RTEMS 4.11Annotated Report
Thu Dec 20 16:07:57 2012
4000ac5c <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
4000ac5c: 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();
4000ac60: 40 00 02 4a call 4000b588 <geteuid>
4000ac64: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000ac68: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000ac6c: 91 2a 20 10 sll %o0, 0x10, %o0
4000ac70: 91 32 20 10 srl %o0, 0x10, %o0
4000ac74: 80 a2 00 01 cmp %o0, %g1
4000ac78: 02 80 00 0a be 4000aca0 <IMFS_chown+0x44>
4000ac7c: 80 a2 20 00 cmp %o0, 0
4000ac80: 22 80 00 09 be,a 4000aca4 <IMFS_chown+0x48> <== NEVER TAKEN
4000ac84: f2 37 60 3c sth %i1, [ %i5 + 0x3c ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
4000ac88: 40 00 0f 79 call 4000ea6c <__errno>
4000ac8c: b0 10 3f ff mov -1, %i0
4000ac90: 82 10 20 01 mov 1, %g1
4000ac94: c2 22 00 00 st %g1, [ %o0 ]
4000ac98: 81 c7 e0 08 ret
4000ac9c: 81 e8 00 00 restore
#endif
jnode->st_uid = owner;
4000aca0: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
4000aca4: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
4000aca8: 90 07 bf f8 add %fp, -8, %o0
4000acac: 7f ff e0 f2 call 40003074 <gettimeofday>
4000acb0: 92 10 20 00 clr %o1
4000acb4: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000acb8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000acbc: 81 c7 e0 08 ret
4000acc0: 91 e8 20 00 restore %g0, 0, %o0
4000505c <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
4000505c: 9d e3 bf a0 save %sp, -96, %sp
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
40005060: 35 10 00 8b sethi %hi(0x40022c00), %i2
40005064: 39 10 00 93 sethi %hi(0x40024c00), %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
40005068: 21 10 00 8b sethi %hi(0x40022c00), %l0
return;
}
puts("");
4000506c: 23 10 00 8b sethi %hi(0x40022c00), %l1
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
40005070: 25 10 00 8b sethi %hi(0x40022c00), %l2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40005074: fa 06 20 50 ld [ %i0 + 0x50 ], %i5
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
40005078: b4 16 a1 b0 or %i2, 0x1b0, %i2
4000507c: b8 17 20 88 or %i4, 0x88, %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
40005080: a0 14 22 20 or %l0, 0x220, %l0
return;
}
puts("");
40005084: a2 14 60 a0 or %l1, 0xa0, %l1
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
40005088: 10 80 00 4d b 400051bc <IMFS_dump_directory+0x160>
4000508c: a4 14 a2 08 or %l2, 0x208, %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
40005090: 90 10 00 1a mov %i2, %o0
40005094: 40 00 37 7d call 40012e88 <fputs>
40005098: b6 06 e0 01 inc %i3
4000509c: 10 80 00 03 b 400050a8 <IMFS_dump_directory+0x4c>
400050a0: c2 07 00 00 ld [ %i4 ], %g1
400050a4: c2 07 00 00 ld [ %i4 ], %g1
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
400050a8: 80 a6 c0 19 cmp %i3, %i1
400050ac: 04 bf ff f9 ble 40005090 <IMFS_dump_directory+0x34>
400050b0: d2 00 60 08 ld [ %g1 + 8 ], %o1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
400050b4: 40 00 37 75 call 40012e88 <fputs>
400050b8: 90 07 60 0c add %i5, 0xc, %o0
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
400050bc: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
400050c0: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
400050c4: 80 a2 a0 06 cmp %o2, 6
400050c8: 38 80 00 2d bgu,a 4000517c <IMFS_dump_directory+0x120> <== NEVER TAKEN
400050cc: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
400050d0: 95 2a a0 02 sll %o2, 2, %o2
400050d4: 03 10 00 14 sethi %hi(0x40005000), %g1
400050d8: 82 10 60 40 or %g1, 0x40, %g1 ! 40005040 <bsp_interrupt_handler_default+0x18>
400050dc: c2 00 40 0a ld [ %g1 + %o2 ], %g1
400050e0: 81 c0 40 00 jmp %g1
400050e4: 01 00 00 00 nop
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
400050e8: c2 07 00 00 ld [ %i4 ], %g1
400050ec: 90 10 20 2f mov 0x2f, %o0
400050f0: 40 00 37 32 call 40012db8 <fputc>
400050f4: d2 00 60 08 ld [ %g1 + 8 ], %o1
400050f8: 30 80 00 26 b,a 40005190 <IMFS_dump_directory+0x134>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
400050fc: c2 07 00 00 ld [ %i4 ], %g1
40005100: 13 10 00 8b sethi %hi(0x40022c00), %o1
40005104: d0 00 60 08 ld [ %g1 + 8 ], %o0
40005108: 92 12 61 b8 or %o1, 0x1b8, %o1
4000510c: 10 80 00 08 b 4000512c <IMFS_dump_directory+0xd0>
40005110: d4 1f 60 50 ldd [ %i5 + 0x50 ], %o2
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
40005114: c2 07 00 00 ld [ %i4 ], %g1
40005118: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
4000511c: d0 00 60 08 ld [ %g1 + 8 ], %o0
40005120: d6 07 60 58 ld [ %i5 + 0x58 ], %o3
40005124: 13 10 00 8b sethi %hi(0x40022c00), %o1
40005128: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 40022dd0 <__FUNCTION__.6193+0x278>
4000512c: 40 00 37 07 call 40012d48 <fprintf>
40005130: 01 00 00 00 nop
40005134: 30 80 00 17 b,a 40005190 <IMFS_dump_directory+0x134>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
40005138: c2 07 00 00 ld [ %i4 ], %g1
4000513c: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
40005140: d0 00 60 08 ld [ %g1 + 8 ], %o0
40005144: 13 10 00 8b sethi %hi(0x40022c00), %o1
40005148: 40 00 37 00 call 40012d48 <fprintf>
4000514c: 92 12 61 e0 or %o1, 0x1e0, %o1 ! 40022de0 <__FUNCTION__.6193+0x288>
40005150: 30 80 00 10 b,a 40005190 <IMFS_dump_directory+0x134>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
40005154: 11 10 00 8b sethi %hi(0x40022c00), %o0
40005158: c2 07 00 00 ld [ %i4 ], %g1
4000515c: 10 80 00 04 b 4000516c <IMFS_dump_directory+0x110>
40005160: 90 12 21 f0 or %o0, 0x1f0, %o0
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
40005164: c2 07 00 00 ld [ %i4 ], %g1
40005168: 90 10 00 12 mov %l2, %o0
4000516c: 40 00 37 47 call 40012e88 <fputs>
40005170: d2 00 60 08 ld [ %g1 + 8 ], %o1
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
40005174: 10 80 00 0a b 4000519c <IMFS_dump_directory+0x140>
40005178: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
4000517c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40005180: 40 00 36 f2 call 40012d48 <fprintf> <== NOT EXECUTED
40005184: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005188: 10 80 00 05 b 4000519c <IMFS_dump_directory+0x140> <== NOT EXECUTED
4000518c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
return;
}
puts("");
40005190: 40 00 3e 25 call 40014a24 <puts>
40005194: 90 10 00 11 mov %l1, %o0
40005198: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
4000519c: c2 00 40 00 ld [ %g1 ], %g1
400051a0: 80 a0 60 00 cmp %g1, 0
400051a4: 32 80 00 06 bne,a 400051bc <IMFS_dump_directory+0x160>
400051a8: fa 07 40 00 ld [ %i5 ], %i5
IMFS_dump_directory( the_jnode, level + 1 );
400051ac: 90 10 00 1d mov %i5, %o0
400051b0: 7f ff ff ab call 4000505c <IMFS_dump_directory>
400051b4: 92 06 60 01 add %i1, 1, %o1
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
400051b8: fa 07 40 00 ld [ %i5 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
400051bc: 82 06 20 54 add %i0, 0x54, %g1
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
400051c0: 80 a7 40 01 cmp %i5, %g1
400051c4: 12 bf ff b8 bne 400050a4 <IMFS_dump_directory+0x48>
400051c8: b6 10 20 00 clr %i3
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
400051cc: 81 c7 e0 08 ret
400051d0: 81 e8 00 00 restore
4000ae00 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
4000ae00: 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;
4000ae04: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
4000ae08: 90 10 00 18 mov %i0, %o0
4000ae0c: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
4000ae10: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
4000ae14: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
4000ae18: 40 00 02 f3 call 4000b9e4 <rtems_filesystem_eval_path_check_access>
4000ae1c: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
4000ae20: 80 8a 20 ff btst 0xff, %o0
4000ae24: 12 80 00 04 bne 4000ae34 <IMFS_eval_token+0x34>
4000ae28: 80 a6 e0 01 cmp %i3, 1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000ae2c: 81 c7 e0 08 ret
4000ae30: 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] == '.';
4000ae34: 12 80 00 06 bne 4000ae4c <IMFS_eval_token+0x4c>
4000ae38: 82 10 20 00 clr %g1
4000ae3c: c2 4e 80 00 ldsb [ %i2 ], %g1
4000ae40: 82 18 60 2e xor %g1, 0x2e, %g1
4000ae44: 80 a0 00 01 cmp %g0, %g1
4000ae48: 82 60 3f ff subx %g0, -1, %g1
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
4000ae4c: 80 a0 60 00 cmp %g1, 0
4000ae50: 12 80 00 2b bne 4000aefc <IMFS_eval_token+0xfc>
4000ae54: 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] == '.';
4000ae58: 12 80 00 0b bne 4000ae84 <IMFS_eval_token+0x84>
4000ae5c: 80 a0 60 00 cmp %g1, 0
4000ae60: c4 4e 80 00 ldsb [ %i2 ], %g2
4000ae64: 80 a0 a0 2e cmp %g2, 0x2e
4000ae68: 12 80 00 07 bne 4000ae84 <IMFS_eval_token+0x84>
4000ae6c: 80 a0 60 00 cmp %g1, 0
4000ae70: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
4000ae74: 82 18 60 2e xor %g1, 0x2e, %g1
4000ae78: 80 a0 00 01 cmp %g0, %g1
4000ae7c: 82 60 3f ff subx %g0, -1, %g1
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
4000ae80: 80 a0 60 00 cmp %g1, 0
4000ae84: 22 80 00 04 be,a 4000ae94 <IMFS_eval_token+0x94>
4000ae88: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
return dir->Parent;
4000ae8c: 10 80 00 17 b 4000aee8 <IMFS_eval_token+0xe8>
4000ae90: fa 07 20 08 ld [ %i4 + 8 ], %i5
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
4000ae94: 10 80 00 10 b 4000aed4 <IMFS_eval_token+0xd4>
4000ae98: b2 07 20 54 add %i4, 0x54, %i1
while ( current != tail ) {
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
4000ae9c: 92 10 00 1a mov %i2, %o1
4000aea0: 40 00 14 ac call 40010150 <strncmp>
4000aea4: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
4000aea8: 80 a2 20 00 cmp %o0, 0
4000aeac: 12 80 00 06 bne 4000aec4 <IMFS_eval_token+0xc4>
4000aeb0: 82 10 20 00 clr %g1
4000aeb4: 82 07 40 1b add %i5, %i3, %g1
4000aeb8: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
4000aebc: 80 a0 00 01 cmp %g0, %g1
4000aec0: 82 60 3f ff subx %g0, -1, %g1
if ( match ) {
4000aec4: 80 a0 60 00 cmp %g1, 0
4000aec8: 12 80 00 09 bne 4000aeec <IMFS_eval_token+0xec>
4000aecc: 80 a7 60 00 cmp %i5, 0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000aed0: 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 ) {
4000aed4: 80 a7 40 19 cmp %i5, %i1
4000aed8: 12 bf ff f1 bne 4000ae9c <IMFS_eval_token+0x9c>
4000aedc: 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;
4000aee0: 81 c7 e0 08 ret
4000aee4: 91 e8 20 02 restore %g0, 2, %o0
);
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
4000aee8: 80 a7 60 00 cmp %i5, 0
4000aeec: 32 80 00 06 bne,a 4000af04 <IMFS_eval_token+0x104>
4000aef0: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
}
}
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
4000aef4: 81 c7 e0 08 ret
4000aef8: 91 e8 20 02 restore %g0, 2, %o0
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
4000aefc: ba 10 00 1c mov %i4, %i5
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
bool terminal = !rtems_filesystem_eval_path_has_path( ctx );
4000af00: c2 06 20 04 ld [ %i0 + 4 ], %g1
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
4000af04: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
4000af08: 80 a0 00 01 cmp %g0, %g1
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
4000af0c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000af10: 84 60 3f ff subx %g0, -1, %g2
4000af14: c2 00 40 00 ld [ %g1 ], %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
4000af18: c0 26 20 0c clr [ %i0 + 0xc ]
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
IMFS_jnode_types_t type = IMFS_type( entry );
rtems_filesystem_eval_path_clear_token( ctx );
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000af1c: 80 a0 60 02 cmp %g1, 2
4000af20: 12 80 00 0a bne 4000af48 <IMFS_eval_token+0x148>
4000af24: 88 10 00 02 mov %g2, %g4
4000af28: 80 a0 a0 00 cmp %g2, 0
4000af2c: 22 80 00 2b be,a 4000afd8 <IMFS_eval_token+0x1d8>
4000af30: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
4000af34: 80 88 e0 08 btst 8, %g3
4000af38: 22 80 00 29 be,a 4000afdc <IMFS_eval_token+0x1dc>
4000af3c: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
entry = entry->info.hard_link.link_node;
4000af40: 10 80 00 26 b 4000afd8 <IMFS_eval_token+0x1d8>
4000af44: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
4000af48: 80 a0 60 03 cmp %g1, 3
4000af4c: 12 80 00 10 bne 4000af8c <IMFS_eval_token+0x18c>
4000af50: 80 a0 60 00 cmp %g1, 0
4000af54: 80 a0 a0 00 cmp %g2, 0
4000af58: 02 80 00 04 be 4000af68 <IMFS_eval_token+0x168>
4000af5c: 80 88 e0 10 btst 0x10, %g3
4000af60: 22 80 00 1f be,a 4000afdc <IMFS_eval_token+0x1dc>
4000af64: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
const char *target = entry->info.sym_link.name;
4000af68: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
4000af6c: 40 00 14 47 call 40010088 <strlen>
4000af70: 90 10 00 1d mov %i5, %o0
4000af74: 92 10 00 1d mov %i5, %o1
4000af78: 94 10 00 08 mov %o0, %o2
4000af7c: 7f ff e4 d7 call 400042d8 <rtems_filesystem_eval_path_recursive>
4000af80: 90 10 00 18 mov %i0, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000af84: 81 c7 e0 08 ret
4000af88: 91 e8 20 01 restore %g0, 1, %o0
IMFS_jnode_types_t type
)
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
4000af8c: 32 80 00 14 bne,a 4000afdc <IMFS_eval_token+0x1dc>
4000af90: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
if ( node->info.directory.mt_fs != NULL ) {
4000af94: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
4000af98: 80 a2 60 00 cmp %o1, 0
4000af9c: 02 80 00 0f be 4000afd8 <IMFS_eval_token+0x1d8>
4000afa0: 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(
4000afa4: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
4000afa8: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
4000afac: d8 17 60 3e lduh [ %i5 + 0x3e ], %o4
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
fs_root_ptr = &node->info.directory.mt_fs->mt_fs_root;
4000afb0: b8 02 60 24 add %o1, 0x24, %i4
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
4000afb4: 40 00 02 8c call 4000b9e4 <rtems_filesystem_eval_path_check_access>
4000afb8: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
4000afbc: 80 8a 20 ff btst 0xff, %o0
4000afc0: 02 80 00 04 be 4000afd0 <IMFS_eval_token+0x1d0> <== NEVER TAKEN
4000afc4: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
4000afc8: 7f ff e4 ab call 40004274 <rtems_filesystem_eval_path_restart>
4000afcc: 92 10 00 1c mov %i4, %o1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000afd0: 81 c7 e0 08 ret
4000afd4: 91 e8 20 01 restore %g0, 1, %o0
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
4000afd8: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
4000afdc: 82 00 7f ff add %g1, -1, %g1
4000afe0: c2 37 20 34 sth %g1, [ %i4 + 0x34 ]
++entry->reference_count;
4000afe4: c2 17 60 34 lduh [ %i5 + 0x34 ], %g1
4000afe8: 82 00 60 01 inc %g1
4000afec: c2 37 60 34 sth %g1, [ %i5 + 0x34 ]
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
4000aff0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
currentloc->node_access = entry;
4000aff4: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
4000aff8: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000affc: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000b000: b0 09 20 ff and %g4, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
4000b004: 81 c7 e0 08 ret
4000b008: 81 e8 00 00 restore
4000b024 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4000b024: 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();
4000b028: 40 00 01 58 call 4000b588 <geteuid>
4000b02c: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000b030: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000b034: 91 2a 20 10 sll %o0, 0x10, %o0
4000b038: 91 32 20 10 srl %o0, 0x10, %o0
4000b03c: 80 a2 00 01 cmp %o0, %g1
4000b040: 02 80 00 0a be 4000b068 <IMFS_fchmod+0x44>
4000b044: 80 a2 20 00 cmp %o0, 0
4000b048: 22 80 00 09 be,a 4000b06c <IMFS_fchmod+0x48> <== NEVER TAKEN
4000b04c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
4000b050: 40 00 0e 87 call 4000ea6c <__errno>
4000b054: b0 10 3f ff mov -1, %i0
4000b058: 82 10 20 01 mov 1, %g1
4000b05c: c2 22 00 00 st %g1, [ %o0 ]
4000b060: 81 c7 e0 08 ret
4000b064: 81 e8 00 00 restore
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4000b068: 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 );
4000b06c: 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);
4000b070: 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 );
4000b074: 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);
4000b078: b2 0e 6f ff and %i1, 0xfff, %i1
4000b07c: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
4000b080: 7f ff df fd call 40003074 <gettimeofday>
4000b084: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
4000b088: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000b08c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000b090: 81 c7 e0 08 ret
4000b094: 91 e8 20 00 restore %g0, 0, %o0
4000325c <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000325c: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
40003260: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
40003264: 96 10 00 18 mov %i0, %o3
40003268: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
4000326c: 92 10 00 19 mov %i1, %o1
40003270: 40 00 28 ed call 4000d624 <pipe_write>
40003274: 94 10 00 1a mov %i2, %o2
if (err > 0) {
40003278: b0 92 20 00 orcc %o0, 0, %i0
4000327c: 04 80 00 09 ble 400032a0 <IMFS_fifo_write+0x44>
40003280: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
40003284: 40 00 03 86 call 4000409c <gettimeofday>
40003288: 92 10 20 00 clr %o1
4000328c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40003290: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
40003294: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
40003298: 81 c7 e0 08 ret
4000329c: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
400032a0: 80 a6 20 00 cmp %i0, 0
400032a4: 02 80 00 06 be 400032bc <IMFS_fifo_write+0x60> <== NEVER TAKEN
400032a8: 01 00 00 00 nop
400032ac: 40 00 34 f3 call 40010678 <__errno>
400032b0: b0 20 00 18 neg %i0
400032b4: f0 22 00 00 st %i0, [ %o0 ]
400032b8: b0 10 3f ff mov -1, %i0
}
400032bc: 81 c7 e0 08 ret
400032c0: 81 e8 00 00 restore
4000b098 <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
)
{
4000b098: 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;
4000b09c: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
4000b0a0: b8 07 bf e8 add %fp, -24, %i4
4000b0a4: 92 10 00 1b mov %i3, %o1
4000b0a8: 90 10 00 1c mov %i4, %o0
4000b0ac: 40 00 10 c1 call 4000f3b0 <memcpy>
4000b0b0: 94 10 20 18 mov 0x18, %o2
jnode = (IMFS_jnode_t *)loc.node_access;
4000b0b4: fa 07 bf f0 ld [ %fp + -16 ], %i5
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
4000b0b8: c0 26 e0 08 clr [ %i3 + 8 ]
4000b0bc: b6 10 00 1c mov %i4, %i3
4000b0c0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
do {
next = jnode->Parent;
4000b0c4: f8 07 60 08 ld [ %i5 + 8 ], %i4
4000b0c8: c4 00 60 04 ld [ %g1 + 4 ], %g2
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b0cc: c2 00 40 00 ld [ %g1 ], %g1
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
4000b0d0: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b0d4: 80 a0 60 00 cmp %g1, 0
4000b0d8: 12 80 00 07 bne 4000b0f4 <IMFS_fsunmount+0x5c>
4000b0dc: c4 27 bf f8 st %g2, [ %fp + -8 ]
4000b0e0: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4000b0e4: 82 07 60 54 add %i5, 0x54, %g1
4000b0e8: 80 a0 80 01 cmp %g2, %g1
4000b0ec: 32 80 00 10 bne,a 4000b12c <IMFS_fsunmount+0x94>
4000b0f0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
result = IMFS_rmnod( NULL, &loc );
4000b0f4: 90 10 20 00 clr %o0
4000b0f8: 7f ff de 55 call 40002a4c <IMFS_rmnod>
4000b0fc: 92 10 00 1b mov %i3, %o1
if ( result != 0 )
4000b100: 80 a2 20 00 cmp %o0, 0
4000b104: 02 80 00 04 be 4000b114 <IMFS_fsunmount+0x7c> <== ALWAYS TAKEN
4000b108: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
4000b10c: 7f ff f1 76 call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000b110: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
IMFS_node_destroy( jnode );
4000b114: 7f ff dd 7c call 40002704 <IMFS_node_destroy>
4000b118: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
4000b11c: 80 a7 20 00 cmp %i4, 0
4000b120: 02 80 00 0e be 4000b158 <IMFS_fsunmount+0xc0>
4000b124: ba 10 00 1c mov %i4, %i5
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
4000b128: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( IMFS_is_directory( jnode ) ) {
4000b12c: c2 00 40 00 ld [ %g1 ], %g1
4000b130: 80 a0 60 00 cmp %g1, 0
4000b134: 32 bf ff e4 bne,a 4000b0c4 <IMFS_fsunmount+0x2c> <== NEVER TAKEN
4000b138: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000b13c: 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 );
4000b140: 84 07 60 54 add %i5, 0x54, %g2
if ( jnode_has_children( jnode ) )
4000b144: 80 a0 40 02 cmp %g1, %g2
4000b148: 02 bf ff de be 4000b0c0 <IMFS_fsunmount+0x28>
4000b14c: 80 a0 60 00 cmp %g1, 0
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
4000b150: 12 bf ff dc bne 4000b0c0 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
4000b154: ba 10 00 01 mov %g1, %i5
4000b158: 81 c7 e0 08 ret
4000b15c: 81 e8 00 00 restore
400025f8 <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]
)
{
400025f8: 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 ) );
400025fc: 90 10 20 01 mov 1, %o0
40002600: 40 00 01 c0 call 40002d00 <calloc>
40002604: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
40002608: ba 92 20 00 orcc %o0, 0, %i5
4000260c: 02 80 00 24 be 4000269c <IMFS_initialize_support+0xa4>
40002610: 03 10 00 77 sethi %hi(0x4001dc00), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
40002614: c4 00 61 e4 ld [ %g1 + 0x1e4 ], %g2 ! 4001dde4 <imfs_instance.6621>
memcpy(
40002618: 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++;
4000261c: c4 27 40 00 st %g2, [ %i5 ]
40002620: 84 00 a0 01 inc %g2
memcpy(
40002624: 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++;
40002628: c4 20 61 e4 st %g2, [ %g1 + 0x1e4 ]
memcpy(
4000262c: 40 00 33 61 call 4000f3b0 <memcpy>
40002630: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
40002634: d2 07 60 08 ld [ %i5 + 8 ], %o1
40002638: 90 10 00 1d mov %i5, %o0
4000263c: 15 10 00 6e sethi %hi(0x4001b800), %o2
40002640: 96 10 20 00 clr %o3
40002644: 94 12 a3 30 or %o2, 0x330, %o2
40002648: 19 00 00 10 sethi %hi(0x4000), %o4
4000264c: 9a 10 20 00 clr %o5
40002650: 40 00 21 9d call 4000acc4 <IMFS_allocate_node>
40002654: 98 13 21 ed or %o4, 0x1ed, %o4
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
40002658: 80 a2 20 00 cmp %o0, 0
4000265c: 02 80 00 10 be 4000269c <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40002660: 03 10 00 71 sethi %hi(0x4001c400), %g1
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
40002664: 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;
40002668: 82 10 60 fc or %g1, 0xfc, %g1
4000266c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40002670: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
40002674: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
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 ]
40002680: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
mt_entry->mt_fs_root->location.node_access = root_node;
40002684: d0 20 60 08 st %o0, [ %g1 + 8 ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
40002688: 86 10 20 06 mov 6, %g3
4000268c: 03 10 00 75 sethi %hi(0x4001d400), %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
40002690: 84 10 20 10 mov 0x10, %g2
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
40002694: 10 80 00 08 b 400026b4 <IMFS_initialize_support+0xbc>
40002698: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
4000269c: 40 00 30 f4 call 4000ea6c <__errno>
400026a0: b0 10 3f ff mov -1, %i0
400026a4: 82 10 20 0c mov 0xc, %g1
400026a8: c2 22 00 00 st %g1, [ %o0 ]
400026ac: 81 c7 e0 08 ret
400026b0: 81 e8 00 00 restore
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
400026b4: 80 a0 80 01 cmp %g2, %g1
400026b8: 22 80 00 09 be,a 400026dc <IMFS_initialize_support+0xe4>
400026bc: 05 10 00 77 sethi %hi(0x4001dc00), %g2
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
400026c0: 34 80 00 06 bg,a 400026d8 <IMFS_initialize_support+0xe0>
400026c4: 82 10 20 80 mov 0x80, %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
400026c8: 86 80 ff ff addcc %g3, -1, %g3
400026cc: 12 bf ff fa bne 400026b4 <IMFS_initialize_support+0xbc> <== ALWAYS TAKEN
400026d0: 85 28 a0 01 sll %g2, 1, %g2
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
400026d4: 82 10 20 80 mov 0x80, %g1 <== NOT EXECUTED
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
400026d8: 05 10 00 77 sethi %hi(0x4001dc00), %g2
400026dc: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] ! 4001dde0 <imfs_memfile_bytes_per_block>
400026e0: b0 10 20 00 clr %i0
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
400026e4: 81 c7 e0 08 ret
400026e8: 81 e8 00 00 restore
400042c4 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
400042c4: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
400042c8: 03 10 00 67 sethi %hi(0x40019c00), %g1
400042cc: c2 00 61 f8 ld [ %g1 + 0x1f8 ], %g1 ! 40019df8 <rtems_current_user_env>
switch (mode & S_IFMT) {
400042d0: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
400042d4: c2 00 60 08 ld [ %g1 + 8 ], %g1
400042d8: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
400042dc: 03 00 00 3c sethi %hi(0xf000), %g1
400042e0: 82 0e 40 01 and %i1, %g1, %g1
400042e4: 80 a0 40 02 cmp %g1, %g2
400042e8: 22 80 00 3a be,a 400043d0 <IMFS_make_generic_node+0x10c>
400042ec: c2 06 80 00 ld [ %i2 ], %g1
400042f0: 38 80 00 04 bgu,a 40004300 <IMFS_make_generic_node+0x3c> <== ALWAYS TAKEN
400042f4: 05 00 00 18 sethi %hi(0x6000), %g2
400042f8: 10 80 00 05 b 4000430c <IMFS_make_generic_node+0x48> <== NOT EXECUTED
400042fc: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
40004300: 80 a0 40 02 cmp %g1, %g2
40004304: 02 80 00 32 be 400043cc <IMFS_make_generic_node+0x108>
40004308: 05 00 00 20 sethi %hi(0x8000), %g2
4000430c: 80 a0 40 02 cmp %g1, %g2
40004310: 22 80 00 30 be,a 400043d0 <IMFS_make_generic_node+0x10c> <== NEVER TAKEN
40004314: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
40004318: 30 80 00 27 b,a 400043b4 <IMFS_make_generic_node+0xf0>
if ( node_control->imfs_type == IMFS_GENERIC ) {
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE;
const rtems_filesystem_location_info_t *currentloc =
4000431c: 94 10 20 78 mov 0x78, %o2
40004320: 40 00 07 4e call 40006058 <rtems_filesystem_eval_path_start>
40004324: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
40004328: 7f ff ff d5 call 4000427c <IMFS_is_imfs_instance>
4000432c: ba 10 00 08 mov %o0, %i5
40004330: 80 8a 20 ff btst 0xff, %o0
40004334: 02 80 00 19 be 40004398 <IMFS_make_generic_node+0xd4>
40004338: 90 07 bf c8 add %fp, -56, %o0
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
new_node = IMFS_create_node_with_control(
4000433c: d4 1f bf d0 ldd [ %fp + -48 ], %o2
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
40004340: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
40004344: 90 10 00 1d mov %i5, %o0
40004348: 92 10 00 1a mov %i2, %o1
4000434c: 98 10 00 19 mov %i1, %o4
40004350: 9a 07 bf b0 add %fp, -80, %o5
40004354: 40 00 2c 4c call 4000f484 <IMFS_create_node_with_control>
40004358: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
4000435c: 80 a2 20 00 cmp %o0, 0
40004360: 02 80 00 11 be 400043a4 <IMFS_make_generic_node+0xe0>
40004364: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
40004368: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
4000436c: 40 00 02 08 call 40004b8c <gettimeofday>
40004370: 90 07 bf a8 add %fp, -88, %o0
40004374: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
40004378: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
4000437c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
40004380: 40 00 02 03 call 40004b8c <gettimeofday>
40004384: 92 10 20 00 clr %o1
40004388: c2 07 bf a8 ld [ %fp + -88 ], %g1
4000438c: b0 10 20 00 clr %i0
40004390: 10 80 00 05 b 400043a4 <IMFS_make_generic_node+0xe0>
40004394: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40004398: 92 10 20 86 mov 0x86, %o1
4000439c: 40 00 06 99 call 40005e00 <rtems_filesystem_eval_path_error>
400043a0: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
400043a4: 40 00 07 69 call 40006148 <rtems_filesystem_eval_path_cleanup>
400043a8: 90 07 bf c8 add %fp, -56, %o0
400043ac: 81 c7 e0 08 ret
400043b0: 81 e8 00 00 restore
} else {
errno = EINVAL;
400043b4: 40 00 3c 0c call 400133e4 <__errno>
400043b8: b0 10 3f ff mov -1, %i0
400043bc: 82 10 20 16 mov 0x16, %g1
400043c0: c2 22 00 00 st %g1, [ %o0 ]
400043c4: 81 c7 e0 08 ret
400043c8: 81 e8 00 00 restore
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
400043cc: c2 06 80 00 ld [ %i2 ], %g1
400043d0: 80 a0 60 07 cmp %g1, 7
400043d4: 02 bf ff d2 be 4000431c <IMFS_make_generic_node+0x58>
400043d8: 92 10 00 18 mov %i0, %o1
400043dc: 30 bf ff f6 b,a 400043b4 <IMFS_make_generic_node+0xf0>
4000d5fc <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000d5fc: 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 );
4000d600: 94 10 20 01 mov 1, %o2
4000d604: 90 10 00 18 mov %i0, %o0
4000d608: 7f ff fe d7 call 4000d164 <IMFS_memfile_get_block_pointer>
4000d60c: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
4000d610: 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 );
4000d614: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
4000d618: 80 a0 60 00 cmp %g1, 0
4000d61c: 12 80 00 08 bne 4000d63c <IMFS_memfile_addblock+0x40>
4000d620: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
4000d624: 7f ff fe c3 call 4000d130 <memfile_alloc_block>
4000d628: 01 00 00 00 nop
if ( !memory )
4000d62c: 80 a2 20 00 cmp %o0, 0
4000d630: 22 80 00 03 be,a 4000d63c <IMFS_memfile_addblock+0x40> <== NEVER TAKEN
4000d634: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
*block_entry_ptr = memory;
4000d638: d0 27 40 00 st %o0, [ %i5 ]
return 0;
4000d63c: 81 c7 e0 08 ret
4000d640: 81 e8 00 00 restore
4000d810 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
4000d810: 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 )
4000d814: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d818: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 4001dde0 <imfs_memfile_bytes_per_block>
4000d81c: b9 37 60 02 srl %i5, 2, %i4
4000d820: 92 10 00 1c mov %i4, %o1
4000d824: 40 00 28 c7 call 40017b40 <.umul>
4000d828: 90 07 20 01 add %i4, 1, %o0
4000d82c: 92 10 00 1c mov %i4, %o1
4000d830: 40 00 28 c4 call 40017b40 <.umul>
4000d834: 90 02 20 01 inc %o0
4000d838: 92 10 00 1d mov %i5, %o1
4000d83c: 40 00 28 c1 call 40017b40 <.umul>
4000d840: 90 02 3f ff add %o0, -1, %o0
4000d844: 82 10 20 00 clr %g1
4000d848: 80 a0 40 1a cmp %g1, %i2
4000d84c: 34 80 00 0b bg,a 4000d878 <IMFS_memfile_extend+0x68> <== NEVER TAKEN
4000d850: f8 06 20 50 ld [ %i0 + 0x50 ], %i4 <== NOT EXECUTED
4000d854: 80 a0 40 1a cmp %g1, %i2
4000d858: 12 80 00 04 bne 4000d868 <IMFS_memfile_extend+0x58> <== NEVER TAKEN
4000d85c: 80 a2 00 1b cmp %o0, %i3
4000d860: 38 80 00 06 bgu,a 4000d878 <IMFS_memfile_extend+0x68>
4000d864: f8 06 20 50 ld [ %i0 + 0x50 ], %i4
rtems_set_errno_and_return_minus_one( EFBIG );
4000d868: 40 00 04 81 call 4000ea6c <__errno>
4000d86c: 01 00 00 00 nop
4000d870: 10 80 00 3c b 4000d960 <IMFS_memfile_extend+0x150>
4000d874: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
4000d878: 80 a6 80 1c cmp %i2, %i4
4000d87c: 14 80 00 07 bg 4000d898 <IMFS_memfile_extend+0x88> <== NEVER TAKEN
4000d880: e0 06 20 54 ld [ %i0 + 0x54 ], %l0
4000d884: 80 a6 80 1c cmp %i2, %i4
4000d888: 12 80 00 48 bne 4000d9a8 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
4000d88c: 80 a6 c0 10 cmp %i3, %l0
4000d890: 08 80 00 46 bleu 4000d9a8 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
4000d894: 01 00 00 00 nop
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d898: a3 3f 60 1f sra %i5, 0x1f, %l1
4000d89c: 96 10 00 1d mov %i5, %o3
4000d8a0: 94 10 00 11 mov %l1, %o2
4000d8a4: 90 10 00 1a mov %i2, %o0
4000d8a8: 40 00 2a 38 call 40018188 <__divdi3>
4000d8ac: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d8b0: 94 10 00 11 mov %l1, %o2
4000d8b4: 90 10 00 1c mov %i4, %o0
4000d8b8: 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;
4000d8bc: a4 10 00 09 mov %o1, %l2
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d8c0: 40 00 2a 32 call 40018188 <__divdi3>
4000d8c4: 92 10 00 10 mov %l0, %o1
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000d8c8: a2 10 20 00 clr %l1
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d8cc: 90 10 00 09 mov %o1, %o0
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d8d0: b8 10 00 09 mov %o1, %i4
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
4000d8d4: 27 10 00 77 sethi %hi(0x4001dc00), %l3
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d8d8: 40 00 28 9a call 40017b40 <.umul>
4000d8dc: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000d8e0: 10 80 00 23 b 4000d96c <IMFS_memfile_extend+0x15c>
4000d8e4: a0 24 00 08 sub %l0, %o0, %l0
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
4000d8e8: 7f ff ff 45 call 4000d5fc <IMFS_memfile_addblock>
4000d8ec: 92 10 00 1d mov %i5, %o1
4000d8f0: 80 a2 20 00 cmp %o0, 0
4000d8f4: 12 80 00 15 bne 4000d948 <IMFS_memfile_extend+0x138> <== NEVER TAKEN
4000d8f8: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
4000d8fc: 22 80 00 1c be,a 4000d96c <IMFS_memfile_extend+0x15c>
4000d900: a2 04 60 01 inc %l1
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
4000d904: e8 04 e1 e0 ld [ %l3 + 0x1e0 ], %l4
block_p *block_ptr =
4000d908: 92 10 00 1d mov %i5, %o1
4000d90c: 94 10 20 00 clr %o2
4000d910: 7f ff fe 15 call 4000d164 <IMFS_memfile_get_block_pointer>
4000d914: 90 10 00 18 mov %i0, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
4000d918: 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;
4000d91c: a8 25 00 10 sub %l4, %l0, %l4
block_p *block_ptr =
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
4000d920: 90 02 00 10 add %o0, %l0, %o0
4000d924: 92 10 20 00 clr %o1
4000d928: 94 10 00 14 mov %l4, %o2
4000d92c: 40 00 06 de call 4000f4a4 <memset>
4000d930: a0 10 20 00 clr %l0
4000d934: 10 80 00 0e b 4000d96c <IMFS_memfile_extend+0x15c>
4000d938: a2 04 60 01 inc %l1
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
4000d93c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d940: 7f ff ff a8 call 4000d7e0 <IMFS_memfile_remove_block> <== NOT EXECUTED
4000d944: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
4000d948: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000d94c: 1a bf ff fc bcc 4000d93c <IMFS_memfile_extend+0x12c> <== NOT EXECUTED
4000d950: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
4000d954: 40 00 04 46 call 4000ea6c <__errno> <== NOT EXECUTED
4000d958: 01 00 00 00 nop <== NOT EXECUTED
4000d95c: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
4000d960: c2 22 00 00 st %g1, [ %o0 ]
4000d964: 81 c7 e0 08 ret
4000d968: 91 e8 3f ff restore %g0, -1, %o0
*
* This routine insures that the in-memory file is of the length
* specified. If necessary, it will allocate memory blocks to
* extend the file.
*/
MEMFILE_STATIC int IMFS_memfile_extend(
4000d96c: ba 04 40 1c add %l1, %i4, %i5
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000d970: 80 a7 40 12 cmp %i5, %l2
4000d974: 08 bf ff dd bleu 4000d8e8 <IMFS_memfile_extend+0xd8>
4000d978: 90 10 00 18 mov %i0, %o0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
4000d97c: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
4000d980: f4 3e 20 50 std %i2, [ %i0 + 0x50 ]
IMFS_update_ctime(the_jnode);
4000d984: 7f ff d5 bc call 40003074 <gettimeofday>
4000d988: 90 07 bf f8 add %fp, -8, %o0
4000d98c: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
4000d990: 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);
4000d994: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime(the_jnode);
4000d998: 7f ff d5 b7 call 40003074 <gettimeofday>
4000d99c: 92 10 20 00 clr %o1
4000d9a0: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000d9a4: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
return 0;
}
4000d9a8: 81 c7 e0 08 ret
4000d9ac: 91 e8 20 00 restore %g0, 0, %o0
4000d164 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4000d164: 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 ) {
4000d168: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d16c: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 4001dde0 <imfs_memfile_bytes_per_block>
4000d170: bb 37 60 02 srl %i5, 2, %i5
4000d174: 82 07 7f ff add %i5, -1, %g1
4000d178: 80 a6 40 01 cmp %i1, %g1
4000d17c: 18 80 00 18 bgu 4000d1dc <IMFS_memfile_get_block_pointer+0x78>
4000d180: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
4000d184: 80 a6 a0 00 cmp %i2, 0
4000d188: 02 80 00 10 be 4000d1c8 <IMFS_memfile_get_block_pointer+0x64>
4000d18c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
if ( !p ) {
4000d190: 80 a0 60 00 cmp %g1, 0
4000d194: 32 80 00 0a bne,a 4000d1bc <IMFS_memfile_get_block_pointer+0x58>
4000d198: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
p = memfile_alloc_block();
4000d19c: 7f ff ff e5 call 4000d130 <memfile_alloc_block>
4000d1a0: 01 00 00 00 nop
if ( !p )
4000d1a4: 80 a2 20 00 cmp %o0, 0
4000d1a8: 32 80 00 04 bne,a 4000d1b8 <IMFS_memfile_get_block_pointer+0x54><== ALWAYS TAKEN
4000d1ac: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
return 0;
4000d1b0: 81 c7 e0 08 ret <== NOT EXECUTED
4000d1b4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->indirect = p;
}
return &info->indirect[ my_block ];
4000d1b8: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
4000d1bc: b3 2e 60 02 sll %i1, 2, %i1
4000d1c0: 81 c7 e0 08 ret
4000d1c4: 91 ee 00 19 restore %i0, %i1, %o0
}
if ( !p )
4000d1c8: 80 a0 60 00 cmp %g1, 0
4000d1cc: 02 bf ff f9 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d1d0: b3 2e 60 02 sll %i1, 2, %i1
return 0;
return &info->indirect[ my_block ];
4000d1d4: 81 c7 e0 08 ret
4000d1d8: 91 e8 40 19 restore %g1, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4000d1dc: 40 00 2a 59 call 40017b40 <.umul>
4000d1e0: 92 10 00 1d mov %i5, %o1
4000d1e4: 82 02 3f ff add %o0, -1, %g1
4000d1e8: 80 a6 40 01 cmp %i1, %g1
4000d1ec: 18 80 00 2c bgu 4000d29c <IMFS_memfile_get_block_pointer+0x138>
4000d1f0: b8 10 00 08 mov %o0, %i4
my_block -= FIRST_DOUBLY_INDIRECT;
4000d1f4: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000d1f8: 92 10 00 1d mov %i5, %o1
4000d1fc: 40 00 2b 37 call 40017ed8 <.urem>
4000d200: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000d204: 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;
4000d208: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000d20c: 40 00 2a 87 call 40017c28 <.udiv>
4000d210: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
if ( malloc_it ) {
4000d214: 80 a6 a0 00 cmp %i2, 0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000d218: ba 10 00 08 mov %o0, %i5
p = info->doubly_indirect;
if ( malloc_it ) {
4000d21c: 02 80 00 17 be 4000d278 <IMFS_memfile_get_block_pointer+0x114>
4000d220: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !p ) {
4000d224: 80 a2 20 00 cmp %o0, 0
4000d228: 12 80 00 08 bne 4000d248 <IMFS_memfile_get_block_pointer+0xe4>
4000d22c: bb 2f 60 02 sll %i5, 2, %i5
p = memfile_alloc_block();
4000d230: 7f ff ff c0 call 4000d130 <memfile_alloc_block>
4000d234: 01 00 00 00 nop
if ( !p )
4000d238: 80 a2 20 00 cmp %o0, 0
4000d23c: 02 bf ff dd be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d240: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
4000d244: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
}
p1 = (block_p *)p[ doubly ];
4000d248: b6 02 00 1d add %o0, %i5, %i3
4000d24c: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p1 ) {
4000d250: 80 a2 20 00 cmp %o0, 0
4000d254: 12 80 00 4a bne 4000d37c <IMFS_memfile_get_block_pointer+0x218>
4000d258: b1 2f 20 02 sll %i4, 2, %i0
p1 = memfile_alloc_block();
4000d25c: 7f ff ff b5 call 4000d130 <memfile_alloc_block>
4000d260: 01 00 00 00 nop
if ( !p1 )
4000d264: 80 a2 20 00 cmp %o0, 0
4000d268: 02 bf ff d2 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d26c: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
4000d270: 10 80 00 43 b 4000d37c <IMFS_memfile_get_block_pointer+0x218>
4000d274: d0 26 c0 00 st %o0, [ %i3 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4000d278: 80 a2 20 00 cmp %o0, 0
4000d27c: 02 bf ff cd be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d280: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
4000d284: c2 02 00 1d ld [ %o0 + %i5 ], %g1
if ( !p )
4000d288: 80 a0 60 00 cmp %g1, 0
4000d28c: 02 bf ff c9 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d290: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
4000d294: 10 80 00 48 b 4000d3b4 <IMFS_memfile_get_block_pointer+0x250>
4000d298: b1 2f 20 02 sll %i4, 2, %i0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4000d29c: 90 02 20 01 inc %o0
4000d2a0: 40 00 2a 28 call 40017b40 <.umul>
4000d2a4: 92 10 00 1d mov %i5, %o1
4000d2a8: 90 02 3f ff add %o0, -1, %o0
4000d2ac: 80 a6 40 08 cmp %i1, %o0
4000d2b0: 18 bf ff c0 bgu 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d2b4: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000d2b8: 92 10 00 1d mov %i5, %o1
4000d2bc: 40 00 2b 07 call 40017ed8 <.urem>
4000d2c0: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000d2c4: 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;
4000d2c8: b6 10 00 08 mov %o0, %i3
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000d2cc: 40 00 2a 57 call 40017c28 <.udiv>
4000d2d0: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4000d2d4: 92 10 00 1d mov %i5, %o1
4000d2d8: 40 00 2a 54 call 40017c28 <.udiv>
4000d2dc: b2 10 00 08 mov %o0, %i1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000d2e0: 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;
4000d2e4: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000d2e8: 40 00 2a fc call 40017ed8 <.urem>
4000d2ec: 90 10 00 19 mov %i1, %o0
p = info->triply_indirect;
if ( malloc_it ) {
4000d2f0: 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;
4000d2f4: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
4000d2f8: 02 80 00 23 be 4000d384 <IMFS_memfile_get_block_pointer+0x220>
4000d2fc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
4000d300: 80 a2 20 00 cmp %o0, 0
4000d304: 12 80 00 08 bne 4000d324 <IMFS_memfile_get_block_pointer+0x1c0>
4000d308: b9 2f 20 02 sll %i4, 2, %i4
p = memfile_alloc_block();
4000d30c: 7f ff ff 89 call 4000d130 <memfile_alloc_block>
4000d310: 01 00 00 00 nop
if ( !p )
4000d314: 80 a2 20 00 cmp %o0, 0
4000d318: 02 bf ff a6 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d31c: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
4000d320: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
}
p1 = (block_p *) p[ triply ];
4000d324: b4 02 00 1c add %o0, %i4, %i2
4000d328: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p1 ) {
4000d32c: 80 a2 20 00 cmp %o0, 0
4000d330: 12 80 00 08 bne 4000d350 <IMFS_memfile_get_block_pointer+0x1ec>
4000d334: bb 2f 60 02 sll %i5, 2, %i5
p1 = memfile_alloc_block();
4000d338: 7f ff ff 7e call 4000d130 <memfile_alloc_block>
4000d33c: 01 00 00 00 nop
if ( !p1 )
4000d340: 80 a2 20 00 cmp %o0, 0
4000d344: 02 bf ff 9b be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d348: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
4000d34c: d0 26 80 00 st %o0, [ %i2 ]
}
p2 = (block_p *)p1[ doubly ];
4000d350: b8 02 00 1d add %o0, %i5, %i4
4000d354: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p2 ) {
4000d358: 80 a2 20 00 cmp %o0, 0
4000d35c: 12 80 00 08 bne 4000d37c <IMFS_memfile_get_block_pointer+0x218>
4000d360: b1 2e e0 02 sll %i3, 2, %i0
p2 = memfile_alloc_block();
4000d364: 7f ff ff 73 call 4000d130 <memfile_alloc_block>
4000d368: 01 00 00 00 nop
if ( !p2 )
4000d36c: 80 a2 20 00 cmp %o0, 0
4000d370: 02 bf ff 90 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d374: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
4000d378: d0 27 00 00 st %o0, [ %i4 ]
}
return (block_p *)&p2[ singly ];
4000d37c: 81 c7 e0 08 ret
4000d380: 91 ea 00 18 restore %o0, %i0, %o0
}
if ( !p )
4000d384: 80 a2 20 00 cmp %o0, 0
4000d388: 02 bf ff 8a be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d38c: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p1 = (block_p *) p[ triply ];
4000d390: c2 02 00 1c ld [ %o0 + %i4 ], %g1
if ( !p1 )
4000d394: 80 a0 60 00 cmp %g1, 0
4000d398: 02 bf ff 86 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d39c: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
4000d3a0: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
4000d3a4: 80 a0 60 00 cmp %g1, 0
4000d3a8: 02 bf ff 82 be 4000d1b0 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000d3ac: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
4000d3b0: b1 2e e0 02 sll %i3, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
4000d3b4: 81 c7 e0 08 ret
4000d3b8: 91 e8 40 18 restore %g1, %i0, %o0
4000d3bc <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000d3bc: 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;
4000d3c0: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
4000d3c4: ba 10 00 18 mov %i0, %i5
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
4000d3c8: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000d3cc: a0 10 00 19 mov %i1, %l0
4000d3d0: 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 ) {
4000d3d4: 80 a0 60 05 cmp %g1, 5
4000d3d8: 12 80 00 17 bne 4000d434 <IMFS_memfile_read+0x78>
4000d3dc: a4 10 00 1b mov %i3, %l2
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
4000d3e0: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
4000d3e4: 82 10 20 00 clr %g1
4000d3e8: 86 a6 c0 11 subcc %i3, %l1, %g3
4000d3ec: 84 66 80 19 subx %i2, %i1, %g2
4000d3f0: 80 a0 40 02 cmp %g1, %g2
4000d3f4: 14 80 00 07 bg 4000d410 <IMFS_memfile_read+0x54> <== NEVER TAKEN
4000d3f8: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
4000d3fc: 80 a0 40 02 cmp %g1, %g2
4000d400: 12 80 00 06 bne 4000d418 <IMFS_memfile_read+0x5c> <== NEVER TAKEN
4000d404: 80 a7 00 03 cmp %i4, %g3
4000d408: 28 80 00 05 bleu,a 4000d41c <IMFS_memfile_read+0x60> <== NEVER TAKEN
4000d40c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
4000d410: 10 80 00 03 b 4000d41c <IMFS_memfile_read+0x60>
4000d414: 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;
4000d418: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
4000d41c: 90 10 00 12 mov %l2, %o0
4000d420: 92 02 40 11 add %o1, %l1, %o1
4000d424: 40 00 07 e3 call 4000f3b0 <memcpy>
4000d428: 94 10 00 18 mov %i0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000d42c: 10 80 00 5d b 4000d5a0 <IMFS_memfile_read+0x1e4>
4000d430: 90 07 bf f8 add %fp, -8, %o0
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
4000d434: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
4000d438: 88 10 20 00 clr %g4
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
4000d43c: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
4000d440: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
4000d444: 80 a1 00 03 cmp %g4, %g3
4000d448: 14 80 00 08 bg 4000d468 <IMFS_memfile_read+0xac> <== NEVER TAKEN
4000d44c: b6 07 00 1a add %i4, %i2, %i3
4000d450: 80 a1 00 03 cmp %g4, %g3
4000d454: 32 80 00 07 bne,a 4000d470 <IMFS_memfile_read+0xb4> <== NEVER TAKEN
4000d458: 03 10 00 77 sethi %hi(0x4001dc00), %g1 <== NOT EXECUTED
4000d45c: 80 a6 c0 02 cmp %i3, %g2
4000d460: 28 80 00 04 bleu,a 4000d470 <IMFS_memfile_read+0xb4>
4000d464: 03 10 00 77 sethi %hi(0x4001dc00), %g1
my_length = the_jnode->info.file.size - start;
4000d468: b8 20 80 01 sub %g2, %g1, %i4
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d46c: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d470: f6 00 61 e0 ld [ %g1 + 0x1e0 ], %i3 ! 4001dde0 <imfs_memfile_bytes_per_block>
4000d474: 90 10 00 10 mov %l0, %o0
4000d478: b5 3e e0 1f sra %i3, 0x1f, %i2
4000d47c: 96 10 00 1b mov %i3, %o3
4000d480: 94 10 00 1a mov %i2, %o2
4000d484: 40 00 2c 2c call 40018534 <__moddi3>
4000d488: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d48c: 94 10 00 1a mov %i2, %o2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d490: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d494: 90 10 00 10 mov %l0, %o0
4000d498: 92 10 00 11 mov %l1, %o1
4000d49c: 40 00 2b 3b call 40018188 <__divdi3>
4000d4a0: 96 10 00 1b mov %i3, %o3
if ( start_offset ) {
4000d4a4: 80 a4 e0 00 cmp %l3, 0
4000d4a8: 02 80 00 18 be 4000d508 <IMFS_memfile_read+0x14c>
4000d4ac: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000d4b0: b6 26 c0 13 sub %i3, %l3, %i3
4000d4b4: 80 a7 00 1b cmp %i4, %i3
4000d4b8: 08 80 00 03 bleu 4000d4c4 <IMFS_memfile_read+0x108>
4000d4bc: b2 10 00 1c mov %i4, %i1
4000d4c0: b2 10 00 1b mov %i3, %i1
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000d4c4: 90 10 00 1d mov %i5, %o0
4000d4c8: 92 10 00 1a mov %i2, %o1
4000d4cc: 94 10 20 00 clr %o2
4000d4d0: 7f ff ff 25 call 4000d164 <IMFS_memfile_get_block_pointer>
4000d4d4: b0 10 20 00 clr %i0
if ( !block_ptr )
4000d4d8: 80 a2 20 00 cmp %o0, 0
4000d4dc: 02 80 00 35 be 4000d5b0 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
4000d4e0: 94 10 00 19 mov %i1, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4000d4e4: d2 02 00 00 ld [ %o0 ], %o1
4000d4e8: 90 10 00 12 mov %l2, %o0
4000d4ec: 92 02 40 13 add %o1, %l3, %o1
4000d4f0: 40 00 07 b0 call 4000f3b0 <memcpy>
4000d4f4: a4 04 80 19 add %l2, %i1, %l2
dest += to_copy;
block++;
4000d4f8: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000d4fc: b8 27 00 19 sub %i4, %i1, %i4
copied += to_copy;
4000d500: 10 80 00 03 b 4000d50c <IMFS_memfile_read+0x150>
4000d504: b0 10 00 19 mov %i1, %i0
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
4000d508: b0 10 20 00 clr %i0
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d50c: 03 10 00 77 sethi %hi(0x4001dc00), %g1
* is considered an error. Read from an offset for more bytes than
* are between the offset and the end of the file will result in
* reading the data between offset and the end of the file (truncated
* read).
*/
MEMFILE_STATIC ssize_t IMFS_memfile_read(
4000d510: a4 24 80 18 sub %l2, %i0, %l2
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d514: f6 00 61 e0 ld [ %g1 + 0x1e0 ], %i3
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000d518: 10 80 00 0f b 4000d554 <IMFS_memfile_read+0x198>
4000d51c: a0 10 00 01 mov %g1, %l0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000d520: 90 10 00 1d mov %i5, %o0
4000d524: 92 10 00 1a mov %i2, %o1
4000d528: 7f ff ff 0f call 4000d164 <IMFS_memfile_get_block_pointer>
4000d52c: 94 10 20 00 clr %o2
if ( !block_ptr )
4000d530: 82 92 20 00 orcc %o0, 0, %g1
4000d534: 02 80 00 1f be 4000d5b0 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
4000d538: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4000d53c: d2 00 40 00 ld [ %g1 ], %o1
4000d540: 94 10 00 1b mov %i3, %o2
4000d544: 40 00 07 9b call 4000f3b0 <memcpy>
4000d548: b4 06 a0 01 inc %i2
dest += to_copy;
block++;
my_length -= to_copy;
4000d54c: b8 27 00 1b sub %i4, %i3, %i4
copied += to_copy;
4000d550: b0 06 00 1b add %i0, %i3, %i0
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000d554: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1
4000d558: 80 a7 00 01 cmp %i4, %g1
4000d55c: 1a bf ff f1 bcc 4000d520 <IMFS_memfile_read+0x164>
4000d560: b2 04 80 18 add %l2, %i0, %i1
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
4000d564: 80 a7 20 00 cmp %i4, 0
4000d568: 02 80 00 0e be 4000d5a0 <IMFS_memfile_read+0x1e4>
4000d56c: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000d570: 90 10 00 1d mov %i5, %o0
4000d574: 92 10 00 1a mov %i2, %o1
4000d578: 7f ff fe fb call 4000d164 <IMFS_memfile_get_block_pointer>
4000d57c: 94 10 20 00 clr %o2
if ( !block_ptr )
4000d580: 82 92 20 00 orcc %o0, 0, %g1
4000d584: 02 80 00 0b be 4000d5b0 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
4000d588: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4000d58c: d2 00 40 00 ld [ %g1 ], %o1
4000d590: 94 10 00 1c mov %i4, %o2
4000d594: 40 00 07 87 call 4000f3b0 <memcpy>
4000d598: b0 07 00 18 add %i4, %i0, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000d59c: 90 07 bf f8 add %fp, -8, %o0
4000d5a0: 7f ff d6 b5 call 40003074 <gettimeofday>
4000d5a4: 92 10 20 00 clr %o1
4000d5a8: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000d5ac: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return copied;
}
4000d5b0: 81 c7 e0 08 ret
4000d5b4: 81 e8 00 00 restore
4000d6b4 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4000d6b4: 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;
4000d6b8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d6bc: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 4001dde0 <imfs_memfile_bytes_per_block>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4000d6c0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4000d6c4: 80 a0 60 00 cmp %g1, 0
4000d6c8: 02 80 00 05 be 4000d6dc <IMFS_memfile_remove+0x28>
4000d6cc: bb 37 60 02 srl %i5, 2, %i5
memfile_free_blocks_in_table( &info->indirect, to_free );
4000d6d0: 90 06 20 58 add %i0, 0x58, %o0
4000d6d4: 7f ff ff e5 call 4000d668 <memfile_free_blocks_in_table>
4000d6d8: 92 10 00 1d mov %i5, %o1
}
if ( info->doubly_indirect ) {
4000d6dc: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000d6e0: b8 10 20 00 clr %i4
4000d6e4: 80 a0 60 00 cmp %g1, 0
4000d6e8: 12 80 00 0d bne 4000d71c <IMFS_memfile_remove+0x68>
4000d6ec: 37 10 00 77 sethi %hi(0x4001dc00), %i3
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
4000d6f0: 10 80 00 15 b 4000d744 <IMFS_memfile_remove+0x90>
4000d6f4: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
4000d6f8: 83 2f 20 02 sll %i4, 2, %g1
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
4000d6fc: 90 00 80 01 add %g2, %g1, %o0
4000d700: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000d704: 80 a0 60 00 cmp %g1, 0
4000d708: 22 80 00 05 be,a 4000d71c <IMFS_memfile_remove+0x68> <== NEVER TAKEN
4000d70c: b8 07 20 01 inc %i4 <== NOT EXECUTED
memfile_free_blocks_in_table(
4000d710: 7f ff ff d6 call 4000d668 <memfile_free_blocks_in_table>
4000d714: 92 10 00 1d mov %i5, %o1
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000d718: b8 07 20 01 inc %i4
4000d71c: c2 06 e1 e0 ld [ %i3 + 0x1e0 ], %g1
4000d720: 83 30 60 02 srl %g1, 2, %g1
4000d724: 80 a7 00 01 cmp %i4, %g1
4000d728: 2a bf ff f4 bcs,a 4000d6f8 <IMFS_memfile_remove+0x44>
4000d72c: c4 06 20 5c ld [ %i0 + 0x5c ], %g2
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
4000d730: 90 06 20 5c add %i0, 0x5c, %o0
4000d734: 7f ff ff cd call 4000d668 <memfile_free_blocks_in_table>
4000d738: 92 10 00 1d mov %i5, %o1
}
if ( info->triply_indirect ) {
4000d73c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
4000d740: b8 10 20 00 clr %i4
4000d744: 80 a0 60 00 cmp %g1, 0
4000d748: 12 80 00 1c bne 4000d7b8 <IMFS_memfile_remove+0x104>
4000d74c: 33 10 00 77 sethi %hi(0x4001dc00), %i1
4000d750: 81 c7 e0 08 ret
4000d754: 81 e8 00 00 restore
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
4000d758: a1 2f 20 02 sll %i4, 2, %l0
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4000d75c: f6 00 40 10 ld [ %g1 + %l0 ], %i3
if ( !p ) /* ensure we have a valid pointer */
4000d760: 80 a6 e0 00 cmp %i3, 0
4000d764: 02 80 00 1b be 4000d7d0 <IMFS_memfile_remove+0x11c> <== NEVER TAKEN
4000d768: 90 06 20 60 add %i0, 0x60, %o0
4000d76c: 10 80 00 09 b 4000d790 <IMFS_memfile_remove+0xdc>
4000d770: b4 10 20 00 clr %i2
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
4000d774: 80 a0 60 00 cmp %g1, 0
4000d778: 02 80 00 04 be 4000d788 <IMFS_memfile_remove+0xd4> <== NEVER TAKEN
4000d77c: 90 10 00 1b mov %i3, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4000d780: 7f ff ff ba call 4000d668 <memfile_free_blocks_in_table>
4000d784: 92 10 00 1d mov %i5, %o1
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
4000d788: b4 06 a0 01 inc %i2
4000d78c: b6 06 e0 04 add %i3, 4, %i3
4000d790: c2 06 61 e0 ld [ %i1 + 0x1e0 ], %g1
4000d794: 83 30 60 02 srl %g1, 2, %g1
4000d798: 80 a6 80 01 cmp %i2, %g1
4000d79c: 2a bf ff f6 bcs,a 4000d774 <IMFS_memfile_remove+0xc0>
4000d7a0: c2 06 c0 00 ld [ %i3 ], %g1
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
4000d7a4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000d7a8: 92 10 00 1d mov %i5, %o1
4000d7ac: 90 02 00 10 add %o0, %l0, %o0
4000d7b0: 7f ff ff ae call 4000d668 <memfile_free_blocks_in_table>
4000d7b4: b8 07 20 01 inc %i4
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000d7b8: c2 06 61 e0 ld [ %i1 + 0x1e0 ], %g1
4000d7bc: 83 30 60 02 srl %g1, 2, %g1
4000d7c0: 80 a7 00 01 cmp %i4, %g1
4000d7c4: 2a bf ff e5 bcs,a 4000d758 <IMFS_memfile_remove+0xa4>
4000d7c8: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
4000d7cc: 90 06 20 60 add %i0, 0x60, %o0
4000d7d0: 7f ff ff a6 call 4000d668 <memfile_free_blocks_in_table>
4000d7d4: 92 10 00 1d mov %i5, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
4000d7d8: 81 c7 e0 08 ret
4000d7dc: 81 e8 00 00 restore
4000d7e0 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000d7e0: 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 );
4000d7e4: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000d7e8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000d7ec: 7f ff fe 5e call 4000d164 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
4000d7f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d7f4: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
4000d7f8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
4000d7fc: 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 );
4000d800: 7f ff ff 91 call 4000d644 <memfile_free_block> <== NOT EXECUTED
4000d804: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
4000d808: 81 c7 e0 08 ret <== NOT EXECUTED
4000d80c: 81 e8 00 00 restore <== NOT EXECUTED
4000d9b0 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4000d9b0: 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 ) {
4000d9b4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000d9b8: 86 10 20 00 clr %g3
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
4000d9bc: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
4000d9c0: 80 a0 c0 01 cmp %g3, %g1
4000d9c4: 14 80 00 1b bg 4000da30 <IMFS_memfile_write+0x80> <== NEVER TAKEN
4000d9c8: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
4000d9cc: 80 a0 c0 01 cmp %g3, %g1
4000d9d0: 32 80 00 06 bne,a 4000d9e8 <IMFS_memfile_write+0x38> <== NEVER TAKEN
4000d9d4: 03 10 00 77 sethi %hi(0x4001dc00), %g1 <== NOT EXECUTED
4000d9d8: 80 a2 c0 02 cmp %o3, %g2
4000d9dc: 18 80 00 16 bgu 4000da34 <IMFS_memfile_write+0x84>
4000d9e0: 80 a6 40 01 cmp %i1, %g1
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000d9e4: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d9e8: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 4001dde0 <imfs_memfile_bytes_per_block>
4000d9ec: 92 10 00 1a mov %i2, %o1
4000d9f0: a3 3f 60 1f sra %i5, 0x1f, %l1
4000d9f4: 96 10 00 1d mov %i5, %o3
4000d9f8: 94 10 00 11 mov %l1, %o2
4000d9fc: 40 00 2a ce call 40018534 <__moddi3>
4000da00: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000da04: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000da08: a0 10 00 09 mov %o1, %l0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000da0c: 94 10 00 11 mov %l1, %o2
4000da10: 92 10 00 1a mov %i2, %o1
4000da14: 40 00 29 dd call 40018188 <__divdi3>
4000da18: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
4000da1c: 80 a4 20 00 cmp %l0, 0
4000da20: 12 80 00 17 bne 4000da7c <IMFS_memfile_write+0xcc>
4000da24: b4 10 00 09 mov %o1, %i2
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
4000da28: 10 80 00 28 b 4000dac8 <IMFS_memfile_write+0x118>
4000da2c: ba 10 20 00 clr %i5
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
4000da30: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000da34: 14 80 00 09 bg 4000da58 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
4000da38: 92 10 20 01 mov 1, %o1
4000da3c: 80 a6 40 01 cmp %i1, %g1
4000da40: 32 80 00 06 bne,a 4000da58 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
4000da44: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000da48: 80 a6 80 02 cmp %i2, %g2
4000da4c: 18 80 00 04 bgu 4000da5c <IMFS_memfile_write+0xac>
4000da50: 90 10 00 18 mov %i0, %o0
4000da54: 92 10 20 00 clr %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
4000da58: 90 10 00 18 mov %i0, %o0
4000da5c: 92 0a 60 01 and %o1, 1, %o1
4000da60: 7f ff ff 6c call 4000d810 <IMFS_memfile_extend>
4000da64: 94 10 20 00 clr %o2
if ( status )
4000da68: 82 92 20 00 orcc %o0, 0, %g1
4000da6c: 22 bf ff df be,a 4000d9e8 <IMFS_memfile_write+0x38>
4000da70: 03 10 00 77 sethi %hi(0x4001dc00), %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000da74: 81 c7 e0 08 ret
4000da78: 91 e8 00 01 restore %g0, %g1, %o0
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000da7c: ba 27 40 10 sub %i5, %l0, %i5
4000da80: 80 a7 40 1c cmp %i5, %i4
4000da84: 38 80 00 02 bgu,a 4000da8c <IMFS_memfile_write+0xdc>
4000da88: ba 10 00 1c mov %i4, %i5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000da8c: 90 10 00 18 mov %i0, %o0
4000da90: 92 10 00 1a mov %i2, %o1
4000da94: 7f ff fd b4 call 4000d164 <IMFS_memfile_get_block_pointer>
4000da98: 94 10 20 00 clr %o2
if ( !block_ptr )
4000da9c: 80 a2 20 00 cmp %o0, 0
4000daa0: 02 80 00 36 be 4000db78 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
4000daa4: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4000daa8: d0 02 00 00 ld [ %o0 ], %o0
4000daac: 92 10 00 1b mov %i3, %o1
4000dab0: 90 02 00 10 add %o0, %l0, %o0
4000dab4: 94 10 00 1d mov %i5, %o2
4000dab8: 40 00 06 3e call 4000f3b0 <memcpy>
4000dabc: b6 06 c0 1d add %i3, %i5, %i3
src += to_copy;
block++;
4000dac0: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000dac4: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000dac8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
4000dacc: b6 26 c0 1d sub %i3, %i5, %i3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000dad0: f2 00 61 e0 ld [ %g1 + 0x1e0 ], %i1
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000dad4: 10 80 00 0f b 4000db10 <IMFS_memfile_write+0x160>
4000dad8: a2 10 00 01 mov %g1, %l1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000dadc: 90 10 00 18 mov %i0, %o0
4000dae0: 92 10 00 1a mov %i2, %o1
4000dae4: 7f ff fd a0 call 4000d164 <IMFS_memfile_get_block_pointer>
4000dae8: 94 10 20 00 clr %o2
if ( !block_ptr )
4000daec: 80 a2 20 00 cmp %o0, 0
4000daf0: 02 80 00 21 be 4000db74 <IMFS_memfile_write+0x1c4> <== NEVER TAKEN
4000daf4: 94 10 00 19 mov %i1, %o2
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4000daf8: d0 02 00 00 ld [ %o0 ], %o0
4000dafc: 92 10 00 10 mov %l0, %o1
4000db00: 40 00 06 2c call 4000f3b0 <memcpy>
4000db04: b4 06 a0 01 inc %i2
src += to_copy;
block++;
my_length -= to_copy;
4000db08: b8 27 00 19 sub %i4, %i1, %i4
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
4000db0c: ba 07 40 19 add %i5, %i1, %i5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000db10: c2 04 61 e0 ld [ %l1 + 0x1e0 ], %g1
4000db14: 80 a7 00 01 cmp %i4, %g1
4000db18: 1a bf ff f1 bcc 4000dadc <IMFS_memfile_write+0x12c>
4000db1c: a0 06 c0 1d add %i3, %i5, %l0
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
4000db20: 80 a7 20 00 cmp %i4, 0
4000db24: 02 80 00 0f be 4000db60 <IMFS_memfile_write+0x1b0>
4000db28: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000db2c: 90 10 00 18 mov %i0, %o0
4000db30: 92 10 00 1a mov %i2, %o1
4000db34: 7f ff fd 8c call 4000d164 <IMFS_memfile_get_block_pointer>
4000db38: 94 10 20 00 clr %o2
if ( !block_ptr )
4000db3c: 80 a2 20 00 cmp %o0, 0
4000db40: 02 80 00 0e be 4000db78 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
4000db44: 82 10 00 1d mov %i5, %g1
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4000db48: d0 02 00 00 ld [ %o0 ], %o0
4000db4c: 92 10 00 10 mov %l0, %o1
4000db50: 94 10 00 1c mov %i4, %o2
4000db54: 40 00 06 17 call 4000f3b0 <memcpy>
4000db58: ba 07 40 1c add %i5, %i4, %i5
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4000db5c: 90 07 bf f8 add %fp, -8, %o0
4000db60: 7f ff d5 45 call 40003074 <gettimeofday>
4000db64: 92 10 20 00 clr %o1
4000db68: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000db6c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
4000db70: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
4000db74: 82 10 00 1d mov %i5, %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000db78: b0 10 00 01 mov %g1, %i0
4000db7c: 81 c7 e0 08 ret
4000db80: 81 e8 00 00 restore
400027ec <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
400027ec: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
400027f0: 05 00 00 3c sethi %hi(0xf000), %g2
400027f4: 07 00 00 10 sethi %hi(0x4000), %g3
400027f8: 84 0e c0 02 and %i3, %g2, %g2
400027fc: 80 a0 80 03 cmp %g2, %g3
40002800: 02 80 00 12 be 40002848 <IMFS_mknod+0x5c>
40002804: 07 00 00 20 sethi %hi(0x8000), %g3
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
40002808: 80 a0 80 03 cmp %g2, %g3
4000280c: 02 80 00 11 be 40002850 <IMFS_mknod+0x64>
40002810: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
40002814: 07 00 00 08 sethi %hi(0x2000), %g3
40002818: 88 0e c0 04 and %i3, %g4, %g4
4000281c: 80 a1 00 03 cmp %g4, %g3
40002820: 12 80 00 05 bne 40002834 <IMFS_mknod+0x48>
40002824: 07 00 00 04 sethi %hi(0x1000), %g3
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
40002828: 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;
4000282c: 10 80 00 0a b 40002854 <IMFS_mknod+0x68>
40002830: 82 10 20 01 mov 1, %g1
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
40002834: 80 a0 80 03 cmp %g2, %g3
40002838: 32 80 00 08 bne,a 40002858 <IMFS_mknod+0x6c> <== NEVER TAKEN
4000283c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
*type = IMFS_FIFO;
40002840: 10 80 00 05 b 40002854 <IMFS_mknod+0x68>
40002844: 82 10 20 06 mov 6, %g1
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
40002848: 10 80 00 03 b 40002854 <IMFS_mknod+0x68>
4000284c: 82 10 20 00 clr %g1
40002850: 82 10 20 04 mov 4, %g1
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
40002854: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40002858: 82 00 60 02 add %g1, 2, %g1
4000285c: c4 00 a0 08 ld [ %g2 + 8 ], %g2
40002860: 83 28 60 02 sll %g1, 2, %g1
40002864: d2 00 80 01 ld [ %g2 + %g1 ], %o1
40002868: 90 10 00 18 mov %i0, %o0
4000286c: 94 10 00 19 mov %i1, %o2
40002870: 96 10 00 1a mov %i2, %o3
40002874: 98 10 00 1b mov %i3, %o4
40002878: 40 00 21 46 call 4000ad90 <IMFS_create_node_with_control>
4000287c: 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 ) {
40002880: 80 a2 20 00 cmp %o0, 0
40002884: 02 80 00 0e be 400028bc <IMFS_mknod+0xd0>
40002888: 90 07 bf e0 add %fp, -32, %o0
IMFS_jnode_t *parent = parentloc->node_access;
4000288c: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
40002890: 40 00 01 f9 call 40003074 <gettimeofday>
40002894: 92 10 20 00 clr %o1
40002898: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
4000289c: 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 );
400028a0: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
400028a4: 40 00 01 f4 call 40003074 <gettimeofday>
400028a8: 92 10 20 00 clr %o1
400028ac: c2 07 bf e0 ld [ %fp + -32 ], %g1
400028b0: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
400028b4: 81 c7 e0 08 ret
400028b8: 91 e8 20 00 restore %g0, 0, %o0
} else {
rv = -1;
}
return rv;
}
400028bc: 81 c7 e0 08 ret
400028c0: 91 e8 3f ff restore %g0, -1, %o0
400028c4 <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400028c4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400028c8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400028cc: 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;
400028d0: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
400028d4: c4 00 80 00 ld [ %g2 ], %g2
400028d8: 80 a0 a0 00 cmp %g2, 0
400028dc: 12 80 00 0d bne 40002910 <IMFS_mount+0x4c>
400028e0: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
400028e4: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
400028e8: 80 a0 a0 00 cmp %g2, 0
400028ec: 12 80 00 05 bne 40002900 <IMFS_mount+0x3c> <== NEVER TAKEN
400028f0: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
400028f4: 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;
400028f8: 81 c7 e0 08 ret
400028fc: 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;
40002900: 40 00 30 5b call 4000ea6c <__errno> <== NOT EXECUTED
40002904: 01 00 00 00 nop <== NOT EXECUTED
40002908: 10 80 00 05 b 4000291c <IMFS_mount+0x58> <== NOT EXECUTED
4000290c: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40002910: 40 00 30 57 call 4000ea6c <__errno>
40002914: 01 00 00 00 nop
40002918: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
4000291c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40002920: 81 c7 e0 08 ret
40002924: 91 e8 3f ff restore %g0, -1, %o0
4000b1e0 <IMFS_node_remove_directory>:
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
4000b1e0: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
4000b1e4: 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 );
4000b1e8: 82 06 20 54 add %i0, 0x54, %g1
4000b1ec: 80 a0 80 01 cmp %g2, %g1
4000b1f0: 22 80 00 06 be,a 4000b208 <IMFS_node_remove_directory+0x28>
4000b1f4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
errno = ENOTEMPTY;
4000b1f8: 40 00 0e 1d call 4000ea6c <__errno>
4000b1fc: 01 00 00 00 nop
4000b200: 10 80 00 08 b 4000b220 <IMFS_node_remove_directory+0x40>
4000b204: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
4000b208: 80 a0 60 00 cmp %g1, 0
4000b20c: 02 80 00 07 be 4000b228 <IMFS_node_remove_directory+0x48> <== ALWAYS TAKEN
4000b210: 01 00 00 00 nop
errno = EBUSY;
4000b214: 40 00 0e 16 call 4000ea6c <__errno> <== NOT EXECUTED
4000b218: 01 00 00 00 nop <== NOT EXECUTED
4000b21c: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
4000b220: c2 22 00 00 st %g1, [ %o0 ]
4000b224: b0 10 20 00 clr %i0
node = NULL;
}
return node;
}
4000b228: 81 c7 e0 08 ret
4000b22c: 81 e8 00 00 restore
40002928 <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;
40002928: 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;
4000292c: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40002930: 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 ) {
40002934: 80 a0 60 02 cmp %g1, 2
40002938: 02 80 00 06 be 40002950 <IMFS_node_type+0x28>
4000293c: 80 a0 60 05 cmp %g1, 5
40002940: 12 80 00 08 bne 40002960 <IMFS_node_type+0x38> <== ALWAYS TAKEN
40002944: 90 10 20 04 mov 4, %o0
40002948: 81 c3 e0 08 retl <== NOT EXECUTED
4000294c: 01 00 00 00 nop <== NOT EXECUTED
40002950: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
40002954: c2 00 60 4c ld [ %g1 + 0x4c ], %g1
case IMFS_HARD_LINK:
type = IMFS_type( node->info.hard_link.link_node );
break;
40002958: 81 c3 e0 08 retl
4000295c: d0 00 40 00 ld [ %g1 ], %o0
type = imfs_type;
break;
}
return type;
}
40002960: 81 c3 e0 08 retl
40002964: 90 10 00 01 mov %g1, %o0
400029a4 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400029a4: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
400029a8: 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 ) {
400029ac: c2 07 60 08 ld [ %i5 + 8 ], %g1
400029b0: 80 a0 60 00 cmp %g1, 0
400029b4: 02 80 00 20 be 40002a34 <IMFS_rename+0x90> <== NEVER TAKEN
400029b8: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
400029bc: 80 a7 20 1f cmp %i4, 0x1f
400029c0: 18 80 00 19 bgu 40002a24 <IMFS_rename+0x80> <== NEVER TAKEN
400029c4: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
400029c8: 92 10 00 1b mov %i3, %o1
400029cc: 40 00 32 79 call 4000f3b0 <memcpy>
400029d0: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
400029d4: b8 07 40 1c add %i5, %i4, %i4
400029d8: c0 2f 20 0c clrb [ %i4 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400029dc: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
400029e0: c2 07 60 04 ld [ %i5 + 4 ], %g1
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
400029e4: 90 07 bf f8 add %fp, -8, %o0
next->previous = previous;
400029e8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
400029ec: c4 20 40 00 st %g2, [ %g1 ]
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
400029f0: f4 27 60 08 st %i2, [ %i5 + 8 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
400029f4: c2 06 a0 58 ld [ %i2 + 0x58 ], %g1
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
400029f8: 84 06 a0 54 add %i2, 0x54, %g2
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
400029fc: fa 26 a0 58 st %i5, [ %i2 + 0x58 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
40002a00: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
old_last->next = the_node;
40002a04: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
40002a08: c2 27 60 04 st %g1, [ %i5 + 4 ]
40002a0c: 40 00 01 9a call 40003074 <gettimeofday>
40002a10: 92 10 20 00 clr %o1
40002a14: c2 07 bf f8 ld [ %fp + -8 ], %g1
40002a18: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
40002a1c: 81 c7 e0 08 ret
40002a20: 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;
40002a24: 40 00 30 12 call 4000ea6c <__errno> <== NOT EXECUTED
40002a28: 01 00 00 00 nop <== NOT EXECUTED
40002a2c: 10 80 00 05 b 40002a40 <IMFS_rename+0x9c> <== NOT EXECUTED
40002a30: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
40002a34: 40 00 30 0e call 4000ea6c <__errno> <== NOT EXECUTED
40002a38: 01 00 00 00 nop <== NOT EXECUTED
40002a3c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40002a40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40002a44: 81 c7 e0 08 ret <== NOT EXECUTED
40002a48: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40002b24 <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40002b24: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40002b28: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40002b2c: 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;
40002b30: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
40002b34: c4 00 80 00 ld [ %g2 ], %g2
40002b38: 80 a0 a0 00 cmp %g2, 0
40002b3c: 12 80 00 0d bne 40002b70 <IMFS_unmount+0x4c> <== NEVER TAKEN
40002b40: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
40002b44: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40002b48: 80 a0 80 18 cmp %g2, %i0
40002b4c: 12 80 00 05 bne 40002b60 <IMFS_unmount+0x3c> <== NEVER TAKEN
40002b50: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
40002b54: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
40002b58: 81 c7 e0 08 ret
40002b5c: 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;
40002b60: 40 00 2f c3 call 4000ea6c <__errno> <== NOT EXECUTED
40002b64: 01 00 00 00 nop <== NOT EXECUTED
40002b68: 10 80 00 05 b 40002b7c <IMFS_unmount+0x58> <== NOT EXECUTED
40002b6c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40002b70: 40 00 2f bf call 4000ea6c <__errno> <== NOT EXECUTED
40002b74: 01 00 00 00 nop <== NOT EXECUTED
40002b78: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14> <== NOT EXECUTED
40002b7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40002b80: 81 c7 e0 08 ret <== NOT EXECUTED
40002b84: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40003260 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
40003260: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
40003264: 03 10 00 75 sethi %hi(0x4001d400), %g1
40003268: f6 00 62 a0 ld [ %g1 + 0x2a0 ], %i3 ! 4001d6a0 <RTEMS_Malloc_Heap>
if ( !rtems_configuration_get_unified_work_area() ) {
4000326c: 03 10 00 6d sethi %hi(0x4001b400), %g1
40003270: c2 08 63 89 ldub [ %g1 + 0x389 ], %g1 ! 4001b789 <Configuration+0x31>
40003274: 80 a0 60 00 cmp %g1, 0
40003278: 12 80 00 1b bne 400032e4 <RTEMS_Malloc_Initialize+0x84>
4000327c: 03 10 00 77 sethi %hi(0x4001dc00), %g1
40003280: 3b 10 00 20 sethi %hi(0x40008000), %i5
40003284: b8 10 20 00 clr %i4
40003288: 10 80 00 0b b 400032b4 <RTEMS_Malloc_Initialize+0x54>
4000328c: ba 17 61 5c or %i5, 0x15c, %i5
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
40003290: d4 06 20 04 ld [ %i0 + 4 ], %o2
40003294: 90 10 00 1b mov %i3, %o0
40003298: 9f c7 40 00 call %i5
4000329c: 96 10 20 08 mov 8, %o3
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
400032a0: 80 a2 20 00 cmp %o0, 0
400032a4: 32 80 00 02 bne,a 400032ac <RTEMS_Malloc_Initialize+0x4c><== ALWAYS TAKEN
400032a8: ba 10 00 1a mov %i2, %i5
if ( !rtems_configuration_get_unified_work_area() ) {
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
400032ac: b8 07 20 01 inc %i4
400032b0: b0 06 20 08 add %i0, 8, %i0
400032b4: 80 a7 00 19 cmp %i4, %i1
400032b8: 32 bf ff f6 bne,a 40003290 <RTEMS_Malloc_Initialize+0x30>
400032bc: d2 06 00 00 ld [ %i0 ], %o1
if ( space_available > 0 ) {
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
400032c0: 03 10 00 20 sethi %hi(0x40008000), %g1
400032c4: 82 10 61 5c or %g1, 0x15c, %g1 ! 4000815c <_Heap_Initialize>
400032c8: 80 a7 40 01 cmp %i5, %g1
400032cc: 12 80 00 06 bne 400032e4 <RTEMS_Malloc_Initialize+0x84>
400032d0: 03 10 00 77 sethi %hi(0x4001dc00), %g1
_Internal_error_Occurred(
400032d4: 90 10 20 00 clr %o0
400032d8: 92 10 20 01 mov 1, %o1
400032dc: 40 00 14 33 call 400083a8 <_Internal_error_Occurred>
400032e0: 94 10 20 17 mov 0x17, %o2
}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
400032e4: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1
400032e8: 80 a0 60 00 cmp %g1, 0
400032ec: 02 80 00 05 be 40003300 <RTEMS_Malloc_Initialize+0xa0>
400032f0: 3b 10 00 78 sethi %hi(0x4001e000), %i5
(*rtems_malloc_statistics_helpers->initialize)();
400032f4: c2 00 40 00 ld [ %g1 ], %g1
400032f8: 9f c0 40 00 call %g1
400032fc: 01 00 00 00 nop
}
MSBUMP( space_available, _Protected_heap_Get_size( heap ) );
40003300: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
40003304: 40 00 16 73 call 40008cd0 <_Protected_heap_Get_size>
40003308: 90 10 00 1b mov %i3, %o0
4000330c: 90 02 00 1c add %o0, %i4, %o0
40003310: d0 27 60 80 st %o0, [ %i5 + 0x80 ]
40003314: 81 c7 e0 08 ret
40003318: 81 e8 00 00 restore
400217d4 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
400217d4: 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) {
400217d8: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED
400217dc: 32 80 00 0a bne,a 40021804 <Stack_check_Dump_threads_usage+0x30><== NOT EXECUTED
400217e0: e0 06 21 38 ld [ %i0 + 0x138 ], %l0 <== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
400217e4: 3b 10 01 8f sethi %hi(0x40063c00), %i5 <== NOT EXECUTED
400217e8: ba 17 60 0c or %i5, 0xc, %i5 ! 40063c0c <Stack_check_Interrupt_stack><== NOT EXECUTED
400217ec: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
400217f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400217f4: 02 80 00 4c be 40021924 <Stack_check_Dump_threads_usage+0x150><== NOT EXECUTED
400217f8: a0 10 20 00 clr %l0 <== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
400217fc: 10 80 00 04 b 4002180c <Stack_check_Dump_threads_usage+0x38><== NOT EXECUTED
40021800: b0 10 20 00 clr %i0 <== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
40021804: ba 06 20 b4 add %i0, 0xb4, %i5 <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
40021808: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
4002180c: f2 07 40 00 ld [ %i5 ], %i1 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
40021810: 84 00 60 10 add %g1, 0x10, %g2 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
40021814: b2 06 7f f0 add %i1, -16, %i1 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
40021818: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
4002181c: 86 0e 7f fc and %i1, -4, %g3 <== NOT EXECUTED
if (*base != U32_PATTERN)
40021820: 09 29 69 69 sethi %hi(0xa5a5a400), %g4 <== 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++)
40021824: 86 00 40 03 add %g1, %g3, %g3 <== NOT EXECUTED
if (*base != U32_PATTERN)
40021828: 10 80 00 06 b 40021840 <Stack_check_Dump_threads_usage+0x6c><== NOT EXECUTED
4002182c: 88 11 21 a5 or %g4, 0x1a5, %g4 <== NOT EXECUTED
40021830: 80 a7 00 04 cmp %i4, %g4 <== NOT EXECUTED
40021834: 12 80 00 08 bne 40021854 <Stack_check_Dump_threads_usage+0x80><== NOT EXECUTED
40021838: 80 a0 60 00 cmp %g1, 0 <== 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++)
4002183c: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED
40021840: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
40021844: 2a bf ff fb bcs,a 40021830 <Stack_check_Dump_threads_usage+0x5c><== NOT EXECUTED
40021848: f8 00 40 00 ld [ %g1 ], %i4 <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
4002184c: 10 80 00 06 b 40021864 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
40021850: b8 10 20 00 clr %i4 <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
40021854: 02 80 00 04 be 40021864 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
40021858: b8 10 20 00 clr %i4 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
4002185c: b8 00 80 19 add %g2, %i1, %i4 <== NOT EXECUTED
40021860: b8 27 00 01 sub %i4, %g1, %i4 <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
40021864: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40021868: 02 80 00 12 be 400218b0 <Stack_check_Dump_threads_usage+0xdc><== NOT EXECUTED
4002186c: 03 10 01 8a sethi %hi(0x40062800), %g1 <== NOT EXECUTED
#endif
{
(*print_handler)(
40021870: f6 06 20 08 ld [ %i0 + 8 ], %i3 <== NOT EXECUTED
40021874: f4 00 62 20 ld [ %g1 + 0x220 ], %i2 <== NOT EXECUTED
40021878: 03 10 01 8a sethi %hi(0x40062800), %g1 <== NOT EXECUTED
4002187c: e2 00 62 1c ld [ %g1 + 0x21c ], %l1 ! 40062a1c <print_context><== NOT EXECUTED
40021880: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
40021884: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40021888: 7f ff b2 92 call 4000e2d0 <rtems_object_get_name> <== NOT EXECUTED
4002188c: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
40021890: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
40021894: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40021898: 92 12 63 90 or %o1, 0x390, %o1 <== NOT EXECUTED
4002189c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
400218a0: 9f c6 80 00 call %i2 <== NOT EXECUTED
400218a4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400218a8: 10 80 00 0a b 400218d0 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
400218ac: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== 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 );
400218b0: 05 10 01 8a sethi %hi(0x40062800), %g2 <== NOT EXECUTED
400218b4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 <== NOT EXECUTED
400218b8: d0 00 a2 1c ld [ %g2 + 0x21c ], %o0 <== NOT EXECUTED
400218bc: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
400218c0: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
400218c4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400218c8: 92 12 63 a0 or %o1, 0x3a0, %o1 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400218cc: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400218d0: 35 10 01 8a sethi %hi(0x40062800), %i2 <== NOT EXECUTED
400218d4: 37 10 01 8a sethi %hi(0x40062800), %i3 <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400218d8: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400218dc: c2 06 a2 20 ld [ %i2 + 0x220 ], %g1 <== NOT EXECUTED
400218e0: d0 06 e2 1c ld [ %i3 + 0x21c ], %o0 <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400218e4: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400218e8: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
400218ec: 96 02 80 0b add %o2, %o3, %o3 <== NOT EXECUTED
400218f0: 92 12 63 b0 or %o1, 0x3b0, %o1 <== NOT EXECUTED
400218f4: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
400218f8: 9f c0 40 00 call %g1 <== NOT EXECUTED
400218fc: 9a 10 00 19 mov %i1, %o5 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
40021900: 03 10 01 8a sethi %hi(0x40062800), %g1 <== NOT EXECUTED
40021904: c2 00 62 18 ld [ %g1 + 0x218 ], %g1 ! 40062a18 <Stack_check_Initialized><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40021908: d0 06 e2 1c ld [ %i3 + 0x21c ], %o0 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
4002190c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40021910: 12 80 00 07 bne 4002192c <Stack_check_Dump_threads_usage+0x158><== NOT EXECUTED
40021914: c2 06 a2 20 ld [ %i2 + 0x220 ], %g1 <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40021918: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
4002191c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40021920: 92 12 63 d0 or %o1, 0x3d0, %o1 ! 400597d0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
40021924: 81 c7 e0 08 ret <== NOT EXECUTED
40021928: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
4002192c: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
40021930: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40021934: 9f c0 40 00 call %g1 <== NOT EXECUTED
40021938: 92 12 63 e0 or %o1, 0x3e0, %o1 <== NOT EXECUTED
4002193c: 81 c7 e0 08 ret <== NOT EXECUTED
40021940: 81 e8 00 00 restore <== NOT EXECUTED
40021a2c <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)
{
40021a2c: 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");
40021a30: 11 10 01 65 sethi %hi(0x40059400), %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);
40021a34: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
40021a38: 7f ff 87 96 call 40003890 <printk> <== NOT EXECUTED
40021a3c: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
40021a40: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40021a44: 11 10 01 65 sethi %hi(0x40059400), %o0 <== NOT EXECUTED
40021a48: 7f ff 87 92 call 40003890 <printk> <== NOT EXECUTED
40021a4c: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 400597f8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328><== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
40021a50: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
40021a54: 11 10 01 66 sethi %hi(0x40059800), %o0 <== NOT EXECUTED
40021a58: 7f ff 87 8e call 40003890 <printk> <== NOT EXECUTED
40021a5c: 90 12 20 18 or %o0, 0x18, %o0 ! 40059818 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348><== NOT EXECUTED
printk(
40021a60: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40021a64: 11 10 01 66 sethi %hi(0x40059800), %o0 <== NOT EXECUTED
40021a68: 7f ff 87 8a call 40003890 <printk> <== NOT EXECUTED
40021a6c: 90 12 20 30 or %o0, 0x30, %o0 ! 40059830 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360><== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
40021a70: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED
40021a74: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
40021a78: 7f ff b2 16 call 4000e2d0 <rtems_object_get_name> <== NOT EXECUTED
40021a7c: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
40021a80: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021a84: 11 10 01 66 sethi %hi(0x40059800), %o0 <== NOT EXECUTED
40021a88: 7f ff 87 82 call 40003890 <printk> <== NOT EXECUTED
40021a8c: 90 12 20 48 or %o0, 0x48, %o0 ! 40059848 <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)
40021a90: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2 <== NOT EXECUTED
40021a94: 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(
40021a98: 11 10 01 66 sethi %hi(0x40059800), %o0 <== NOT EXECUTED
40021a9c: 96 02 80 09 add %o2, %o1, %o3 <== NOT EXECUTED
40021aa0: 7f ff 87 7c call 40003890 <printk> <== NOT EXECUTED
40021aa4: 90 12 20 60 or %o0, 0x60, %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) {
40021aa8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40021aac: 32 80 00 09 bne,a 40021ad0 <Stack_check_report_blown_task+0xa4><== NOT EXECUTED
40021ab0: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
printk(
40021ab4: 11 10 01 66 sethi %hi(0x40059800), %o0 <== NOT EXECUTED
40021ab8: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
40021abc: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
40021ac0: 94 07 60 08 add %i5, 8, %o2 <== NOT EXECUTED
40021ac4: 7f ff 87 73 call 40003890 <printk> <== NOT EXECUTED
40021ac8: 96 07 60 18 add %i5, 0x18, %o3 <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
40021acc: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40021ad0: 7f ff 95 78 call 400070b0 <rtems_fatal> <== NOT EXECUTED
40021ad4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
40009cf4 <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
40009cf4: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
40009cf8: 03 10 00 68 sethi %hi(0x4001a000), %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 );
40009cfc: 7f ff e6 32 call 400035c4 <sparc_disable_interrupts>
40009d00: fa 00 61 a0 ld [ %g1 + 0x1a0 ], %i5 ! 4001a1a0 <_Per_CPU_Information+0x10>
40009d04: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
40009d08: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
40009d0c: 80 a0 60 00 cmp %g1, 0
40009d10: 12 80 00 08 bne 40009d30 <_CORE_RWLock_Release+0x3c>
40009d14: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
40009d18: 7f ff e6 2f call 400035d4 <sparc_enable_interrupts>
40009d1c: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
40009d20: 82 10 20 02 mov 2, %g1
40009d24: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
40009d28: 81 c7 e0 08 ret
40009d2c: 81 e8 00 00 restore
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
40009d30: 32 80 00 0b bne,a 40009d5c <_CORE_RWLock_Release+0x68>
40009d34: c0 27 60 34 clr [ %i5 + 0x34 ]
the_rwlock->number_of_readers -= 1;
40009d38: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
40009d3c: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
40009d40: 80 a0 60 00 cmp %g1, 0
40009d44: 02 80 00 05 be 40009d58 <_CORE_RWLock_Release+0x64>
40009d48: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
40009d4c: 7f ff e6 22 call 400035d4 <sparc_enable_interrupts>
40009d50: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
40009d54: 30 80 00 24 b,a 40009de4 <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
40009d58: 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;
40009d5c: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
40009d60: 7f ff e6 1d call 400035d4 <sparc_enable_interrupts>
40009d64: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
40009d68: 40 00 07 6d call 4000bb1c <_Thread_queue_Dequeue>
40009d6c: 90 10 00 18 mov %i0, %o0
if ( next ) {
40009d70: 80 a2 20 00 cmp %o0, 0
40009d74: 22 80 00 1c be,a 40009de4 <_CORE_RWLock_Release+0xf0>
40009d78: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
40009d7c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
40009d80: 80 a0 60 01 cmp %g1, 1
40009d84: 32 80 00 05 bne,a 40009d98 <_CORE_RWLock_Release+0xa4>
40009d88: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
40009d8c: 82 10 20 02 mov 2, %g1
return CORE_RWLOCK_SUCCESSFUL;
40009d90: 10 80 00 14 b 40009de0 <_CORE_RWLock_Release+0xec>
40009d94: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
40009d98: 82 00 60 01 inc %g1
40009d9c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
40009da0: 82 10 20 01 mov 1, %g1
40009da4: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
40009da8: 40 00 08 99 call 4000c00c <_Thread_queue_First>
40009dac: 90 10 00 18 mov %i0, %o0
if ( !next ||
40009db0: 92 92 20 00 orcc %o0, 0, %o1
40009db4: 22 80 00 0c be,a 40009de4 <_CORE_RWLock_Release+0xf0>
40009db8: b0 10 20 00 clr %i0
40009dbc: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
40009dc0: 80 a0 60 01 cmp %g1, 1
40009dc4: 02 80 00 07 be 40009de0 <_CORE_RWLock_Release+0xec> <== NEVER TAKEN
40009dc8: 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;
40009dcc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
40009dd0: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
40009dd4: 40 00 08 3f call 4000bed0 <_Thread_queue_Extract>
40009dd8: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
}
40009ddc: 30 bf ff f3 b,a 40009da8 <_CORE_RWLock_Release+0xb4>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
40009de0: b0 10 20 00 clr %i0
40009de4: 81 c7 e0 08 ret
40009de8: 81 e8 00 00 restore
40009dec <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
40009dec: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
40009df0: 90 10 00 18 mov %i0, %o0
40009df4: 40 00 06 7e call 4000b7ec <_Thread_Get>
40009df8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40009dfc: c2 07 bf fc ld [ %fp + -4 ], %g1
40009e00: 80 a0 60 00 cmp %g1, 0
40009e04: 12 80 00 08 bne 40009e24 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
40009e08: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
40009e0c: 40 00 08 bd call 4000c100 <_Thread_queue_Process_timeout>
40009e10: 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;
40009e14: 03 10 00 67 sethi %hi(0x40019c00), %g1
40009e18: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40019c80 <_Thread_Dispatch_disable_level>
--level;
40009e1c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40009e20: c4 20 60 80 st %g2, [ %g1 + 0x80 ]
40009e24: 81 c7 e0 08 ret
40009e28: 81 e8 00 00 restore
40007e84 <_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
)
{
40007e84: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
40007e88: 90 10 00 18 mov %i0, %o0
40007e8c: 40 00 07 3d call 40009b80 <_Thread_queue_Dequeue>
40007e90: ba 10 00 18 mov %i0, %i5
40007e94: 80 a2 20 00 cmp %o0, 0
40007e98: 12 80 00 0e bne 40007ed0 <_CORE_semaphore_Surrender+0x4c>
40007e9c: b0 10 20 00 clr %i0
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
40007ea0: 7f ff e8 82 call 400020a8 <sparc_disable_interrupts>
40007ea4: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
40007ea8: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
40007eac: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
40007eb0: 80 a0 40 02 cmp %g1, %g2
40007eb4: 1a 80 00 05 bcc 40007ec8 <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
40007eb8: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
40007ebc: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
40007ec0: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
40007ec4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
40007ec8: 7f ff e8 7c call 400020b8 <sparc_enable_interrupts>
40007ecc: 01 00 00 00 nop
}
return status;
}
40007ed0: 81 c7 e0 08 ret
40007ed4: 81 e8 00 00 restore
40006b0c <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
40006b0c: 9d e3 bf a0 save %sp, -96, %sp
rtems_event_set pending_events;
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
40006b10: e0 06 20 30 ld [ %i0 + 0x30 ], %l0
_ISR_Disable( level );
40006b14: 7f ff ed 65 call 400020a8 <sparc_disable_interrupts>
40006b18: ba 10 00 18 mov %i0, %i5
40006b1c: b0 10 00 08 mov %o0, %i0
RTEMS_INLINE_ROUTINE void _Event_sets_Post(
rtems_event_set the_new_events,
rtems_event_set *the_event_set
)
{
*the_event_set |= the_new_events;
40006b20: c2 06 80 00 ld [ %i2 ], %g1
40006b24: b2 16 40 01 or %i1, %g1, %i1
40006b28: 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;
40006b2c: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
40006b30: 82 8e 40 02 andcc %i1, %g2, %g1
40006b34: 02 80 00 3d be 40006c28 <_Event_Surrender+0x11c>
40006b38: 07 10 00 79 sethi %hi(0x4001e400), %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() &&
40006b3c: 86 10 e3 10 or %g3, 0x310, %g3 ! 4001e710 <_Per_CPU_Information>
40006b40: c8 00 e0 08 ld [ %g3 + 8 ], %g4
40006b44: 80 a1 20 00 cmp %g4, 0
40006b48: 22 80 00 18 be,a 40006ba8 <_Event_Surrender+0x9c>
40006b4c: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
40006b50: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
40006b54: 80 a7 40 03 cmp %i5, %g3
40006b58: 32 80 00 14 bne,a 40006ba8 <_Event_Surrender+0x9c>
40006b5c: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
40006b60: c6 06 c0 00 ld [ %i3 ], %g3
40006b64: 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 ) &&
40006b68: 80 a0 e0 01 cmp %g3, 1
40006b6c: 38 80 00 0f bgu,a 40006ba8 <_Event_Surrender+0x9c>
40006b70: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
40006b74: 80 a0 40 02 cmp %g1, %g2
40006b78: 02 80 00 04 be 40006b88 <_Event_Surrender+0x7c>
40006b7c: 80 8c 20 02 btst 2, %l0
40006b80: 02 80 00 2a be 40006c28 <_Event_Surrender+0x11c> <== NEVER TAKEN
40006b84: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
40006b88: b2 2e 40 01 andn %i1, %g1, %i1
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006b8c: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
event->pending_events = _Event_sets_Clear(
40006b90: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40006b94: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006b98: c2 20 80 00 st %g1, [ %g2 ]
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
40006b9c: 82 10 20 03 mov 3, %g1
40006ba0: 10 80 00 22 b 40006c28 <_Event_Surrender+0x11c>
40006ba4: c2 26 c0 00 st %g1, [ %i3 ]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
40006ba8: 80 8f 00 03 btst %i4, %g3
40006bac: 02 80 00 1f be 40006c28 <_Event_Surrender+0x11c>
40006bb0: 80 a0 40 02 cmp %g1, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40006bb4: 02 80 00 04 be 40006bc4 <_Event_Surrender+0xb8>
40006bb8: 80 8c 20 02 btst 2, %l0
40006bbc: 02 80 00 1b be 40006c28 <_Event_Surrender+0x11c> <== NEVER TAKEN
40006bc0: 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;
40006bc4: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
40006bc8: b2 2e 40 01 andn %i1, %g1, %i1
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
event->pending_events = _Event_sets_Clear(
40006bcc: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40006bd0: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006bd4: c2 20 80 00 st %g1, [ %g2 ]
_ISR_Flash( level );
40006bd8: 7f ff ed 38 call 400020b8 <sparc_enable_interrupts>
40006bdc: 90 10 00 18 mov %i0, %o0
40006be0: 7f ff ed 32 call 400020a8 <sparc_disable_interrupts>
40006be4: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
40006be8: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
40006bec: 80 a0 60 02 cmp %g1, 2
40006bf0: 02 80 00 06 be 40006c08 <_Event_Surrender+0xfc>
40006bf4: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
40006bf8: 7f ff ed 30 call 400020b8 <sparc_enable_interrupts>
40006bfc: 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 );
40006c00: 10 80 00 08 b 40006c20 <_Event_Surrender+0x114>
40006c04: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
40006c08: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
40006c0c: 7f ff ed 2b call 400020b8 <sparc_enable_interrupts>
40006c10: 33 04 01 ff sethi %hi(0x1007fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
40006c14: 40 00 0e 6a call 4000a5bc <_Watchdog_Remove>
40006c18: 90 07 60 48 add %i5, 0x48, %o0
40006c1c: b2 16 63 f8 or %i1, 0x3f8, %i1
40006c20: 40 00 0a 2a call 400094c8 <_Thread_Clear_state>
40006c24: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
40006c28: 7f ff ed 24 call 400020b8 <sparc_enable_interrupts>
40006c2c: 81 e8 00 00 restore
40006c30 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
40006c30: 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 );
40006c34: 90 10 00 18 mov %i0, %o0
40006c38: 40 00 0b 06 call 40009850 <_Thread_Get>
40006c3c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40006c40: c2 07 bf fc ld [ %fp + -4 ], %g1
40006c44: 80 a0 60 00 cmp %g1, 0
40006c48: 12 80 00 1b bne 40006cb4 <_Event_Timeout+0x84> <== NEVER TAKEN
40006c4c: 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 );
40006c50: 7f ff ed 16 call 400020a8 <sparc_disable_interrupts>
40006c54: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
40006c58: 03 10 00 79 sethi %hi(0x4001e400), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
40006c5c: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 4001e720 <_Per_CPU_Information+0x10>
40006c60: 80 a7 40 01 cmp %i5, %g1
40006c64: 12 80 00 08 bne 40006c84 <_Event_Timeout+0x54>
40006c68: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
40006c6c: c2 06 40 00 ld [ %i1 ], %g1
40006c70: 80 a0 60 01 cmp %g1, 1
40006c74: 12 80 00 05 bne 40006c88 <_Event_Timeout+0x58>
40006c78: 82 10 20 06 mov 6, %g1
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
40006c7c: 82 10 20 02 mov 2, %g1
40006c80: c2 26 40 00 st %g1, [ %i1 ]
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
40006c84: 82 10 20 06 mov 6, %g1
40006c88: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
40006c8c: 7f ff ed 0b call 400020b8 <sparc_enable_interrupts>
40006c90: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40006c94: 90 10 00 1d mov %i5, %o0
40006c98: 13 04 01 ff sethi %hi(0x1007fc00), %o1
40006c9c: 40 00 0a 0b call 400094c8 <_Thread_Clear_state>
40006ca0: 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;
40006ca4: 03 10 00 78 sethi %hi(0x4001e000), %g1
40006ca8: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 4001e200 <_Thread_Dispatch_disable_level>
--level;
40006cac: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40006cb0: c4 20 62 00 st %g2, [ %g1 + 0x200 ]
40006cb4: 81 c7 e0 08 ret
40006cb8: 81 e8 00 00 restore
4000cba4 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4000cba4: 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 ) {
4000cba8: 80 a6 60 00 cmp %i1, 0
4000cbac: 02 80 00 7a be 4000cd94 <_Heap_Free+0x1f0>
4000cbb0: 88 10 20 01 mov 1, %g4
4000cbb4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4000cbb8: 40 00 2c c8 call 40017ed8 <.urem>
4000cbbc: 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
4000cbc0: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000cbc4: 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);
4000cbc8: 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;
4000cbcc: 80 a2 00 1b cmp %o0, %i3
4000cbd0: 0a 80 00 05 bcs 4000cbe4 <_Heap_Free+0x40>
4000cbd4: 82 10 20 00 clr %g1
4000cbd8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000cbdc: 80 a0 40 08 cmp %g1, %o0
4000cbe0: 82 60 3f ff subx %g0, -1, %g1
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
4000cbe4: 80 a0 60 00 cmp %g1, 0
4000cbe8: 02 80 00 6b be 4000cd94 <_Heap_Free+0x1f0>
4000cbec: 88 10 20 00 clr %g4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000cbf0: f8 02 20 04 ld [ %o0 + 4 ], %i4
4000cbf4: 84 0f 3f fe and %i4, -2, %g2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000cbf8: 82 02 00 02 add %o0, %g2, %g1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000cbfc: 80 a0 40 1b cmp %g1, %i3
4000cc00: 0a 80 00 05 bcs 4000cc14 <_Heap_Free+0x70> <== NEVER TAKEN
4000cc04: 86 10 20 00 clr %g3
4000cc08: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
4000cc0c: 80 a0 c0 01 cmp %g3, %g1
4000cc10: 86 60 3f ff subx %g0, -1, %g3
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
4000cc14: 80 a0 e0 00 cmp %g3, 0
4000cc18: 02 80 00 5f be 4000cd94 <_Heap_Free+0x1f0> <== NEVER TAKEN
4000cc1c: 88 10 20 00 clr %g4
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000cc20: fa 00 60 04 ld [ %g1 + 4 ], %i5
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4000cc24: 80 8f 60 01 btst 1, %i5
4000cc28: 22 80 00 5c be,a 4000cd98 <_Heap_Free+0x1f4> <== NEVER TAKEN
4000cc2c: b0 09 20 01 and %g4, 1, %i0 <== NOT EXECUTED
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4000cc30: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000cc34: 80 a0 40 04 cmp %g1, %g4
4000cc38: 02 80 00 07 be 4000cc54 <_Heap_Free+0xb0>
4000cc3c: ba 0f 7f fe and %i5, -2, %i5
4000cc40: 86 00 40 1d add %g1, %i5, %g3
4000cc44: f4 00 e0 04 ld [ %g3 + 4 ], %i2
4000cc48: b4 1e a0 01 xor %i2, 1, %i2
4000cc4c: 10 80 00 03 b 4000cc58 <_Heap_Free+0xb4>
4000cc50: b4 0e a0 01 and %i2, 1, %i2
4000cc54: b4 10 20 00 clr %i2
if ( !_Heap_Is_prev_used( block ) ) {
4000cc58: 80 8f 20 01 btst 1, %i4
4000cc5c: 12 80 00 26 bne 4000ccf4 <_Heap_Free+0x150>
4000cc60: 80 8e a0 ff btst 0xff, %i2
uintptr_t const prev_size = block->prev_size;
4000cc64: f8 02 00 00 ld [ %o0 ], %i4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000cc68: 86 22 00 1c sub %o0, %i4, %g3
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000cc6c: 80 a0 c0 1b cmp %g3, %i3
4000cc70: 0a 80 00 04 bcs 4000cc80 <_Heap_Free+0xdc> <== NEVER TAKEN
4000cc74: b2 10 20 00 clr %i1
4000cc78: 80 a1 00 03 cmp %g4, %g3
4000cc7c: b2 60 3f ff subx %g0, -1, %i1
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
4000cc80: 80 a6 60 00 cmp %i1, 0
4000cc84: 02 80 00 44 be 4000cd94 <_Heap_Free+0x1f0> <== NEVER TAKEN
4000cc88: 88 10 20 00 clr %g4
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000cc8c: f6 00 e0 04 ld [ %g3 + 4 ], %i3
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
4000cc90: 80 8e e0 01 btst 1, %i3
4000cc94: 02 80 00 40 be 4000cd94 <_Heap_Free+0x1f0> <== NEVER TAKEN
4000cc98: 80 8e a0 ff btst 0xff, %i2
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4000cc9c: 22 80 00 0f be,a 4000ccd8 <_Heap_Free+0x134>
4000cca0: b8 00 80 1c add %g2, %i4, %i4
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
4000cca4: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = block->prev;
4000cca8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
uintptr_t const size = block_size + prev_size + next_block_size;
4000ccac: ba 00 80 1d add %g2, %i5, %i5
prev->next = next;
4000ccb0: c8 20 60 08 st %g4, [ %g1 + 8 ]
next->prev = prev;
4000ccb4: c2 21 20 0c st %g1, [ %g4 + 0xc ]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4000ccb8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
4000ccbc: b8 07 40 1c add %i5, %i4, %i4
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4000ccc0: 82 00 7f ff add %g1, -1, %g1
4000ccc4: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
4000ccc8: f8 20 c0 1c st %i4, [ %g3 + %i4 ]
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000cccc: 82 17 20 01 or %i4, 1, %g1
4000ccd0: 10 80 00 27 b 4000cd6c <_Heap_Free+0x1c8>
4000ccd4: c2 20 e0 04 st %g1, [ %g3 + 4 ]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000ccd8: 88 17 20 01 or %i4, 1, %g4
4000ccdc: c8 20 e0 04 st %g4, [ %g3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000cce0: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = size;
4000cce4: f8 22 00 02 st %i4, [ %o0 + %g2 ]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000cce8: 86 08 ff fe and %g3, -2, %g3
4000ccec: 10 80 00 20 b 4000cd6c <_Heap_Free+0x1c8>
4000ccf0: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4000ccf4: 22 80 00 0d be,a 4000cd28 <_Heap_Free+0x184>
4000ccf8: c6 06 20 08 ld [ %i0 + 8 ], %g3
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4000ccfc: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = old_block->prev;
4000cd00: c2 00 60 0c ld [ %g1 + 0xc ], %g1
new_block->next = next;
4000cd04: c8 22 20 08 st %g4, [ %o0 + 8 ]
new_block->prev = prev;
4000cd08: c2 22 20 0c st %g1, [ %o0 + 0xc ]
uintptr_t const size = block_size + next_block_size;
4000cd0c: 86 07 40 02 add %i5, %g2, %g3
next->prev = new_block;
prev->next = new_block;
4000cd10: d0 20 60 08 st %o0, [ %g1 + 8 ]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
4000cd14: d0 21 20 0c st %o0, [ %g4 + 0xc ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000cd18: 82 10 e0 01 or %g3, 1, %g1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4000cd1c: c6 22 00 03 st %g3, [ %o0 + %g3 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000cd20: 10 80 00 13 b 4000cd6c <_Heap_Free+0x1c8>
4000cd24: c2 22 20 04 st %g1, [ %o0 + 4 ]
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
4000cd28: f0 22 20 0c st %i0, [ %o0 + 0xc ]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4000cd2c: c6 22 20 08 st %g3, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
4000cd30: d0 20 e0 0c st %o0, [ %g3 + 0xc ]
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4000cd34: 86 10 a0 01 or %g2, 1, %g3
4000cd38: c6 22 20 04 st %g3, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000cd3c: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = block_size;
4000cd40: c4 22 00 02 st %g2, [ %o0 + %g2 ]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000cd44: 86 08 ff fe and %g3, -2, %g3
4000cd48: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4000cd4c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
if ( stats->max_free_blocks < stats->free_blocks ) {
4000cd50: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4000cd54: 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;
4000cd58: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
4000cd5c: 80 a0 c0 01 cmp %g3, %g1
4000cd60: 1a 80 00 03 bcc 4000cd6c <_Heap_Free+0x1c8>
4000cd64: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
4000cd68: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
}
/* Statistics */
--stats->used_blocks;
4000cd6c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4000cd70: 82 00 7f ff add %g1, -1, %g1
4000cd74: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
++stats->frees;
4000cd78: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000cd7c: 82 00 60 01 inc %g1
4000cd80: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->free_size += block_size;
4000cd84: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4000cd88: 84 00 40 02 add %g1, %g2, %g2
4000cd8c: c4 26 20 30 st %g2, [ %i0 + 0x30 ]
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
4000cd90: 88 10 20 01 mov 1, %g4
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4000cd94: b0 09 20 01 and %g4, 1, %i0
4000cd98: 81 c7 e0 08 ret
4000cd9c: 81 e8 00 00 restore
40009e6c <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
40009e6c: 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) {
40009e70: b6 10 20 00 clr %i3
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
40009e74: ba 10 00 18 mov %i0, %i5
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
40009e78: 10 80 00 11 b 40009ebc <_Heap_Greedy_allocate+0x50>
40009e7c: b8 10 20 00 clr %i4
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
40009e80: d2 06 40 01 ld [ %i1 + %g1 ], %o1
40009e84: 90 10 00 1d mov %i5, %o0
40009e88: 94 10 20 00 clr %o2
40009e8c: 40 00 1d 02 call 40011294 <_Heap_Allocate_aligned_with_boundary>
40009e90: 96 10 20 00 clr %o3
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
40009e94: 82 92 20 00 orcc %o0, 0, %g1
40009e98: 22 80 00 09 be,a 40009ebc <_Heap_Greedy_allocate+0x50> <== NEVER TAKEN
40009e9c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
40009ea0: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
40009ea4: 40 00 34 08 call 40016ec4 <.urem>
40009ea8: 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);
40009eac: 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;
40009eb0: f8 22 20 08 st %i4, [ %o0 + 8 ]
40009eb4: b8 10 00 08 mov %o0, %i4
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
40009eb8: b6 06 e0 01 inc %i3
40009ebc: 80 a6 c0 1a cmp %i3, %i2
40009ec0: 12 bf ff f0 bne 40009e80 <_Heap_Greedy_allocate+0x14>
40009ec4: 83 2e e0 02 sll %i3, 2, %g1
40009ec8: 10 80 00 0a b 40009ef0 <_Heap_Greedy_allocate+0x84>
40009ecc: b0 10 20 00 clr %i0
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
_Heap_Block_allocate(
40009ed0: 90 10 00 1d mov %i5, %o0
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40009ed4: 96 0a ff fe and %o3, -2, %o3
40009ed8: 92 10 00 1b mov %i3, %o1
40009edc: 94 06 e0 08 add %i3, 8, %o2
40009ee0: 40 00 00 cb call 4000a20c <_Heap_Block_allocate>
40009ee4: 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;
40009ee8: f0 26 e0 08 st %i0, [ %i3 + 8 ]
40009eec: b0 10 00 1b mov %i3, %i0
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
40009ef0: f6 07 60 08 ld [ %i5 + 8 ], %i3
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
40009ef4: 80 a6 c0 1d cmp %i3, %i5
40009ef8: 32 bf ff f6 bne,a 40009ed0 <_Heap_Greedy_allocate+0x64>
40009efc: d6 06 e0 04 ld [ %i3 + 4 ], %o3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
40009f00: 10 80 00 07 b 40009f1c <_Heap_Greedy_allocate+0xb0>
40009f04: 80 a7 20 00 cmp %i4, 0
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
40009f08: 92 07 20 08 add %i4, 8, %o1
40009f0c: 90 10 00 1d mov %i5, %o0
40009f10: 40 00 1d 52 call 40011458 <_Heap_Free>
40009f14: b8 10 00 1b mov %i3, %i4
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
40009f18: 80 a7 20 00 cmp %i4, 0
40009f1c: 32 bf ff fb bne,a 40009f08 <_Heap_Greedy_allocate+0x9c>
40009f20: f6 07 20 08 ld [ %i4 + 8 ], %i3
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
40009f24: 81 c7 e0 08 ret
40009f28: 81 e8 00 00 restore
40012608 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40012608: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
4001260c: 90 10 20 00 clr %o0 <== NOT EXECUTED
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
Heap_Block *current = heap->first_block;
40012610: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
40012614: 10 80 00 0a b 4001263c <_Heap_Iterate+0x34> <== NOT EXECUTED
40012618: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== 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 );
4001261c: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
40012620: 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);
40012624: 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;
40012628: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
4001262c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40012630: 9f c6 40 00 call %i1 <== NOT EXECUTED
40012634: 94 0a a0 01 and %o2, 1, %o2 <== NOT EXECUTED
40012638: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
4001263c: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
40012640: 02 80 00 05 be 40012654 <_Heap_Iterate+0x4c> <== NOT EXECUTED
40012644: 90 1a 20 01 xor %o0, 1, %o0 <== NOT EXECUTED
40012648: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001264c: 32 bf ff f4 bne,a 4001261c <_Heap_Iterate+0x14> <== NOT EXECUTED
40012650: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40012654: 81 c7 e0 08 ret <== NOT EXECUTED
40012658: 81 e8 00 00 restore <== NOT EXECUTED
4001b440 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
4001b440: 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);
4001b444: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4001b448: 7f ff f2 a4 call 40017ed8 <.urem>
4001b44c: 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
4001b450: c8 06 20 20 ld [ %i0 + 0x20 ], %g4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4001b454: 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);
4001b458: 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;
4001b45c: 80 a2 00 04 cmp %o0, %g4
4001b460: 0a 80 00 05 bcs 4001b474 <_Heap_Size_of_alloc_area+0x34>
4001b464: 82 10 20 00 clr %g1
4001b468: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001b46c: 80 a0 40 08 cmp %g1, %o0
4001b470: 82 60 3f ff subx %g0, -1, %g1
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
4001b474: 80 a0 60 00 cmp %g1, 0
4001b478: 02 80 00 15 be 4001b4cc <_Heap_Size_of_alloc_area+0x8c>
4001b47c: 86 10 20 00 clr %g3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4001b480: c2 02 20 04 ld [ %o0 + 4 ], %g1
4001b484: 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);
4001b488: 82 02 00 01 add %o0, %g1, %g1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4001b48c: 80 a0 40 04 cmp %g1, %g4
4001b490: 0a 80 00 05 bcs 4001b4a4 <_Heap_Size_of_alloc_area+0x64> <== NEVER TAKEN
4001b494: 84 10 20 00 clr %g2
4001b498: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
4001b49c: 80 a0 80 01 cmp %g2, %g1
4001b4a0: 84 60 3f ff subx %g0, -1, %g2
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
4001b4a4: 80 a0 a0 00 cmp %g2, 0
4001b4a8: 02 80 00 09 be 4001b4cc <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
4001b4ac: 86 10 20 00 clr %g3
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4001b4b0: c4 00 60 04 ld [ %g1 + 4 ], %g2
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
4001b4b4: 80 88 a0 01 btst 1, %g2
4001b4b8: 02 80 00 05 be 4001b4cc <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
4001b4bc: 82 20 40 19 sub %g1, %i1, %g1
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
4001b4c0: 86 10 20 01 mov 1, %g3
|| !_Heap_Is_prev_used( next_block )
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
4001b4c4: 82 00 60 04 add %g1, 4, %g1
4001b4c8: c2 26 80 00 st %g1, [ %i2 ]
return true;
}
4001b4cc: b0 08 e0 01 and %g3, 1, %i0
4001b4d0: 81 c7 e0 08 ret
4001b4d4: 81 e8 00 00 restore
40008c6c <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
40008c6c: 9d e3 bf 80 save %sp, -128, %sp
40008c70: ac 10 00 19 mov %i1, %l6
uintptr_t const page_size = heap->page_size;
40008c74: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
uintptr_t const min_block_size = heap->min_block_size;
40008c78: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
Heap_Block *const first_block = heap->first_block;
40008c7c: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
40008c80: 80 a6 a0 00 cmp %i2, 0
40008c84: 02 80 00 05 be 40008c98 <_Heap_Walk+0x2c>
40008c88: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
40008c8c: 3b 10 00 23 sethi %hi(0x40008c00), %i5
40008c90: 10 80 00 04 b 40008ca0 <_Heap_Walk+0x34>
40008c94: ba 17 60 1c or %i5, 0x1c, %i5 ! 40008c1c <_Heap_Walk_print>
40008c98: 3b 10 00 23 sethi %hi(0x40008c00), %i5
40008c9c: ba 17 60 14 or %i5, 0x14, %i5 ! 40008c14 <_Heap_Walk_print_nothing>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40008ca0: 05 10 00 61 sethi %hi(0x40018400), %g2
40008ca4: c4 00 a3 48 ld [ %g2 + 0x348 ], %g2 ! 40018748 <_System_state_Current>
40008ca8: 80 a0 a0 03 cmp %g2, 3
40008cac: 22 80 00 04 be,a 40008cbc <_Heap_Walk+0x50>
40008cb0: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
return true;
40008cb4: 10 80 01 2a b 4000915c <_Heap_Walk+0x4f0>
40008cb8: b0 10 20 01 mov 1, %i0
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
40008cbc: da 06 20 18 ld [ %i0 + 0x18 ], %o5
40008cc0: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
40008cc4: f2 23 a0 60 st %i1, [ %sp + 0x60 ]
40008cc8: e0 23 a0 64 st %l0, [ %sp + 0x64 ]
40008ccc: c4 06 20 08 ld [ %i0 + 8 ], %g2
40008cd0: 90 10 00 16 mov %l6, %o0
40008cd4: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40008cd8: c4 06 20 0c ld [ %i0 + 0xc ], %g2
40008cdc: 92 10 20 00 clr %o1
40008ce0: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
40008ce4: 15 10 00 56 sethi %hi(0x40015800), %o2
40008ce8: 96 10 00 1c mov %i4, %o3
40008cec: 94 12 a1 08 or %o2, 0x108, %o2
40008cf0: 9f c7 40 00 call %i5
40008cf4: 98 10 00 1b mov %i3, %o4
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
40008cf8: 80 a7 20 00 cmp %i4, 0
40008cfc: 12 80 00 07 bne 40008d18 <_Heap_Walk+0xac>
40008d00: 80 8f 20 07 btst 7, %i4
(*printer)( source, true, "page size is zero\n" );
40008d04: 15 10 00 56 sethi %hi(0x40015800), %o2
40008d08: 90 10 00 16 mov %l6, %o0
40008d0c: 92 10 20 01 mov 1, %o1
40008d10: 10 80 00 37 b 40008dec <_Heap_Walk+0x180>
40008d14: 94 12 a1 a0 or %o2, 0x1a0, %o2
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
40008d18: 22 80 00 08 be,a 40008d38 <_Heap_Walk+0xcc>
40008d1c: 90 10 00 1b mov %i3, %o0
(*printer)(
40008d20: 15 10 00 56 sethi %hi(0x40015800), %o2
40008d24: 90 10 00 16 mov %l6, %o0
40008d28: 92 10 20 01 mov 1, %o1
40008d2c: 94 12 a1 b8 or %o2, 0x1b8, %o2
40008d30: 10 80 01 12 b 40009178 <_Heap_Walk+0x50c>
40008d34: 96 10 00 1c mov %i4, %o3
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40008d38: 7f ff e3 93 call 40001b84 <.urem>
40008d3c: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
40008d40: 80 a2 20 00 cmp %o0, 0
40008d44: 22 80 00 08 be,a 40008d64 <_Heap_Walk+0xf8>
40008d48: 90 06 60 08 add %i1, 8, %o0
(*printer)(
40008d4c: 15 10 00 56 sethi %hi(0x40015800), %o2
40008d50: 90 10 00 16 mov %l6, %o0
40008d54: 92 10 20 01 mov 1, %o1
40008d58: 94 12 a1 d8 or %o2, 0x1d8, %o2
40008d5c: 10 80 01 07 b 40009178 <_Heap_Walk+0x50c>
40008d60: 96 10 00 1b mov %i3, %o3
40008d64: 7f ff e3 88 call 40001b84 <.urem>
40008d68: 92 10 00 1c mov %i4, %o1
);
return false;
}
if (
40008d6c: 80 a2 20 00 cmp %o0, 0
40008d70: 22 80 00 07 be,a 40008d8c <_Heap_Walk+0x120>
40008d74: c4 06 60 04 ld [ %i1 + 4 ], %g2
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
40008d78: 15 10 00 56 sethi %hi(0x40015800), %o2
40008d7c: 90 10 00 16 mov %l6, %o0
40008d80: 92 10 20 01 mov 1, %o1
40008d84: 10 80 00 fc b 40009174 <_Heap_Walk+0x508>
40008d88: 94 12 a2 00 or %o2, 0x200, %o2
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
40008d8c: 80 88 a0 01 btst 1, %g2
40008d90: 32 80 00 07 bne,a 40008dac <_Heap_Walk+0x140>
40008d94: f4 04 20 04 ld [ %l0 + 4 ], %i2
(*printer)(
40008d98: 15 10 00 56 sethi %hi(0x40015800), %o2
40008d9c: 90 10 00 16 mov %l6, %o0
40008da0: 92 10 20 01 mov 1, %o1
40008da4: 10 80 00 12 b 40008dec <_Heap_Walk+0x180>
40008da8: 94 12 a2 38 or %o2, 0x238, %o2
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40008dac: b4 0e bf fe and %i2, -2, %i2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
40008db0: b4 04 00 1a add %l0, %i2, %i2
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40008db4: c4 06 a0 04 ld [ %i2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
40008db8: 80 88 a0 01 btst 1, %g2
40008dbc: 12 80 00 07 bne 40008dd8 <_Heap_Walk+0x16c>
40008dc0: 80 a6 80 19 cmp %i2, %i1
(*printer)(
40008dc4: 15 10 00 56 sethi %hi(0x40015800), %o2
40008dc8: 90 10 00 16 mov %l6, %o0
40008dcc: 92 10 20 01 mov 1, %o1
40008dd0: 10 80 00 07 b 40008dec <_Heap_Walk+0x180>
40008dd4: 94 12 a2 68 or %o2, 0x268, %o2
);
return false;
}
if (
40008dd8: 02 80 00 0a be 40008e00 <_Heap_Walk+0x194>
40008ddc: 15 10 00 56 sethi %hi(0x40015800), %o2
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
40008de0: 90 10 00 16 mov %l6, %o0
40008de4: 92 10 20 01 mov 1, %o1
40008de8: 94 12 a2 80 or %o2, 0x280, %o2
40008dec: 9f c7 40 00 call %i5
40008df0: b0 10 20 00 clr %i0
40008df4: b0 0e 20 ff and %i0, 0xff, %i0
40008df8: 81 c7 e0 08 ret
40008dfc: 81 e8 00 00 restore
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
40008e00: e2 06 20 10 ld [ %i0 + 0x10 ], %l1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
40008e04: d6 06 20 08 ld [ %i0 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
40008e08: 10 80 00 30 b 40008ec8 <_Heap_Walk+0x25c>
40008e0c: b2 10 00 18 mov %i0, %i1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40008e10: 80 a0 c0 0b cmp %g3, %o3
40008e14: 18 80 00 05 bgu 40008e28 <_Heap_Walk+0x1bc>
40008e18: 84 10 20 00 clr %g2
40008e1c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
40008e20: 80 a0 80 0b cmp %g2, %o3
40008e24: 84 60 3f ff subx %g0, -1, %g2
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
40008e28: 80 a0 a0 00 cmp %g2, 0
40008e2c: 32 80 00 07 bne,a 40008e48 <_Heap_Walk+0x1dc>
40008e30: 90 02 e0 08 add %o3, 8, %o0
(*printer)(
40008e34: 15 10 00 56 sethi %hi(0x40015800), %o2
40008e38: 90 10 00 16 mov %l6, %o0
40008e3c: 92 10 20 01 mov 1, %o1
40008e40: 10 80 00 ce b 40009178 <_Heap_Walk+0x50c>
40008e44: 94 12 a2 b0 or %o2, 0x2b0, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40008e48: d6 27 bf fc st %o3, [ %fp + -4 ]
40008e4c: 7f ff e3 4e call 40001b84 <.urem>
40008e50: 92 10 00 11 mov %l1, %o1
);
return false;
}
if (
40008e54: 80 a2 20 00 cmp %o0, 0
40008e58: 02 80 00 07 be 40008e74 <_Heap_Walk+0x208>
40008e5c: d6 07 bf fc ld [ %fp + -4 ], %o3
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
40008e60: 15 10 00 56 sethi %hi(0x40015800), %o2
40008e64: 90 10 00 16 mov %l6, %o0
40008e68: 92 10 20 01 mov 1, %o1
40008e6c: 10 80 00 c3 b 40009178 <_Heap_Walk+0x50c>
40008e70: 94 12 a2 d0 or %o2, 0x2d0, %o2
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40008e74: c4 02 e0 04 ld [ %o3 + 4 ], %g2
40008e78: 84 08 bf fe and %g2, -2, %g2
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40008e7c: 84 02 c0 02 add %o3, %g2, %g2
40008e80: c4 00 a0 04 ld [ %g2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
40008e84: 80 88 a0 01 btst 1, %g2
40008e88: 22 80 00 07 be,a 40008ea4 <_Heap_Walk+0x238>
40008e8c: d8 02 e0 0c ld [ %o3 + 0xc ], %o4
(*printer)(
40008e90: 15 10 00 56 sethi %hi(0x40015800), %o2
40008e94: 90 10 00 16 mov %l6, %o0
40008e98: 92 10 20 01 mov 1, %o1
40008e9c: 10 80 00 b7 b 40009178 <_Heap_Walk+0x50c>
40008ea0: 94 12 a3 00 or %o2, 0x300, %o2
);
return false;
}
if ( free_block->prev != prev_block ) {
40008ea4: 80 a3 00 19 cmp %o4, %i1
40008ea8: 02 80 00 07 be 40008ec4 <_Heap_Walk+0x258>
40008eac: b2 10 00 0b mov %o3, %i1
(*printer)(
40008eb0: 15 10 00 56 sethi %hi(0x40015800), %o2
40008eb4: 90 10 00 16 mov %l6, %o0
40008eb8: 92 10 20 01 mov 1, %o1
40008ebc: 10 80 00 4d b 40008ff0 <_Heap_Walk+0x384>
40008ec0: 94 12 a3 20 or %o2, 0x320, %o2
return false;
}
prev_block = free_block;
free_block = free_block->next;
40008ec4: d6 02 e0 08 ld [ %o3 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
40008ec8: 80 a2 c0 18 cmp %o3, %i0
40008ecc: 32 bf ff d1 bne,a 40008e10 <_Heap_Walk+0x1a4>
40008ed0: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
40008ed4: 2b 10 00 57 sethi %hi(0x40015c00), %l5
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
40008ed8: b2 10 00 1a mov %i2, %i1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
40008edc: aa 15 60 20 or %l5, 0x20, %l5
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
40008ee0: 23 10 00 57 sethi %hi(0x40015c00), %l1
40008ee4: 2f 10 00 56 sethi %hi(0x40015800), %l7
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40008ee8: e4 06 60 04 ld [ %i1 + 4 ], %l2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40008eec: d8 06 20 20 ld [ %i0 + 0x20 ], %o4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
40008ef0: 9e 1e 40 10 xor %i1, %l0, %o7
40008ef4: 80 a0 00 0f cmp %g0, %o7
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40008ef8: a8 0c bf fe and %l2, -2, %l4
40008efc: 9a 40 20 00 addx %g0, 0, %o5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
40008f00: a6 06 40 14 add %i1, %l4, %l3
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40008f04: a4 0c a0 01 and %l2, 1, %l2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40008f08: 80 a3 00 13 cmp %o4, %l3
40008f0c: 18 80 00 05 bgu 40008f20 <_Heap_Walk+0x2b4> <== NEVER TAKEN
40008f10: 9e 10 20 00 clr %o7
40008f14: de 06 20 24 ld [ %i0 + 0x24 ], %o7
40008f18: 80 a3 c0 13 cmp %o7, %l3
40008f1c: 9e 60 3f ff subx %g0, -1, %o7
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
40008f20: 80 a3 e0 00 cmp %o7, 0
40008f24: 32 80 00 07 bne,a 40008f40 <_Heap_Walk+0x2d4>
40008f28: da 27 bf f8 st %o5, [ %fp + -8 ]
(*printer)(
40008f2c: 15 10 00 56 sethi %hi(0x40015800), %o2
40008f30: 90 10 00 16 mov %l6, %o0
40008f34: 92 10 20 01 mov 1, %o1
40008f38: 10 80 00 2c b 40008fe8 <_Heap_Walk+0x37c>
40008f3c: 94 12 a3 58 or %o2, 0x358, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40008f40: 90 10 00 14 mov %l4, %o0
40008f44: 7f ff e3 10 call 40001b84 <.urem>
40008f48: 92 10 00 1c mov %i4, %o1
40008f4c: da 07 bf f8 ld [ %fp + -8 ], %o5
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40008f50: 80 a2 20 00 cmp %o0, 0
40008f54: 02 80 00 0c be 40008f84 <_Heap_Walk+0x318>
40008f58: 9e 0b 60 ff and %o5, 0xff, %o7
40008f5c: 80 a3 e0 00 cmp %o7, 0
40008f60: 02 80 00 19 be 40008fc4 <_Heap_Walk+0x358>
40008f64: 80 a6 40 13 cmp %i1, %l3
(*printer)(
40008f68: 15 10 00 56 sethi %hi(0x40015800), %o2
40008f6c: 90 10 00 16 mov %l6, %o0
40008f70: 92 10 20 01 mov 1, %o1
40008f74: 94 12 a3 88 or %o2, 0x388, %o2
40008f78: 96 10 00 19 mov %i1, %o3
40008f7c: 10 80 00 1d b 40008ff0 <_Heap_Walk+0x384>
40008f80: 98 10 00 14 mov %l4, %o4
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
40008f84: 80 a3 e0 00 cmp %o7, 0
40008f88: 02 80 00 0f be 40008fc4 <_Heap_Walk+0x358>
40008f8c: 80 a6 40 13 cmp %i1, %l3
40008f90: 80 a5 00 1b cmp %l4, %i3
40008f94: 1a 80 00 0c bcc 40008fc4 <_Heap_Walk+0x358>
40008f98: 80 a6 40 13 cmp %i1, %l3
(*printer)(
40008f9c: 90 10 00 16 mov %l6, %o0
40008fa0: 92 10 20 01 mov 1, %o1
40008fa4: 15 10 00 56 sethi %hi(0x40015800), %o2
40008fa8: 96 10 00 19 mov %i1, %o3
40008fac: 94 12 a3 b8 or %o2, 0x3b8, %o2
40008fb0: 98 10 00 14 mov %l4, %o4
40008fb4: 9f c7 40 00 call %i5
40008fb8: 9a 10 00 1b mov %i3, %o5
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
40008fbc: 10 80 00 68 b 4000915c <_Heap_Walk+0x4f0>
40008fc0: b0 10 20 00 clr %i0
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
40008fc4: 2a 80 00 10 bcs,a 40009004 <_Heap_Walk+0x398>
40008fc8: de 04 e0 04 ld [ %l3 + 4 ], %o7
40008fcc: 80 8b 60 ff btst 0xff, %o5
40008fd0: 22 80 00 0d be,a 40009004 <_Heap_Walk+0x398>
40008fd4: de 04 e0 04 ld [ %l3 + 4 ], %o7
(*printer)(
40008fd8: 15 10 00 56 sethi %hi(0x40015800), %o2
40008fdc: 90 10 00 16 mov %l6, %o0
40008fe0: 92 10 20 01 mov 1, %o1
40008fe4: 94 12 a3 e8 or %o2, 0x3e8, %o2
40008fe8: 96 10 00 19 mov %i1, %o3
40008fec: 98 10 00 13 mov %l3, %o4
40008ff0: 9f c7 40 00 call %i5
40008ff4: b0 10 20 00 clr %i0
40008ff8: b0 0e 20 ff and %i0, 0xff, %i0
40008ffc: 81 c7 e0 08 ret
40009000: 81 e8 00 00 restore
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
40009004: 80 8b e0 01 btst 1, %o7
40009008: 12 80 00 3f bne 40009104 <_Heap_Walk+0x498>
4000900c: 90 10 00 16 mov %l6, %o0
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
40009010: da 06 60 0c ld [ %i1 + 0xc ], %o5
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
40009014: d8 06 20 08 ld [ %i0 + 8 ], %o4
40009018: 80 a3 40 0c cmp %o5, %o4
4000901c: 02 80 00 08 be 4000903c <_Heap_Walk+0x3d0>
40009020: de 06 20 0c ld [ %i0 + 0xc ], %o7
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
40009024: 80 a3 40 18 cmp %o5, %i0
40009028: 12 80 00 07 bne 40009044 <_Heap_Walk+0x3d8>
4000902c: 96 14 60 90 or %l1, 0x90, %o3
40009030: 17 10 00 56 sethi %hi(0x40015800), %o3
40009034: 10 80 00 04 b 40009044 <_Heap_Walk+0x3d8>
40009038: 96 12 e0 d8 or %o3, 0xd8, %o3 ! 400158d8 <__log2table+0x130>
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
4000903c: 03 10 00 56 sethi %hi(0x40015800), %g1
40009040: 96 10 60 c8 or %g1, 0xc8, %o3 ! 400158c8 <__log2table+0x120>
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
40009044: d8 06 60 08 ld [ %i1 + 8 ], %o4
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
40009048: 80 a3 00 0f cmp %o4, %o7
4000904c: 02 80 00 06 be 40009064 <_Heap_Walk+0x3f8>
40009050: 80 a3 00 18 cmp %o4, %i0
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
40009054: 12 80 00 06 bne 4000906c <_Heap_Walk+0x400>
40009058: 9e 14 60 90 or %l1, 0x90, %o7
4000905c: 10 80 00 04 b 4000906c <_Heap_Walk+0x400>
40009060: 9e 15 e0 f8 or %l7, 0xf8, %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)(
40009064: 03 10 00 56 sethi %hi(0x40015800), %g1
40009068: 9e 10 60 e8 or %g1, 0xe8, %o7 ! 400158e8 <__log2table+0x140>
4000906c: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
40009070: d8 23 a0 60 st %o4, [ %sp + 0x60 ]
40009074: de 23 a0 64 st %o7, [ %sp + 0x64 ]
40009078: 90 10 00 16 mov %l6, %o0
4000907c: 92 10 20 00 clr %o1
40009080: 94 10 00 15 mov %l5, %o2
40009084: 96 10 00 19 mov %i1, %o3
40009088: 9f c7 40 00 call %i5
4000908c: 98 10 00 14 mov %l4, %o4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
40009090: da 04 c0 00 ld [ %l3 ], %o5
40009094: 80 a5 00 0d cmp %l4, %o5
40009098: 02 80 00 0c be 400090c8 <_Heap_Walk+0x45c>
4000909c: 80 a4 a0 00 cmp %l2, 0
(*printer)(
400090a0: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
400090a4: 90 10 00 16 mov %l6, %o0
400090a8: 92 10 20 01 mov 1, %o1
400090ac: 15 10 00 57 sethi %hi(0x40015c00), %o2
400090b0: 96 10 00 19 mov %i1, %o3
400090b4: 94 12 a0 58 or %o2, 0x58, %o2
400090b8: 9f c7 40 00 call %i5
400090bc: 98 10 00 14 mov %l4, %o4
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
400090c0: 10 bf ff ce b 40008ff8 <_Heap_Walk+0x38c>
400090c4: b0 10 20 00 clr %i0
);
return false;
}
if ( !prev_used ) {
400090c8: 32 80 00 0a bne,a 400090f0 <_Heap_Walk+0x484>
400090cc: c6 06 20 08 ld [ %i0 + 8 ], %g3
(*printer)(
400090d0: 15 10 00 57 sethi %hi(0x40015c00), %o2
400090d4: 90 10 00 16 mov %l6, %o0
400090d8: 92 10 20 01 mov 1, %o1
400090dc: 10 80 00 26 b 40009174 <_Heap_Walk+0x508>
400090e0: 94 12 a0 98 or %o2, 0x98, %o2
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
400090e4: 22 80 00 19 be,a 40009148 <_Heap_Walk+0x4dc>
400090e8: b2 10 00 13 mov %l3, %i1
return true;
}
free_block = free_block->next;
400090ec: c6 00 e0 08 ld [ %g3 + 8 ], %g3
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
400090f0: 80 a0 c0 18 cmp %g3, %i0
400090f4: 12 bf ff fc bne 400090e4 <_Heap_Walk+0x478>
400090f8: 80 a0 c0 19 cmp %g3, %i1
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
400090fc: 10 80 00 1b b 40009168 <_Heap_Walk+0x4fc>
40009100: 15 10 00 57 sethi %hi(0x40015c00), %o2
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
40009104: 80 a4 a0 00 cmp %l2, 0
40009108: 02 80 00 09 be 4000912c <_Heap_Walk+0x4c0>
4000910c: 92 10 20 00 clr %o1
(*printer)(
40009110: 15 10 00 57 sethi %hi(0x40015c00), %o2
40009114: 96 10 00 19 mov %i1, %o3
40009118: 94 12 a0 c8 or %o2, 0xc8, %o2
4000911c: 9f c7 40 00 call %i5
40009120: 98 10 00 14 mov %l4, %o4
40009124: 10 80 00 09 b 40009148 <_Heap_Walk+0x4dc>
40009128: b2 10 00 13 mov %l3, %i1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4000912c: da 06 40 00 ld [ %i1 ], %o5
40009130: 15 10 00 57 sethi %hi(0x40015c00), %o2
40009134: 96 10 00 19 mov %i1, %o3
40009138: 94 12 a0 e0 or %o2, 0xe0, %o2
4000913c: 9f c7 40 00 call %i5
40009140: 98 10 00 14 mov %l4, %o4
40009144: b2 10 00 13 mov %l3, %i1
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
40009148: 80 a4 c0 1a cmp %l3, %i2
4000914c: 32 bf ff 68 bne,a 40008eec <_Heap_Walk+0x280>
40009150: e4 06 60 04 ld [ %i1 + 4 ], %l2
40009154: 10 80 00 02 b 4000915c <_Heap_Walk+0x4f0>
40009158: b0 10 20 01 mov 1, %i0
4000915c: b0 0e 20 ff and %i0, 0xff, %i0
40009160: 81 c7 e0 08 ret
40009164: 81 e8 00 00 restore
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
40009168: 90 10 00 16 mov %l6, %o0
4000916c: 92 10 20 01 mov 1, %o1
40009170: 94 12 a1 08 or %o2, 0x108, %o2
40009174: 96 10 00 19 mov %i1, %o3
40009178: 9f c7 40 00 call %i5
4000917c: b0 10 20 00 clr %i0
40009180: b0 0e 20 ff and %i0, 0xff, %i0
40009184: 81 c7 e0 08 ret
40009188: 81 e8 00 00 restore
400083a8 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
400083a8: 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 );
400083ac: 13 10 00 28 sethi %hi(0x4000a000), %o1
400083b0: 90 07 bf f4 add %fp, -12, %o0
400083b4: 92 12 63 30 or %o1, 0x330, %o1
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
400083b8: f0 27 bf f4 st %i0, [ %fp + -12 ]
400083bc: f2 2f bf f8 stb %i1, [ %fp + -8 ]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
400083c0: 40 00 07 e7 call 4000a35c <_User_extensions_Iterate>
400083c4: 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;
400083c8: 05 10 00 79 sethi %hi(0x4001e400), %g2 <== NOT EXECUTED
400083cc: 82 10 a2 fc or %g2, 0x2fc, %g1 ! 4001e6fc <_Internal_errors_What_happened><== NOT EXECUTED
400083d0: f0 20 a2 fc st %i0, [ %g2 + 0x2fc ] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
400083d4: f2 28 60 04 stb %i1, [ %g1 + 4 ] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
400083d8: 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;
400083dc: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
400083e0: 03 10 00 79 sethi %hi(0x4001e400), %g1 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
400083e4: 7f ff e7 31 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
400083e8: c4 20 63 08 st %g2, [ %g1 + 0x308 ] ! 4001e708 <_System_state_Current><== NOT EXECUTED
400083ec: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
400083f0: 30 80 00 00 b,a 400083f0 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
4000845c <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
4000845c: 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 )
40008460: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40008464: 80 a0 60 00 cmp %g1, 0
40008468: 12 80 00 04 bne 40008478 <_Objects_Allocate+0x1c> <== ALWAYS TAKEN
4000846c: ba 10 00 18 mov %i0, %i5
return NULL;
40008470: 81 c7 e0 08 ret
40008474: 91 e8 20 00 restore %g0, 0, %o0
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
40008478: b8 06 20 20 add %i0, 0x20, %i4
4000847c: 7f ff fd 85 call 40007a90 <_Chain_Get>
40008480: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
40008484: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
40008488: 80 a0 60 00 cmp %g1, 0
4000848c: 02 80 00 1d be 40008500 <_Objects_Allocate+0xa4>
40008490: 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 ) {
40008494: 80 a2 20 00 cmp %o0, 0
40008498: 32 80 00 0a bne,a 400084c0 <_Objects_Allocate+0x64>
4000849c: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Objects_Extend_information( information );
400084a0: 40 00 00 21 call 40008524 <_Objects_Extend_information>
400084a4: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
400084a8: 7f ff fd 7a call 40007a90 <_Chain_Get>
400084ac: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
400084b0: b0 92 20 00 orcc %o0, 0, %i0
400084b4: 02 bf ff ef be 40008470 <_Objects_Allocate+0x14>
400084b8: 01 00 00 00 nop
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
400084bc: c4 07 60 08 ld [ %i5 + 8 ], %g2
400084c0: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
400084c4: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
400084c8: 03 00 00 3f sethi %hi(0xfc00), %g1
400084cc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
400084d0: 90 0a 00 01 and %o0, %g1, %o0
400084d4: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
400084d8: 40 00 3d d4 call 40017c28 <.udiv>
400084dc: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
400084e0: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
400084e4: 91 2a 20 02 sll %o0, 2, %o0
400084e8: c4 00 40 08 ld [ %g1 + %o0 ], %g2
400084ec: 84 00 bf ff add %g2, -1, %g2
400084f0: c4 20 40 08 st %g2, [ %g1 + %o0 ]
information->inactive--;
400084f4: c2 17 60 2c lduh [ %i5 + 0x2c ], %g1
400084f8: 82 00 7f ff add %g1, -1, %g1
400084fc: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
40008500: 81 c7 e0 08 ret
40008504: 81 e8 00 00 restore
4000888c <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
4000888c: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
40008890: 80 a6 60 00 cmp %i1, 0
40008894: 12 80 00 04 bne 400088a4 <_Objects_Get_information+0x18>
40008898: 01 00 00 00 nop
return NULL;
4000889c: 81 c7 e0 08 ret
400088a0: 91 e8 20 00 restore %g0, 0, %o0
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
400088a4: 40 00 11 3f call 4000cda0 <_Objects_API_maximum_class>
400088a8: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
400088ac: 80 a2 20 00 cmp %o0, 0
400088b0: 02 bf ff fb be 4000889c <_Objects_Get_information+0x10>
400088b4: 80 a6 40 08 cmp %i1, %o0
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
400088b8: 18 bf ff f9 bgu 4000889c <_Objects_Get_information+0x10>
400088bc: 03 10 00 78 sethi %hi(0x4001e000), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
400088c0: b1 2e 20 02 sll %i0, 2, %i0
400088c4: 82 10 61 64 or %g1, 0x164, %g1
400088c8: c2 00 40 18 ld [ %g1 + %i0 ], %g1
400088cc: 80 a0 60 00 cmp %g1, 0
400088d0: 02 bf ff f3 be 4000889c <_Objects_Get_information+0x10> <== NEVER TAKEN
400088d4: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
400088d8: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
400088dc: 80 a6 20 00 cmp %i0, 0
400088e0: 02 bf ff ef be 4000889c <_Objects_Get_information+0x10> <== NEVER TAKEN
400088e4: 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 )
400088e8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
400088ec: 80 a0 60 00 cmp %g1, 0
400088f0: 02 bf ff eb be 4000889c <_Objects_Get_information+0x10>
400088f4: 01 00 00 00 nop
return NULL;
#endif
return info;
}
400088f8: 81 c7 e0 08 ret
400088fc: 81 e8 00 00 restore
4001ac84 <_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;
4001ac84: c2 02 20 08 ld [ %o0 + 8 ], %g1
4001ac88: 92 22 40 01 sub %o1, %g1, %o1
if ( information->maximum >= index ) {
4001ac8c: 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;
4001ac90: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
4001ac94: 80 a0 40 09 cmp %g1, %o1
4001ac98: 0a 80 00 09 bcs 4001acbc <_Objects_Get_no_protection+0x38>
4001ac9c: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
4001aca0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4001aca4: d0 00 40 09 ld [ %g1 + %o1 ], %o0
4001aca8: 80 a2 20 00 cmp %o0, 0
4001acac: 02 80 00 05 be 4001acc0 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
4001acb0: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
4001acb4: 81 c3 e0 08 retl
4001acb8: 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;
4001acbc: 82 10 20 01 mov 1, %g1
return NULL;
4001acc0: 90 10 20 00 clr %o0
}
4001acc4: 81 c3 e0 08 retl
4001acc8: c2 22 80 00 st %g1, [ %o2 ]
4000c9b0 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
4000c9b0: 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;
4000c9b4: 80 a6 20 00 cmp %i0, 0
4000c9b8: 12 80 00 06 bne 4000c9d0 <_Objects_Id_to_name+0x20>
4000c9bc: 83 36 20 18 srl %i0, 0x18, %g1
4000c9c0: 03 10 00 bb sethi %hi(0x4002ec00), %g1
4000c9c4: c2 00 60 40 ld [ %g1 + 0x40 ], %g1 ! 4002ec40 <_Per_CPU_Information+0x10>
4000c9c8: f0 00 60 08 ld [ %g1 + 8 ], %i0
4000c9cc: 83 36 20 18 srl %i0, 0x18, %g1
4000c9d0: 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 )
4000c9d4: 84 00 7f ff add %g1, -1, %g2
4000c9d8: 80 a0 a0 02 cmp %g2, 2
4000c9dc: 08 80 00 18 bleu 4000ca3c <_Objects_Id_to_name+0x8c>
4000c9e0: 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;
4000c9e4: 81 c7 e0 08 ret
4000c9e8: 91 e8 20 03 restore %g0, 3, %o0
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
4000c9ec: 85 28 a0 02 sll %g2, 2, %g2
4000c9f0: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
4000c9f4: 80 a2 20 00 cmp %o0, 0
4000c9f8: 02 bf ff fb be 4000c9e4 <_Objects_Id_to_name+0x34> <== NEVER TAKEN
4000c9fc: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
4000ca00: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
4000ca04: 80 a0 60 00 cmp %g1, 0
4000ca08: 12 bf ff f7 bne 4000c9e4 <_Objects_Id_to_name+0x34> <== NEVER TAKEN
4000ca0c: 92 10 00 18 mov %i0, %o1
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
4000ca10: 7f ff ff cb call 4000c93c <_Objects_Get>
4000ca14: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
4000ca18: 80 a2 20 00 cmp %o0, 0
4000ca1c: 02 bf ff f2 be 4000c9e4 <_Objects_Id_to_name+0x34>
4000ca20: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
4000ca24: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
4000ca28: 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();
4000ca2c: 40 00 03 99 call 4000d890 <_Thread_Enable_dispatch>
4000ca30: c2 26 40 00 st %g1, [ %i1 ]
4000ca34: 81 c7 e0 08 ret
4000ca38: 81 e8 00 00 restore
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
4000ca3c: 05 10 00 b9 sethi %hi(0x4002e400), %g2
4000ca40: 84 10 a2 44 or %g2, 0x244, %g2 ! 4002e644 <_Objects_Information_table>
4000ca44: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000ca48: 80 a0 60 00 cmp %g1, 0
4000ca4c: 12 bf ff e8 bne 4000c9ec <_Objects_Id_to_name+0x3c>
4000ca50: 85 36 20 1b srl %i0, 0x1b, %g2
4000ca54: 30 bf ff e4 b,a 4000c9e4 <_Objects_Id_to_name+0x34>
4000e2c0 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4000e2c0: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4000e2c4: 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 ];
4000e2c8: 39 00 00 3f sethi %hi(0xfc00), %i4
4000e2cc: b5 30 60 18 srl %g1, 0x18, %i2
4000e2d0: b8 17 23 ff or %i4, 0x3ff, %i4
4000e2d4: b4 0e a0 07 and %i2, 7, %i2
4000e2d8: b8 08 40 1c and %g1, %i4, %i4
4000e2dc: b4 06 a0 04 add %i2, 4, %i2
4000e2e0: b9 2f 20 02 sll %i4, 2, %i4
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
4000e2e4: 37 10 00 79 sethi %hi(0x4001e400), %i3
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
4000e2e8: b5 2e a0 02 sll %i2, 2, %i2
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
4000e2ec: 82 16 e1 dc or %i3, 0x1dc, %g1
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4000e2f0: ba 10 20 01 mov 1, %i5
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
4000e2f4: 84 10 20 01 mov 1, %g2
for ( index = 1 ; index <= max ; ++index ) {
4000e2f8: 10 80 00 18 b 4000e358 <_POSIX_Keys_Run_destructors+0x98>
4000e2fc: f2 10 60 10 lduh [ %g1 + 0x10 ], %i1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
4000e300: 86 16 e1 dc or %i3, 0x1dc, %g3
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
4000e304: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4000e308: 83 28 60 02 sll %g1, 2, %g1
4000e30c: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
4000e310: 80 a0 60 00 cmp %g1, 0
4000e314: 22 80 00 11 be,a 4000e358 <_POSIX_Keys_Run_destructors+0x98>
4000e318: ba 07 60 01 inc %i5
4000e31c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000e320: 80 a0 e0 00 cmp %g3, 0
4000e324: 02 80 00 0c be 4000e354 <_POSIX_Keys_Run_destructors+0x94>
4000e328: 86 00 40 1a add %g1, %i2, %g3
void *value = key->Values [ thread_api ][ thread_index ];
4000e32c: c6 00 e0 04 ld [ %g3 + 4 ], %g3
4000e330: d0 00 c0 1c ld [ %g3 + %i4 ], %o0
if ( value != NULL ) {
4000e334: 80 a2 20 00 cmp %o0, 0
4000e338: 22 80 00 08 be,a 4000e358 <_POSIX_Keys_Run_destructors+0x98><== ALWAYS TAKEN
4000e33c: ba 07 60 01 inc %i5
key->Values [ thread_api ][ thread_index ] = NULL;
4000e340: c0 20 c0 1c clr [ %g3 + %i4 ] <== NOT EXECUTED
(*key->destructor)( value );
4000e344: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
4000e348: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000e34c: 01 00 00 00 nop <== NOT EXECUTED
done = false;
4000e350: 84 10 20 00 clr %g2 ! 0 <PROM_START> <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4000e354: ba 07 60 01 inc %i5
4000e358: 83 2f 60 10 sll %i5, 0x10, %g1
4000e35c: 83 30 60 10 srl %g1, 0x10, %g1
4000e360: 80 a0 40 19 cmp %g1, %i1
4000e364: 08 bf ff e7 bleu 4000e300 <_POSIX_Keys_Run_destructors+0x40>
4000e368: 80 88 a0 ff btst 0xff, %g2
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
4000e36c: 02 bf ff e1 be 4000e2f0 <_POSIX_Keys_Run_destructors+0x30><== NEVER TAKEN
4000e370: 82 16 e1 dc or %i3, 0x1dc, %g1
done = false;
}
}
}
}
}
4000e374: 81 c7 e0 08 ret
4000e378: 81 e8 00 00 restore
4000bdfc <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
4000bdfc: 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(
4000be00: 11 10 00 a0 sethi %hi(0x40028000), %o0
4000be04: 92 10 00 18 mov %i0, %o1
4000be08: 90 12 21 a0 or %o0, 0x1a0, %o0
4000be0c: 40 00 0c c3 call 4000f118 <_Objects_Get>
4000be10: 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 ) {
4000be14: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000be18: 80 a0 60 00 cmp %g1, 0
4000be1c: 12 80 00 40 bne 4000bf1c <_POSIX_Message_queue_Receive_support+0x120>
4000be20: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
4000be24: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000be28: 84 08 60 03 and %g1, 3, %g2
4000be2c: 80 a0 a0 01 cmp %g2, 1
4000be30: 32 80 00 05 bne,a 4000be44 <_POSIX_Message_queue_Receive_support+0x48>
4000be34: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
_Thread_Enable_dispatch();
4000be38: 40 00 10 5f call 4000ffb4 <_Thread_Enable_dispatch>
4000be3c: 01 00 00 00 nop
4000be40: 30 80 00 37 b,a 4000bf1c <_POSIX_Message_queue_Receive_support+0x120>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
4000be44: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
4000be48: 80 a6 80 02 cmp %i2, %g2
4000be4c: 1a 80 00 08 bcc 4000be6c <_POSIX_Message_queue_Receive_support+0x70>
4000be50: 84 10 3f ff mov -1, %g2
_Thread_Enable_dispatch();
4000be54: 40 00 10 58 call 4000ffb4 <_Thread_Enable_dispatch>
4000be58: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4000be5c: 40 00 26 b4 call 4001592c <__errno>
4000be60: 01 00 00 00 nop
4000be64: 10 80 00 31 b 4000bf28 <_POSIX_Message_queue_Receive_support+0x12c>
4000be68: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
4000be6c: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4000be70: 80 a7 20 00 cmp %i4, 0
4000be74: 02 80 00 05 be 4000be88 <_POSIX_Message_queue_Receive_support+0x8c>
4000be78: 98 10 20 00 clr %o4
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
4000be7c: 99 30 60 0e srl %g1, 0xe, %o4
4000be80: 98 1b 20 01 xor %o4, 1, %o4
4000be84: 98 0b 20 01 and %o4, 1, %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
4000be88: 90 02 20 1c add %o0, 0x1c, %o0
4000be8c: 92 10 00 18 mov %i0, %o1
4000be90: 94 10 00 19 mov %i1, %o2
4000be94: 96 07 bf fc add %fp, -4, %o3
4000be98: 98 0b 20 01 and %o4, 1, %o4
4000be9c: 40 00 08 6c call 4000e04c <_CORE_message_queue_Seize>
4000bea0: 9a 10 00 1d mov %i5, %o5
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
4000bea4: 40 00 10 44 call 4000ffb4 <_Thread_Enable_dispatch>
4000bea8: 01 00 00 00 nop
if (msg_prio) {
4000beac: 80 a6 e0 00 cmp %i3, 0
4000beb0: 02 80 00 08 be 4000bed0 <_POSIX_Message_queue_Receive_support+0xd4><== NEVER TAKEN
4000beb4: 03 10 00 a0 sethi %hi(0x40028000), %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
4000beb8: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 40028230 <_Per_CPU_Information+0x10>
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return (unsigned int) ((priority >= 0) ? priority : -priority);
4000bebc: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000bec0: 83 38 a0 1f sra %g2, 0x1f, %g1
4000bec4: 84 18 40 02 xor %g1, %g2, %g2
4000bec8: 82 20 80 01 sub %g2, %g1, %g1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
4000becc: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
4000bed0: 3b 10 00 a0 sethi %hi(0x40028000), %i5
4000bed4: ba 17 62 20 or %i5, 0x220, %i5 ! 40028220 <_Per_CPU_Information>
4000bed8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000bedc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
4000bee0: 80 a0 60 00 cmp %g1, 0
4000bee4: 12 80 00 05 bne 4000bef8 <_POSIX_Message_queue_Receive_support+0xfc>
4000bee8: 01 00 00 00 nop
return length_out;
4000beec: f0 07 bf fc ld [ %fp + -4 ], %i0
4000bef0: 81 c7 e0 08 ret
4000bef4: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(
4000bef8: 40 00 26 8d call 4001592c <__errno>
4000befc: b0 10 3f ff mov -1, %i0
4000bf00: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000bf04: b8 10 00 08 mov %o0, %i4
4000bf08: 40 00 00 96 call 4000c160 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4000bf0c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
4000bf10: d0 27 00 00 st %o0, [ %i4 ]
4000bf14: 81 c7 e0 08 ret
4000bf18: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
4000bf1c: 40 00 26 84 call 4001592c <__errno>
4000bf20: 01 00 00 00 nop
4000bf24: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4000bf28: c2 22 00 00 st %g1, [ %o0 ]
4000bf2c: b0 10 3f ff mov -1, %i0
}
4000bf30: 81 c7 e0 08 ret
4000bf34: 81 e8 00 00 restore
4000e2cc <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
4000e2cc: 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)
4000e2d0: 80 a6 a0 00 cmp %i2, 0
4000e2d4: 22 80 00 06 be,a 4000e2ec <_POSIX_Semaphore_Create_support+0x20>
4000e2d8: 03 10 00 8b sethi %hi(0x40022c00), %g1
rtems_set_errno_and_return_minus_one( ENOSYS );
4000e2dc: 40 00 09 ad call 40010990 <__errno>
4000e2e0: 01 00 00 00 nop
4000e2e4: 10 80 00 10 b 4000e324 <_POSIX_Semaphore_Create_support+0x58>
4000e2e8: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
4000e2ec: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
++level;
4000e2f0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4000e2f4: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
4000e2f8: 21 10 00 8b sethi %hi(0x40022c00), %l0
4000e2fc: 7f ff ef 6f call 4000a0b8 <_Objects_Allocate>
4000e300: 90 14 22 d4 or %l0, 0x2d4, %o0 ! 40022ed4 <_POSIX_Semaphore_Information>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
4000e304: ba 92 20 00 orcc %o0, 0, %i5
4000e308: 12 80 00 0a bne 4000e330 <_POSIX_Semaphore_Create_support+0x64>
4000e30c: 80 a6 20 00 cmp %i0, 0
_Thread_Enable_dispatch();
4000e310: 7f ff f4 6a call 4000b4b8 <_Thread_Enable_dispatch>
4000e314: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSPC );
4000e318: 40 00 09 9e call 40010990 <__errno>
4000e31c: 01 00 00 00 nop
4000e320: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
4000e324: c2 22 00 00 st %g1, [ %o0 ]
4000e328: 81 c7 e0 08 ret
4000e32c: 91 e8 3f ff restore %g0, -1, %o0
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
4000e330: 02 80 00 10 be 4000e370 <_POSIX_Semaphore_Create_support+0xa4>
4000e334: 90 10 00 18 mov %i0, %o0
name = _Workspace_String_duplicate( name_arg, name_len );
4000e338: 40 00 03 ca call 4000f260 <_Workspace_String_duplicate>
4000e33c: 92 10 00 19 mov %i1, %o1
if ( !name ) {
4000e340: b4 92 20 00 orcc %o0, 0, %i2
4000e344: 12 80 00 0d bne 4000e378 <_POSIX_Semaphore_Create_support+0xac><== ALWAYS TAKEN
4000e348: 80 a6 a0 00 cmp %i2, 0
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
4000e34c: 90 14 22 d4 or %l0, 0x2d4, %o0 <== NOT EXECUTED
4000e350: 7f ff f0 39 call 4000a434 <_Objects_Free> <== NOT EXECUTED
4000e354: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
4000e358: 7f ff f4 58 call 4000b4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED
4000e35c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000e360: 40 00 09 8c call 40010990 <__errno> <== NOT EXECUTED
4000e364: 01 00 00 00 nop <== NOT EXECUTED
4000e368: 10 bf ff ef b 4000e324 <_POSIX_Semaphore_Create_support+0x58><== NOT EXECUTED
4000e36c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
}
} else {
name = NULL;
4000e370: b4 10 20 00 clr %i2
}
the_semaphore->process_shared = pshared;
if ( name ) {
4000e374: 80 a6 a0 00 cmp %i2, 0
4000e378: 02 80 00 08 be 4000e398 <_POSIX_Semaphore_Create_support+0xcc>
4000e37c: c0 27 60 10 clr [ %i5 + 0x10 ]
the_semaphore->named = true;
4000e380: 82 10 20 01 mov 1, %g1
4000e384: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
4000e388: 82 10 20 01 mov 1, %g1
4000e38c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
4000e390: 10 80 00 05 b 4000e3a4 <_POSIX_Semaphore_Create_support+0xd8>
4000e394: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
} else {
the_semaphore->named = false;
4000e398: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
4000e39c: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
4000e3a0: c0 2f 60 15 clrb [ %i5 + 0x15 ]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
4000e3a4: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000e3a8: 90 07 60 1c add %i5, 0x1c, %o0
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
4000e3ac: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000e3b0: 92 07 60 5c add %i5, 0x5c, %o1
4000e3b4: 94 10 00 1b mov %i3, %o2
4000e3b8: 7f ff ed b5 call 40009a8c <_CORE_semaphore_Initialize>
4000e3bc: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
4000e3c0: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000e3c4: 05 10 00 8b sethi %hi(0x40022c00), %g2
4000e3c8: c4 00 a2 f0 ld [ %g2 + 0x2f0 ], %g2 ! 40022ef0 <_POSIX_Semaphore_Information+0x1c>
4000e3cc: 83 28 60 02 sll %g1, 2, %g1
4000e3d0: 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;
4000e3d4: f4 27 60 0c st %i2, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
4000e3d8: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
4000e3dc: 7f ff f4 37 call 4000b4b8 <_Thread_Enable_dispatch>
4000e3e0: b0 10 20 00 clr %i0
return 0;
}
4000e3e4: 81 c7 e0 08 ret
4000e3e8: 81 e8 00 00 restore
4000b9d4 <_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 ];
4000b9d4: c2 02 21 50 ld [ %o0 + 0x150 ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4000b9d8: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
4000b9dc: 80 a0 a0 00 cmp %g2, 0
4000b9e0: 12 80 00 12 bne 4000ba28 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54><== NEVER TAKEN
4000b9e4: 01 00 00 00 nop
4000b9e8: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
4000b9ec: 80 a0 a0 01 cmp %g2, 1
4000b9f0: 12 80 00 0e bne 4000ba28 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
4000b9f4: 01 00 00 00 nop
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4000b9f8: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
4000b9fc: 80 a0 60 00 cmp %g1, 0
4000ba00: 02 80 00 0a be 4000ba28 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
4000ba04: 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;
4000ba08: 03 10 00 5b sethi %hi(0x40016c00), %g1
4000ba0c: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 40016fd0 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4000ba10: 92 10 3f ff mov -1, %o1
--level;
4000ba14: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000ba18: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ]
4000ba1c: 82 13 c0 00 mov %o7, %g1
4000ba20: 40 00 01 b5 call 4000c0f4 <_POSIX_Thread_Exit>
4000ba24: 9e 10 40 00 mov %g1, %o7
} else
_Thread_Enable_dispatch();
4000ba28: 82 13 c0 00 mov %o7, %g1
4000ba2c: 7f ff f6 d8 call 4000958c <_Thread_Enable_dispatch>
4000ba30: 9e 10 40 00 mov %g1, %o7
4000cd84 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4000cd84: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4000cd88: 7f ff ff f4 call 4000cd58 <_POSIX_Priority_Is_valid>
4000cd8c: d0 06 40 00 ld [ %i1 ], %o0
4000cd90: 80 8a 20 ff btst 0xff, %o0
4000cd94: 32 80 00 04 bne,a 4000cda4 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
4000cd98: c0 26 80 00 clr [ %i2 ]
return EINVAL;
4000cd9c: 81 c7 e0 08 ret
4000cda0: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
4000cda4: 80 a6 20 00 cmp %i0, 0
4000cda8: 12 80 00 06 bne 4000cdc0 <_POSIX_Thread_Translate_sched_param+0x3c>
4000cdac: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000cdb0: 82 10 20 01 mov 1, %g1
4000cdb4: c2 26 80 00 st %g1, [ %i2 ]
return 0;
4000cdb8: 81 c7 e0 08 ret
4000cdbc: 81 e8 00 00 restore
}
if ( policy == SCHED_FIFO ) {
4000cdc0: 80 a6 20 01 cmp %i0, 1
4000cdc4: 02 80 00 29 be 4000ce68 <_POSIX_Thread_Translate_sched_param+0xe4>
4000cdc8: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4000cdcc: 12 80 00 04 bne 4000cddc <_POSIX_Thread_Translate_sched_param+0x58>
4000cdd0: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4000cdd4: 10 80 00 25 b 4000ce68 <_POSIX_Thread_Translate_sched_param+0xe4>
4000cdd8: f0 26 80 00 st %i0, [ %i2 ]
return 0;
}
if ( policy == SCHED_SPORADIC ) {
4000cddc: 12 bf ff f0 bne 4000cd9c <_POSIX_Thread_Translate_sched_param+0x18>
4000cde0: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4000cde4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000cde8: 80 a0 60 00 cmp %g1, 0
4000cdec: 32 80 00 07 bne,a 4000ce08 <_POSIX_Thread_Translate_sched_param+0x84>
4000cdf0: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000cdf4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000cdf8: 80 a0 60 00 cmp %g1, 0
4000cdfc: 02 bf ff e8 be 4000cd9c <_POSIX_Thread_Translate_sched_param+0x18>
4000ce00: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4000ce04: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000ce08: 80 a0 60 00 cmp %g1, 0
4000ce0c: 12 80 00 06 bne 4000ce24 <_POSIX_Thread_Translate_sched_param+0xa0>
4000ce10: 01 00 00 00 nop
4000ce14: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000ce18: 80 a0 60 00 cmp %g1, 0
4000ce1c: 02 bf ff e0 be 4000cd9c <_POSIX_Thread_Translate_sched_param+0x18>
4000ce20: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4000ce24: 7f ff f7 d9 call 4000ad88 <_Timespec_To_ticks>
4000ce28: 90 06 60 08 add %i1, 8, %o0
4000ce2c: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4000ce30: 7f ff f7 d6 call 4000ad88 <_Timespec_To_ticks>
4000ce34: 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 ) <
4000ce38: 80 a7 40 08 cmp %i5, %o0
4000ce3c: 0a bf ff d8 bcs 4000cd9c <_POSIX_Thread_Translate_sched_param+0x18>
4000ce40: 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 ) )
4000ce44: 7f ff ff c5 call 4000cd58 <_POSIX_Priority_Is_valid>
4000ce48: d0 06 60 04 ld [ %i1 + 4 ], %o0
4000ce4c: 80 8a 20 ff btst 0xff, %o0
4000ce50: 02 bf ff d3 be 4000cd9c <_POSIX_Thread_Translate_sched_param+0x18>
4000ce54: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4000ce58: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4000ce5c: 03 10 00 1c sethi %hi(0x40007000), %g1
4000ce60: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 400071a0 <_POSIX_Threads_Sporadic_budget_callout>
4000ce64: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
return EINVAL;
}
4000ce68: 81 c7 e0 08 ret
4000ce6c: 91 e8 20 00 restore %g0, 0, %o0
4000c11c <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
4000c11c: 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 ];
4000c120: f0 06 61 50 ld [ %i1 + 0x150 ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
4000c124: 40 00 08 4d call 4000e258 <_POSIX_Threads_cancel_run>
4000c128: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
4000c12c: 90 10 00 19 mov %i1, %o0
4000c130: 40 00 08 64 call 4000e2c0 <_POSIX_Keys_Run_destructors>
4000c134: 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 )) )
4000c138: 10 80 00 03 b 4000c144 <_POSIX_Threads_Delete_extension+0x28>
4000c13c: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
4000c140: 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 )) )
4000c144: 7f ff f6 8f call 40009b80 <_Thread_queue_Dequeue>
4000c148: 90 10 00 1d mov %i5, %o0
4000c14c: 80 a2 20 00 cmp %o0, 0
4000c150: 32 bf ff fc bne,a 4000c140 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
4000c154: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
4000c158: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4000c15c: 80 a0 60 04 cmp %g1, 4
4000c160: 32 80 00 05 bne,a 4000c174 <_POSIX_Threads_Delete_extension+0x58>
4000c164: c0 26 61 50 clr [ %i1 + 0x150 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
4000c168: 7f ff f9 15 call 4000a5bc <_Watchdog_Remove>
4000c16c: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4000c170: c0 26 61 50 clr [ %i1 + 0x150 ]
_Workspace_Free( api );
4000c174: 7f ff f9 b3 call 4000a840 <_Workspace_Free>
4000c178: 81 e8 00 00 restore
40006efc <_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)
{
40006efc: 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;
40006f00: 03 10 00 78 sethi %hi(0x4001e000), %g1
40006f04: 82 10 60 b4 or %g1, 0xb4, %g1 ! 4001e0b4 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
40006f08: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
40006f0c: 80 a6 e0 00 cmp %i3, 0
40006f10: 02 80 00 1d be 40006f84 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
40006f14: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
40006f18: 80 a7 60 00 cmp %i5, 0
40006f1c: 02 80 00 1a be 40006f84 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
40006f20: 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 );
40006f24: 40 00 17 d3 call 4000ce70 <pthread_attr_init>
40006f28: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
40006f2c: 92 10 20 02 mov 2, %o1
40006f30: 40 00 17 dc call 4000cea0 <pthread_attr_setinheritsched>
40006f34: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
40006f38: d2 07 60 04 ld [ %i5 + 4 ], %o1
40006f3c: 40 00 17 e8 call 4000cedc <pthread_attr_setstacksize>
40006f40: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
40006f44: d4 07 40 00 ld [ %i5 ], %o2
40006f48: 90 07 bf bc add %fp, -68, %o0
40006f4c: 92 07 bf c0 add %fp, -64, %o1
40006f50: 96 10 20 00 clr %o3
40006f54: 7f ff ff 18 call 40006bb4 <pthread_create>
40006f58: ba 07 60 08 add %i5, 8, %i5
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
40006f5c: 80 a2 20 00 cmp %o0, 0
40006f60: 02 80 00 05 be 40006f74 <_POSIX_Threads_Initialize_user_threads_body+0x78>
40006f64: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
40006f68: 90 10 20 02 mov 2, %o0
40006f6c: 40 00 07 f8 call 40008f4c <_Internal_error_Occurred>
40006f70: 92 10 20 01 mov 1, %o1
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
40006f74: b8 07 20 01 inc %i4
40006f78: 80 a7 00 1b cmp %i4, %i3
40006f7c: 12 bf ff ea bne 40006f24 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
40006f80: 01 00 00 00 nop
40006f84: 81 c7 e0 08 ret
40006f88: 81 e8 00 00 restore
4000c270 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4000c270: 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 ];
4000c274: 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 );
4000c278: 40 00 03 82 call 4000d080 <_Timespec_To_ticks>
4000c27c: 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);
4000c280: 03 10 00 75 sethi %hi(0x4001d400), %g1
4000c284: d2 08 62 1c ldub [ %g1 + 0x21c ], %o1 ! 4001d61c <rtems_maximum_priority>
4000c288: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->cpu_time_budget = ticks;
4000c28c: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
4000c290: 92 22 40 01 sub %o1, %g1, %o1
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4000c294: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4000c298: 80 a0 60 00 cmp %g1, 0
4000c29c: 12 80 00 09 bne 4000c2c0 <_POSIX_Threads_Sporadic_budget_TSR+0x50><== NEVER TAKEN
4000c2a0: 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 ) {
4000c2a4: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000c2a8: 80 a0 40 09 cmp %g1, %o1
4000c2ac: 08 80 00 06 bleu 4000c2c4 <_POSIX_Threads_Sporadic_budget_TSR+0x54>
4000c2b0: 90 07 60 90 add %i5, 0x90, %o0
_Thread_Change_priority( the_thread, new_priority, true );
4000c2b4: 90 10 00 19 mov %i1, %o0
4000c2b8: 7f ff f4 40 call 400093b8 <_Thread_Change_priority>
4000c2bc: 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 );
4000c2c0: 90 07 60 90 add %i5, 0x90, %o0
4000c2c4: 40 00 03 6f call 4000d080 <_Timespec_To_ticks>
4000c2c8: 31 10 00 78 sethi %hi(0x4001e000), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000c2cc: b0 16 22 98 or %i0, 0x298, %i0 ! 4001e298 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000c2d0: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000c2d4: 7f ff f8 62 call 4000a45c <_Watchdog_Insert>
4000c2d8: 93 ef 60 a8 restore %i5, 0xa8, %o1
4000c2dc <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000c2dc: c4 02 21 50 ld [ %o0 + 0x150 ], %g2
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
4000c2e0: 86 10 3f ff mov -1, %g3
4000c2e4: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2
4000c2e8: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
4000c2ec: 07 10 00 75 sethi %hi(0x4001d400), %g3
4000c2f0: d2 08 e2 1c ldub [ %g3 + 0x21c ], %o1 ! 4001d61c <rtems_maximum_priority>
4000c2f4: 92 22 40 02 sub %o1, %g2, %o1
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4000c2f8: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
4000c2fc: 80 a0 a0 00 cmp %g2, 0
4000c300: 12 80 00 09 bne 4000c324 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
4000c304: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
4000c308: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000c30c: 80 a0 40 09 cmp %g1, %o1
4000c310: 1a 80 00 05 bcc 4000c324 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
4000c314: 94 10 20 01 mov 1, %o2
_Thread_Change_priority( the_thread, new_priority, true );
4000c318: 82 13 c0 00 mov %o7, %g1
4000c31c: 7f ff f4 27 call 400093b8 <_Thread_Change_priority>
4000c320: 9e 10 40 00 mov %g1, %o7
4000c324: 81 c3 e0 08 retl <== NOT EXECUTED
40006cb4 <_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)
{
40006cb4: 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;
40006cb8: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
40006cbc: 82 00 60 01 inc %g1
40006cc0: c2 26 60 68 st %g1, [ %i1 + 0x68 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
40006cc4: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
40006cc8: 80 a0 60 00 cmp %g1, 0
40006ccc: 32 80 00 07 bne,a 40006ce8 <_POSIX_Timer_TSR+0x34>
40006cd0: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
40006cd4: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
40006cd8: 80 a0 60 00 cmp %g1, 0
40006cdc: 02 80 00 1f be 40006d58 <_POSIX_Timer_TSR+0xa4> <== NEVER TAKEN
40006ce0: 82 10 20 04 mov 4, %g1
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
40006ce4: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
40006ce8: d4 06 60 08 ld [ %i1 + 8 ], %o2
40006cec: 90 06 60 10 add %i1, 0x10, %o0
40006cf0: 17 10 00 1b sethi %hi(0x40006c00), %o3
40006cf4: 98 10 00 19 mov %i1, %o4
40006cf8: 40 00 17 a5 call 4000cb8c <_POSIX_Timer_Insert_helper>
40006cfc: 96 12 e0 b4 or %o3, 0xb4, %o3
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
40006d00: 80 8a 20 ff btst 0xff, %o0
40006d04: 02 80 00 1a be 40006d6c <_POSIX_Timer_TSR+0xb8> <== NEVER TAKEN
40006d08: 90 07 bf f8 add %fp, -8, %o0
40006d0c: 13 10 00 7a sethi %hi(0x4001e800), %o1
40006d10: 40 00 05 ed call 400084c4 <_TOD_Get_with_nanoseconds>
40006d14: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4001ebb8 <_TOD>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
40006d18: 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);
40006d1c: 94 10 20 00 clr %o2
40006d20: 90 10 00 1c mov %i4, %o0
40006d24: 92 10 00 1d mov %i5, %o1
40006d28: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006d2c: 40 00 48 0b call 40018d58 <__divdi3>
40006d30: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006d34: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
40006d38: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006d3c: 94 10 20 00 clr %o2
40006d40: 92 10 00 1d mov %i5, %o1
40006d44: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006d48: 40 00 48 ef call 40019104 <__moddi3>
40006d4c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
/* 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;
40006d50: 82 10 20 03 mov 3, %g1
40006d54: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
40006d58: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
40006d5c: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
40006d60: 40 00 16 7a call 4000c748 <pthread_kill>
40006d64: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
40006d68: c0 26 60 68 clr [ %i1 + 0x68 ]
40006d6c: 81 c7 e0 08 ret
40006d70: 81 e8 00 00 restore
4000e37c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4000e37c: 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,
4000e380: 98 10 20 01 mov 1, %o4
4000e384: 90 10 00 18 mov %i0, %o0
4000e388: 92 10 00 19 mov %i1, %o1
4000e38c: 94 07 bf cc add %fp, -52, %o2
4000e390: 40 00 00 2e call 4000e448 <_POSIX_signals_Clear_signals>
4000e394: 96 10 00 1a mov %i2, %o3
4000e398: 80 8a 20 ff btst 0xff, %o0
4000e39c: 02 80 00 28 be 4000e43c <_POSIX_signals_Check_signal+0xc0>
4000e3a0: 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 )
4000e3a4: 85 2e 60 02 sll %i1, 2, %g2
4000e3a8: 35 10 00 79 sethi %hi(0x4001e400), %i2
4000e3ac: b7 2e 60 04 sll %i1, 4, %i3
4000e3b0: b4 16 a3 70 or %i2, 0x370, %i2
4000e3b4: b6 26 c0 02 sub %i3, %g2, %i3
4000e3b8: 84 06 80 1b add %i2, %i3, %g2
4000e3bc: fa 00 a0 08 ld [ %g2 + 8 ], %i5
4000e3c0: 80 a7 60 01 cmp %i5, 1
4000e3c4: 02 80 00 1e be 4000e43c <_POSIX_signals_Check_signal+0xc0><== NEVER TAKEN
4000e3c8: 90 07 bf d8 add %fp, -40, %o0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
4000e3cc: f8 06 20 d0 ld [ %i0 + 0xd0 ], %i4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4000e3d0: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000e3d4: 82 10 40 1c or %g1, %i4, %g1
4000e3d8: 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,
4000e3dc: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000e3e0: d2 00 63 20 ld [ %g1 + 0x320 ], %o1 ! 4001e720 <_Per_CPU_Information+0x10>
4000e3e4: 94 10 20 28 mov 0x28, %o2
4000e3e8: 40 00 03 f2 call 4000f3b0 <memcpy>
4000e3ec: 92 02 60 20 add %o1, 0x20, %o1
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
4000e3f0: c2 06 80 1b ld [ %i2 + %i3 ], %g1
4000e3f4: 80 a0 60 02 cmp %g1, 2
4000e3f8: 12 80 00 07 bne 4000e414 <_POSIX_signals_Check_signal+0x98>
4000e3fc: 90 10 00 19 mov %i1, %o0
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
4000e400: 92 07 bf cc add %fp, -52, %o1
4000e404: 9f c7 40 00 call %i5
4000e408: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4000e40c: 10 80 00 05 b 4000e420 <_POSIX_signals_Check_signal+0xa4>
4000e410: 03 10 00 79 sethi %hi(0x4001e400), %g1
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
4000e414: 9f c7 40 00 call %i5
4000e418: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
4000e41c: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000e420: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 4001e720 <_Per_CPU_Information+0x10>
4000e424: 92 07 bf d8 add %fp, -40, %o1
4000e428: 90 02 20 20 add %o0, 0x20, %o0
4000e42c: 40 00 03 e1 call 4000f3b0 <memcpy>
4000e430: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4000e434: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
4000e438: f8 26 20 d0 st %i4, [ %i0 + 0xd0 ]
return true;
}
4000e43c: b0 08 60 01 and %g1, 1, %i0
4000e440: 81 c7 e0 08 ret
4000e444: 81 e8 00 00 restore
4000e9c8 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
4000e9c8: 9d e3 bf a0 save %sp, -96, %sp
4000e9cc: 82 06 3f ff add %i0, -1, %g1
4000e9d0: ba 10 20 01 mov 1, %i5
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4000e9d4: 7f ff cd b5 call 400020a8 <sparc_disable_interrupts>
4000e9d8: bb 2f 40 01 sll %i5, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4000e9dc: 05 10 00 79 sethi %hi(0x4001e400), %g2
4000e9e0: 83 2e 20 02 sll %i0, 2, %g1
4000e9e4: 84 10 a3 70 or %g2, 0x370, %g2
4000e9e8: b1 2e 20 04 sll %i0, 4, %i0
4000e9ec: 82 26 00 01 sub %i0, %g1, %g1
4000e9f0: c4 00 80 01 ld [ %g2 + %g1 ], %g2
4000e9f4: 80 a0 a0 02 cmp %g2, 2
4000e9f8: 32 80 00 0c bne,a 4000ea28 <_POSIX_signals_Clear_process_signals+0x60>
4000e9fc: 03 10 00 7a sethi %hi(0x4001e800), %g1
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4000ea00: 05 10 00 7a sethi %hi(0x4001e800), %g2
4000ea04: 84 10 a1 68 or %g2, 0x168, %g2 ! 4001e968 <_POSIX_signals_Siginfo>
4000ea08: 86 00 40 02 add %g1, %g2, %g3
4000ea0c: c2 00 40 02 ld [ %g1 + %g2 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4000ea10: 86 00 e0 04 add %g3, 4, %g3
4000ea14: 80 a0 40 03 cmp %g1, %g3
4000ea18: 02 80 00 04 be 4000ea28 <_POSIX_signals_Clear_process_signals+0x60><== ALWAYS TAKEN
4000ea1c: 03 10 00 7a sethi %hi(0x4001e800), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
4000ea20: 7f ff cd a6 call 400020b8 <sparc_enable_interrupts>
4000ea24: 91 e8 00 08 restore %g0, %o0, %o0
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4000ea28: c4 00 61 64 ld [ %g1 + 0x164 ], %g2
4000ea2c: ba 28 80 1d andn %g2, %i5, %i5
4000ea30: 10 bf ff fc b 4000ea20 <_POSIX_signals_Clear_process_signals+0x58>
4000ea34: fa 20 61 64 st %i5, [ %g1 + 0x164 ]
400077ac <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
400077ac: 82 10 20 1b mov 0x1b, %g1
400077b0: 84 10 20 01 mov 1, %g2
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
400077b4: 86 00 7f ff add %g1, -1, %g3
400077b8: 87 28 80 03 sll %g2, %g3, %g3
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
400077bc: 80 88 c0 08 btst %g3, %o0
400077c0: 12 80 00 11 bne 40007804 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
400077c4: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
400077c8: 82 00 60 01 inc %g1
400077cc: 80 a0 60 20 cmp %g1, 0x20
400077d0: 12 bf ff fa bne 400077b8 <_POSIX_signals_Get_lowest+0xc>
400077d4: 86 00 7f ff add %g1, -1, %g3
400077d8: 82 10 20 01 mov 1, %g1
400077dc: 84 10 20 01 mov 1, %g2
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
400077e0: 86 00 7f ff add %g1, -1, %g3
400077e4: 87 28 80 03 sll %g2, %g3, %g3
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
400077e8: 80 88 c0 08 btst %g3, %o0
400077ec: 12 80 00 06 bne 40007804 <_POSIX_signals_Get_lowest+0x58>
400077f0: 01 00 00 00 nop
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
400077f4: 82 00 60 01 inc %g1
400077f8: 80 a0 60 1b cmp %g1, 0x1b
400077fc: 12 bf ff fa bne 400077e4 <_POSIX_signals_Get_lowest+0x38> <== ALWAYS TAKEN
40007800: 86 00 7f ff add %g1, -1, %g3
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
40007804: 81 c3 e0 08 retl
40007808: 90 10 00 01 mov %g1, %o0
4000bea8 <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
4000bea8: 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;
4000beac: 03 10 00 79 sethi %hi(0x4001e400), %g1
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000beb0: fa 06 21 50 ld [ %i0 + 0x150 ], %i5
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
4000beb4: c2 00 63 20 ld [ %g1 + 0x320 ], %g1
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
4000beb8: 80 a7 60 00 cmp %i5, 0
4000bebc: 02 80 00 11 be 4000bf00 <_POSIX_signals_Post_switch_hook+0x58><== NEVER TAKEN
4000bec0: f6 00 60 34 ld [ %g1 + 0x34 ], %i3
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000bec4: 35 10 00 7a sethi %hi(0x4001e800), %i2
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
4000bec8: 7f ff d8 78 call 400020a8 <sparc_disable_interrupts>
4000becc: 01 00 00 00 nop
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000bed0: c4 06 a1 64 ld [ %i2 + 0x164 ], %g2
4000bed4: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
4000bed8: 82 10 80 01 or %g2, %g1, %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4000bedc: c4 07 60 d0 ld [ %i5 + 0xd0 ], %g2
4000bee0: 80 a8 40 02 andncc %g1, %g2, %g0
4000bee4: 12 80 00 09 bne 4000bf08 <_POSIX_signals_Post_switch_hook+0x60>
4000bee8: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
4000beec: 7f ff d8 73 call 400020b8 <sparc_enable_interrupts>
4000bef0: 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;
4000bef4: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000bef8: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 4001e720 <_Per_CPU_Information+0x10>
4000befc: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
4000bf00: 81 c7 e0 08 ret
4000bf04: 81 e8 00 00 restore
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
4000bf08: 7f ff d8 6c call 400020b8 <sparc_enable_interrupts>
4000bf0c: b8 10 20 1b mov 0x1b, %i4
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4000bf10: 92 10 00 1c mov %i4, %o1
4000bf14: 94 10 20 00 clr %o2
4000bf18: 40 00 09 19 call 4000e37c <_POSIX_signals_Check_signal>
4000bf1c: 90 10 00 1d mov %i5, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000bf20: 92 10 00 1c mov %i4, %o1
4000bf24: 90 10 00 1d mov %i5, %o0
4000bf28: 40 00 09 15 call 4000e37c <_POSIX_signals_Check_signal>
4000bf2c: 94 10 20 01 mov 1, %o2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4000bf30: b8 07 20 01 inc %i4
4000bf34: 80 a7 20 20 cmp %i4, 0x20
4000bf38: 12 bf ff f7 bne 4000bf14 <_POSIX_signals_Post_switch_hook+0x6c>
4000bf3c: 92 10 00 1c mov %i4, %o1
4000bf40: b8 10 20 01 mov 1, %i4
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4000bf44: 92 10 00 1c mov %i4, %o1
4000bf48: 94 10 20 00 clr %o2
4000bf4c: 40 00 09 0c call 4000e37c <_POSIX_signals_Check_signal>
4000bf50: 90 10 00 1d mov %i5, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000bf54: 92 10 00 1c mov %i4, %o1
4000bf58: 90 10 00 1d mov %i5, %o0
4000bf5c: 40 00 09 08 call 4000e37c <_POSIX_signals_Check_signal>
4000bf60: 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++ ) {
4000bf64: b8 07 20 01 inc %i4
4000bf68: 80 a7 20 1b cmp %i4, 0x1b
4000bf6c: 12 bf ff f7 bne 4000bf48 <_POSIX_signals_Post_switch_hook+0xa0>
4000bf70: 92 10 00 1c mov %i4, %o1
4000bf74: 30 bf ff d5 b,a 4000bec8 <_POSIX_signals_Post_switch_hook+0x20>
4001b050 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
4001b050: 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 ) ) {
4001b054: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001b058: 3b 04 00 20 sethi %hi(0x10008000), %i5
4001b05c: 84 06 7f ff add %i1, -1, %g2
4001b060: 86 10 20 01 mov 1, %g3
4001b064: b8 08 40 1d and %g1, %i5, %i4
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4001b068: c8 06 21 50 ld [ %i0 + 0x150 ], %g4
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
4001b06c: 80 a7 00 1d cmp %i4, %i5
4001b070: 12 80 00 1e bne 4001b0e8 <_POSIX_signals_Unblock_thread+0x98>
4001b074: 85 28 c0 02 sll %g3, %g2, %g2
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
4001b078: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4001b07c: 80 88 80 01 btst %g2, %g1
4001b080: 12 80 00 08 bne 4001b0a0 <_POSIX_signals_Unblock_thread+0x50>
4001b084: 82 10 20 04 mov 4, %g1
4001b088: c2 01 20 d0 ld [ %g4 + 0xd0 ], %g1
4001b08c: 80 a8 80 01 andncc %g2, %g1, %g0
4001b090: 32 80 00 04 bne,a 4001b0a0 <_POSIX_signals_Unblock_thread+0x50>
4001b094: 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;
4001b098: 10 80 00 3d b 4001b18c <_POSIX_signals_Unblock_thread+0x13c>
4001b09c: b0 10 20 00 clr %i0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
4001b0a0: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
4001b0a4: 80 a6 a0 00 cmp %i2, 0
4001b0a8: 12 80 00 07 bne 4001b0c4 <_POSIX_signals_Unblock_thread+0x74>
4001b0ac: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
4001b0b0: 82 10 20 01 mov 1, %g1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
4001b0b4: f2 22 00 00 st %i1, [ %o0 ]
the_info->si_code = SI_USER;
4001b0b8: c2 22 20 04 st %g1, [ %o0 + 4 ]
the_info->si_value.sival_int = 0;
4001b0bc: 10 80 00 05 b 4001b0d0 <_POSIX_signals_Unblock_thread+0x80>
4001b0c0: c0 22 20 08 clr [ %o0 + 8 ]
} else {
*the_info = *info;
4001b0c4: 92 10 00 1a mov %i2, %o1
4001b0c8: 7f ff d0 ba call 4000f3b0 <memcpy>
4001b0cc: 94 10 20 0c mov 0xc, %o2
}
_Thread_queue_Extract_with_proxy( the_thread );
4001b0d0: 90 10 00 18 mov %i0, %o0
4001b0d4: 7f ff bb 98 call 40009f34 <_Thread_queue_Extract_with_proxy>
4001b0d8: b0 10 20 01 mov 1, %i0
4001b0dc: b0 0e 20 01 and %i0, 1, %i0
4001b0e0: 81 c7 e0 08 ret
4001b0e4: 81 e8 00 00 restore
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
4001b0e8: c8 01 20 d0 ld [ %g4 + 0xd0 ], %g4
4001b0ec: 80 a8 80 04 andncc %g2, %g4, %g0
4001b0f0: 02 80 00 26 be 4001b188 <_POSIX_signals_Unblock_thread+0x138>
4001b0f4: 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 ) ) {
4001b0f8: 80 88 40 02 btst %g1, %g2
4001b0fc: 02 80 00 17 be 4001b158 <_POSIX_signals_Unblock_thread+0x108>
4001b100: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
4001b104: 84 10 20 04 mov 4, %g2
4001b108: c4 26 20 34 st %g2, [ %i0 + 0x34 ]
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
4001b10c: 05 00 00 ef sethi %hi(0x3bc00), %g2
4001b110: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
4001b114: 80 88 40 02 btst %g1, %g2
4001b118: 02 80 00 06 be 4001b130 <_POSIX_signals_Unblock_thread+0xe0>
4001b11c: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
4001b120: 7f ff bb 85 call 40009f34 <_Thread_queue_Extract_with_proxy>
4001b124: 90 10 00 18 mov %i0, %o0
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
4001b128: 10 80 00 19 b 4001b18c <_POSIX_signals_Unblock_thread+0x13c>
4001b12c: b0 10 20 00 clr %i0
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
4001b130: 22 80 00 17 be,a 4001b18c <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
4001b134: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4001b138: 7f ff bd 21 call 4000a5bc <_Watchdog_Remove>
4001b13c: 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 );
4001b140: 90 10 00 18 mov %i0, %o0
4001b144: 13 04 01 ff sethi %hi(0x1007fc00), %o1
4001b148: 7f ff b8 e0 call 400094c8 <_Thread_Clear_state>
4001b14c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
4001b150: 10 80 00 0f b 4001b18c <_POSIX_signals_Unblock_thread+0x13c>
4001b154: b0 10 20 00 clr %i0
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
4001b158: 32 80 00 0d bne,a 4001b18c <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
4001b15c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001b160: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001b164: 82 10 63 10 or %g1, 0x310, %g1 ! 4001e710 <_Per_CPU_Information>
4001b168: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001b16c: 80 a0 a0 00 cmp %g2, 0
4001b170: 22 80 00 07 be,a 4001b18c <_POSIX_signals_Unblock_thread+0x13c>
4001b174: b0 10 20 00 clr %i0
4001b178: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001b17c: 80 a6 00 02 cmp %i0, %g2
4001b180: 22 80 00 02 be,a 4001b188 <_POSIX_signals_Unblock_thread+0x138><== ALWAYS TAKEN
4001b184: c6 28 60 0c stb %g3, [ %g1 + 0xc ]
_Thread_Dispatch_necessary = true;
}
}
return false;
4001b188: b0 10 20 00 clr %i0
}
4001b18c: b0 0e 20 01 and %i0, 1, %i0
4001b190: 81 c7 e0 08 ret
4001b194: 81 e8 00 00 restore
400096d8 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
400096d8: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
400096dc: 80 a6 60 00 cmp %i1, 0
400096e0: 02 80 00 69 be 40009884 <_RBTree_Extract_unprotected+0x1ac>
400096e4: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
400096e8: c2 06 20 08 ld [ %i0 + 8 ], %g1
400096ec: 80 a6 40 01 cmp %i1, %g1
400096f0: 32 80 00 07 bne,a 4000970c <_RBTree_Extract_unprotected+0x34>
400096f4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
400096f8: 90 10 00 19 mov %i1, %o0
400096fc: 40 00 01 31 call 40009bc0 <_RBTree_Next_unprotected>
40009700: 92 10 20 01 mov 1, %o1
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
40009704: d0 26 20 08 st %o0, [ %i0 + 8 ]
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
40009708: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000970c: 80 a6 40 01 cmp %i1, %g1
40009710: 32 80 00 07 bne,a 4000972c <_RBTree_Extract_unprotected+0x54>
40009714: fa 06 60 04 ld [ %i1 + 4 ], %i5
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
40009718: 90 10 00 19 mov %i1, %o0
4000971c: 40 00 01 29 call 40009bc0 <_RBTree_Next_unprotected>
40009720: 92 10 20 00 clr %o1
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
40009724: d0 26 20 0c st %o0, [ %i0 + 0xc ]
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
40009728: fa 06 60 04 ld [ %i1 + 4 ], %i5
4000972c: 80 a7 60 00 cmp %i5, 0
40009730: 02 80 00 36 be 40009808 <_RBTree_Extract_unprotected+0x130>
40009734: f8 06 60 08 ld [ %i1 + 8 ], %i4
40009738: 80 a7 20 00 cmp %i4, 0
4000973c: 32 80 00 05 bne,a 40009750 <_RBTree_Extract_unprotected+0x78>
40009740: c2 07 60 08 ld [ %i5 + 8 ], %g1
40009744: 10 80 00 35 b 40009818 <_RBTree_Extract_unprotected+0x140>
40009748: 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];
4000974c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40009750: 80 a0 60 00 cmp %g1, 0
40009754: 32 bf ff fe bne,a 4000974c <_RBTree_Extract_unprotected+0x74>
40009758: 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];
4000975c: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
40009760: 80 a7 20 00 cmp %i4, 0
40009764: 02 80 00 05 be 40009778 <_RBTree_Extract_unprotected+0xa0>
40009768: 01 00 00 00 nop
leaf->parent = target->parent;
4000976c: c2 07 40 00 ld [ %i5 ], %g1
40009770: 10 80 00 04 b 40009780 <_RBTree_Extract_unprotected+0xa8>
40009774: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
40009778: 7f ff ff 73 call 40009544 <_RBTree_Extract_validate_unprotected>
4000977c: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
40009780: c4 07 40 00 ld [ %i5 ], %g2
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
40009784: c2 07 60 0c ld [ %i5 + 0xc ], %g1
dir = target != target->parent->child[0];
40009788: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000978c: 86 1f 40 03 xor %i5, %g3, %g3
40009790: 80 a0 00 03 cmp %g0, %g3
40009794: 86 40 20 00 addx %g0, 0, %g3
target->parent->child[dir] = leaf;
40009798: 87 28 e0 02 sll %g3, 2, %g3
4000979c: 84 00 80 03 add %g2, %g3, %g2
400097a0: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
400097a4: c4 06 40 00 ld [ %i1 ], %g2
400097a8: c6 00 a0 04 ld [ %g2 + 4 ], %g3
400097ac: 86 1e 40 03 xor %i1, %g3, %g3
400097b0: 80 a0 00 03 cmp %g0, %g3
400097b4: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = target;
400097b8: 87 28 e0 02 sll %g3, 2, %g3
400097bc: 84 00 80 03 add %g2, %g3, %g2
400097c0: fa 20 a0 04 st %i5, [ %g2 + 4 ]
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
400097c4: c4 06 60 08 ld [ %i1 + 8 ], %g2
400097c8: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
400097cc: c4 06 60 08 ld [ %i1 + 8 ], %g2
400097d0: 80 a0 a0 00 cmp %g2, 0
400097d4: 32 80 00 02 bne,a 400097dc <_RBTree_Extract_unprotected+0x104><== ALWAYS TAKEN
400097d8: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
400097dc: c4 06 60 04 ld [ %i1 + 4 ], %g2
400097e0: c4 27 60 04 st %g2, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
400097e4: c4 06 60 04 ld [ %i1 + 4 ], %g2
400097e8: 80 a0 a0 00 cmp %g2, 0
400097ec: 32 80 00 02 bne,a 400097f4 <_RBTree_Extract_unprotected+0x11c>
400097f0: fa 20 80 00 st %i5, [ %g2 ]
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
400097f4: c4 06 40 00 ld [ %i1 ], %g2
400097f8: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
400097fc: c4 06 60 0c ld [ %i1 + 0xc ], %g2
40009800: 10 80 00 14 b 40009850 <_RBTree_Extract_unprotected+0x178>
40009804: c4 27 60 0c st %g2, [ %i5 + 0xc ]
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
40009808: 80 a7 20 00 cmp %i4, 0
4000980c: 32 80 00 04 bne,a 4000981c <_RBTree_Extract_unprotected+0x144>
40009810: c2 06 40 00 ld [ %i1 ], %g1
40009814: 30 80 00 04 b,a 40009824 <_RBTree_Extract_unprotected+0x14c>
leaf->parent = the_node->parent;
40009818: c2 06 40 00 ld [ %i1 ], %g1
4000981c: 10 80 00 04 b 4000982c <_RBTree_Extract_unprotected+0x154>
40009820: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
40009824: 7f ff ff 48 call 40009544 <_RBTree_Extract_validate_unprotected>
40009828: 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];
4000982c: c4 06 40 00 ld [ %i1 ], %g2
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
40009830: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
40009834: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40009838: 86 1e 40 03 xor %i1, %g3, %g3
4000983c: 80 a0 00 03 cmp %g0, %g3
40009840: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = leaf;
40009844: 87 28 e0 02 sll %g3, 2, %g3
40009848: 84 00 80 03 add %g2, %g3, %g2
4000984c: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
40009850: 80 a0 60 00 cmp %g1, 0
40009854: 32 80 00 06 bne,a 4000986c <_RBTree_Extract_unprotected+0x194>
40009858: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
4000985c: 80 a7 20 00 cmp %i4, 0
40009860: 32 80 00 02 bne,a 40009868 <_RBTree_Extract_unprotected+0x190>
40009864: 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;
40009868: 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;
4000986c: c0 26 60 08 clr [ %i1 + 8 ]
40009870: c0 26 60 04 clr [ %i1 + 4 ]
40009874: 80 a0 60 00 cmp %g1, 0
40009878: 02 80 00 03 be 40009884 <_RBTree_Extract_unprotected+0x1ac>
4000987c: c0 26 40 00 clr [ %i1 ]
40009880: c0 20 60 0c clr [ %g1 + 0xc ]
40009884: 81 c7 e0 08 ret
40009888: 81 e8 00 00 restore
4000a950 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
4000a950: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
4000a954: 80 a6 20 00 cmp %i0, 0
4000a958: 02 80 00 10 be 4000a998 <_RBTree_Initialize+0x48> <== NEVER TAKEN
4000a95c: 01 00 00 00 nop
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
4000a960: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
4000a964: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
4000a968: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
4000a96c: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
4000a970: 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-- ) {
4000a974: 10 80 00 06 b 4000a98c <_RBTree_Initialize+0x3c>
4000a978: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
4000a97c: 90 10 00 18 mov %i0, %o0
4000a980: 7f ff ff 2e call 4000a638 <_RBTree_Insert_unprotected>
4000a984: b4 06 80 1c add %i2, %i4, %i2
4000a988: b6 06 ff ff add %i3, -1, %i3
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
4000a98c: 80 a6 e0 00 cmp %i3, 0
4000a990: 12 bf ff fb bne 4000a97c <_RBTree_Initialize+0x2c>
4000a994: 92 10 00 1a mov %i2, %o1
4000a998: 81 c7 e0 08 ret
4000a99c: 81 e8 00 00 restore
4000992c <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4000992c: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
40009930: 80 a6 60 00 cmp %i1, 0
40009934: 02 80 00 7c be 40009b24 <_RBTree_Insert_unprotected+0x1f8>
40009938: ba 10 00 18 mov %i0, %i5
RBTree_Node *iter_node = the_rbtree->root;
4000993c: f0 06 20 04 ld [ %i0 + 4 ], %i0
int compare_result;
if (!iter_node) { /* special case: first node inserted */
40009940: b6 96 20 00 orcc %i0, 0, %i3
40009944: 32 80 00 0c bne,a 40009974 <_RBTree_Insert_unprotected+0x48>
40009948: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
the_node->color = RBT_BLACK;
4000994c: c0 26 60 0c clr [ %i1 + 0xc ]
the_rbtree->root = the_node;
40009950: f2 27 60 04 st %i1, [ %i5 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
40009954: f2 27 60 0c st %i1, [ %i5 + 0xc ]
40009958: f2 27 60 08 st %i1, [ %i5 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
4000995c: fa 26 40 00 st %i5, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
40009960: c0 26 60 08 clr [ %i1 + 8 ]
40009964: c0 26 60 04 clr [ %i1 + 4 ]
40009968: 81 c7 e0 08 ret
4000996c: 81 e8 00 00 restore
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
40009970: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40009974: 90 10 00 19 mov %i1, %o0
40009978: 9f c0 40 00 call %g1
4000997c: 92 10 00 18 mov %i0, %o1
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
40009980: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
40009984: 80 a0 60 00 cmp %g1, 0
40009988: 02 80 00 05 be 4000999c <_RBTree_Insert_unprotected+0x70>
4000998c: b8 38 00 08 xnor %g0, %o0, %i4
40009990: 80 a2 20 00 cmp %o0, 0
40009994: 02 80 00 65 be 40009b28 <_RBTree_Insert_unprotected+0x1fc>
40009998: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
4000999c: b9 37 20 1f srl %i4, 0x1f, %i4
if (!iter_node->child[dir]) {
400099a0: 83 2f 20 02 sll %i4, 2, %g1
400099a4: 82 06 00 01 add %i0, %g1, %g1
400099a8: f0 00 60 04 ld [ %g1 + 4 ], %i0
400099ac: 80 a6 20 00 cmp %i0, 0
400099b0: 32 bf ff f0 bne,a 40009970 <_RBTree_Insert_unprotected+0x44>
400099b4: b6 10 00 18 mov %i0, %i3
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
400099b8: c0 26 60 08 clr [ %i1 + 8 ]
400099bc: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
400099c0: 84 10 20 01 mov 1, %g2
iter_node->child[dir] = the_node;
400099c4: 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;
400099c8: c4 26 60 0c st %g2, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
400099cc: f6 26 40 00 st %i3, [ %i1 ]
/* update min/max */
compare_result = the_rbtree->compare_function(
400099d0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
400099d4: b6 07 20 02 add %i4, 2, %i3
400099d8: 85 2e e0 02 sll %i3, 2, %g2
400099dc: d2 07 40 02 ld [ %i5 + %g2 ], %o1
400099e0: 9f c0 40 00 call %g1
400099e4: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
400099e8: 80 a7 20 00 cmp %i4, 0
400099ec: 12 80 00 06 bne 40009a04 <_RBTree_Insert_unprotected+0xd8>
400099f0: 80 a2 20 00 cmp %o0, 0
400099f4: 36 80 00 3c bge,a 40009ae4 <_RBTree_Insert_unprotected+0x1b8>
400099f8: d0 06 40 00 ld [ %i1 ], %o0
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
400099fc: 10 80 00 04 b 40009a0c <_RBTree_Insert_unprotected+0xe0>
40009a00: b7 2e e0 02 sll %i3, 2, %i3
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
40009a04: 04 80 00 37 ble 40009ae0 <_RBTree_Insert_unprotected+0x1b4>
40009a08: b7 2e e0 02 sll %i3, 2, %i3
the_rbtree->first[dir] = the_node;
40009a0c: 10 80 00 35 b 40009ae0 <_RBTree_Insert_unprotected+0x1b4>
40009a10: f2 27 40 1b st %i1, [ %i5 + %i3 ]
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
40009a14: 02 80 00 13 be 40009a60 <_RBTree_Insert_unprotected+0x134><== NEVER TAKEN
40009a18: 82 10 20 00 clr %g1
if(!(the_node->parent->parent->parent)) return NULL;
40009a1c: c2 07 40 00 ld [ %i5 ], %g1
40009a20: 80 a0 60 00 cmp %g1, 0
40009a24: 02 80 00 0f be 40009a60 <_RBTree_Insert_unprotected+0x134><== NEVER TAKEN
40009a28: 82 10 20 00 clr %g1
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
40009a2c: c2 07 60 04 ld [ %i5 + 4 ], %g1
40009a30: 80 a2 00 01 cmp %o0, %g1
40009a34: 22 80 00 02 be,a 40009a3c <_RBTree_Insert_unprotected+0x110>
40009a38: c2 07 60 08 ld [ %i5 + 8 ], %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
40009a3c: 80 a0 60 00 cmp %g1, 0
40009a40: 02 80 00 09 be 40009a64 <_RBTree_Insert_unprotected+0x138>
40009a44: 84 10 20 00 clr %g2
40009a48: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40009a4c: 80 a0 a0 01 cmp %g2, 1
40009a50: 32 80 00 05 bne,a 40009a64 <_RBTree_Insert_unprotected+0x138>
40009a54: 84 10 20 00 clr %g2
40009a58: 10 80 00 03 b 40009a64 <_RBTree_Insert_unprotected+0x138>
40009a5c: 84 10 20 01 mov 1, %g2
40009a60: 84 10 20 00 clr %g2 <== NOT EXECUTED
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
40009a64: 80 a0 a0 00 cmp %g2, 0
40009a68: 22 80 00 08 be,a 40009a88 <_RBTree_Insert_unprotected+0x15c>
40009a6c: c2 07 60 04 ld [ %i5 + 4 ], %g1
the_node->parent->color = RBT_BLACK;
40009a70: c0 22 20 0c clr [ %o0 + 0xc ]
u->color = RBT_BLACK;
40009a74: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
40009a78: b2 10 00 1d mov %i5, %i1
40009a7c: 82 10 20 01 mov 1, %g1
40009a80: 10 80 00 18 b 40009ae0 <_RBTree_Insert_unprotected+0x1b4>
40009a84: c2 27 60 0c st %g1, [ %i5 + 0xc ]
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
40009a88: 82 1a 00 01 xor %o0, %g1, %g1
40009a8c: 80 a0 00 01 cmp %g0, %g1
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
40009a90: c2 02 20 04 ld [ %o0 + 4 ], %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
40009a94: b8 40 20 00 addx %g0, 0, %i4
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
40009a98: 82 1e 40 01 xor %i1, %g1, %g1
40009a9c: 80 a0 00 01 cmp %g0, %g1
40009aa0: 82 40 20 00 addx %g0, 0, %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
40009aa4: 80 a0 40 1c cmp %g1, %i4
40009aa8: 22 80 00 08 be,a 40009ac8 <_RBTree_Insert_unprotected+0x19c>
40009aac: c2 06 40 00 ld [ %i1 ], %g1
_RBTree_Rotate(the_node->parent, pdir);
40009ab0: 7f ff ff 80 call 400098b0 <_RBTree_Rotate>
40009ab4: 92 10 00 1c mov %i4, %o1
the_node = the_node->child[pdir];
40009ab8: 83 2f 20 02 sll %i4, 2, %g1
40009abc: b2 06 40 01 add %i1, %g1, %i1
40009ac0: f2 06 60 04 ld [ %i1 + 4 ], %i1
}
the_node->parent->color = RBT_BLACK;
40009ac4: c2 06 40 00 ld [ %i1 ], %g1
g->color = RBT_RED;
40009ac8: 92 10 20 01 mov 1, %o1
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
40009acc: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
40009ad0: d2 27 60 0c st %o1, [ %i5 + 0xc ]
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
40009ad4: 90 10 00 1d mov %i5, %o0
40009ad8: 7f ff ff 76 call 400098b0 <_RBTree_Rotate>
40009adc: 92 22 40 1c sub %o1, %i4, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
40009ae0: d0 06 40 00 ld [ %i1 ], %o0
40009ae4: fa 02 00 00 ld [ %o0 ], %i5
40009ae8: 80 a7 60 00 cmp %i5, 0
40009aec: 22 80 00 06 be,a 40009b04 <_RBTree_Insert_unprotected+0x1d8>
40009af0: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
40009af4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40009af8: 82 18 60 01 xor %g1, 1, %g1
40009afc: 80 a0 00 01 cmp %g0, %g1
40009b00: 82 60 3f ff subx %g0, -1, %g1
RBTree_Node *u,*g;
/* note: the insert root case is handled already */
/* if the parent is black, nothing needs to be done
* otherwise may need to loop a few times */
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
40009b04: 80 a0 60 00 cmp %g1, 0
40009b08: 12 bf ff c3 bne 40009a14 <_RBTree_Insert_unprotected+0xe8>
40009b0c: 80 a7 60 00 cmp %i5, 0
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
40009b10: 12 80 00 06 bne 40009b28 <_RBTree_Insert_unprotected+0x1fc>
40009b14: 01 00 00 00 nop
40009b18: c0 26 60 0c clr [ %i1 + 0xc ]
40009b1c: 81 c7 e0 08 ret
40009b20: 81 e8 00 00 restore
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
if(!the_node) return (RBTree_Node*)-1;
40009b24: b0 10 3f ff mov -1, %i0
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
40009b28: 81 c7 e0 08 ret
40009b2c: 81 e8 00 00 restore
40009b60 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
40009b60: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
40009b64: b8 10 20 00 clr %i4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
40009b68: 80 a0 00 19 cmp %g0, %i1
40009b6c: 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];
40009b70: 82 00 60 02 add %g1, 2, %g1
40009b74: 83 28 60 02 sll %g1, 2, %g1
while ( !stop && current != NULL ) {
40009b78: 10 80 00 0a b 40009ba0 <_RBTree_Iterate_unprotected+0x40>
40009b7c: fa 06 00 01 ld [ %i0 + %g1 ], %i5
stop = (*visitor)( current, dir, visitor_arg );
40009b80: 92 10 00 19 mov %i1, %o1
40009b84: 9f c6 80 00 call %i2
40009b88: 94 10 00 1b mov %i3, %o2
current = _RBTree_Next_unprotected( current, dir );
40009b8c: 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 );
40009b90: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
40009b94: 40 00 00 0b call 40009bc0 <_RBTree_Next_unprotected>
40009b98: 90 10 00 1d mov %i5, %o0
40009b9c: ba 10 00 08 mov %o0, %i5
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
40009ba0: 80 a7 60 00 cmp %i5, 0
40009ba4: 02 80 00 05 be 40009bb8 <_RBTree_Iterate_unprotected+0x58>
40009ba8: b8 1f 20 01 xor %i4, 1, %i4
40009bac: 80 8f 20 ff btst 0xff, %i4
40009bb0: 12 bf ff f4 bne 40009b80 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
40009bb4: 90 10 00 1d mov %i5, %o0
40009bb8: 81 c7 e0 08 ret
40009bbc: 81 e8 00 00 restore
400094c8 <_RBTree_Rotate>:
RBTree_Node *the_node,
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
400094c8: 80 a2 20 00 cmp %o0, 0
400094cc: 02 80 00 1c be 4000953c <_RBTree_Rotate+0x74> <== NEVER TAKEN
400094d0: 80 a0 00 09 cmp %g0, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
400094d4: 86 60 3f ff subx %g0, -1, %g3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
400094d8: 87 28 e0 02 sll %g3, 2, %g3
400094dc: 86 02 00 03 add %o0, %g3, %g3
400094e0: c2 00 e0 04 ld [ %g3 + 4 ], %g1
400094e4: 80 a0 60 00 cmp %g1, 0
400094e8: 02 80 00 15 be 4000953c <_RBTree_Rotate+0x74> <== NEVER TAKEN
400094ec: 93 2a 60 02 sll %o1, 2, %o1
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
400094f0: 84 00 40 09 add %g1, %o1, %g2
400094f4: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400094f8: c8 20 e0 04 st %g4, [ %g3 + 4 ]
if (c->child[dir])
400094fc: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40009500: 80 a0 a0 00 cmp %g2, 0
40009504: 32 80 00 02 bne,a 4000950c <_RBTree_Rotate+0x44>
40009508: d0 20 80 00 st %o0, [ %g2 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000950c: c4 02 00 00 ld [ %o0 ], %g2
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
40009510: 92 00 40 09 add %g1, %o1, %o1
40009514: d0 22 60 04 st %o0, [ %o1 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009518: c6 00 a0 04 ld [ %g2 + 4 ], %g3
c->parent = the_node->parent;
4000951c: 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;
40009520: 86 1a 00 03 xor %o0, %g3, %g3
c->parent = the_node->parent;
the_node->parent = c;
40009524: c2 22 00 00 st %g1, [ %o0 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009528: 80 a0 00 03 cmp %g0, %g3
4000952c: 86 40 20 00 addx %g0, 0, %g3
40009530: 87 28 e0 02 sll %g3, 2, %g3
40009534: 86 00 80 03 add %g2, %g3, %g3
40009538: c2 20 e0 04 st %g1, [ %g3 + 4 ]
4000953c: 81 c3 e0 08 retl
40009478 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
40009478: 80 a2 20 00 cmp %o0, 0
4000947c: 02 80 00 10 be 400094bc <_RBTree_Sibling+0x44> <== NEVER TAKEN
40009480: 82 10 20 00 clr %g1
if(!(the_node->parent)) return NULL;
40009484: c4 02 00 00 ld [ %o0 ], %g2
40009488: 80 a0 a0 00 cmp %g2, 0
4000948c: 22 80 00 0d be,a 400094c0 <_RBTree_Sibling+0x48> <== NEVER TAKEN
40009490: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
if(!(the_node->parent->parent)) return NULL;
40009494: c2 00 80 00 ld [ %g2 ], %g1
40009498: 80 a0 60 00 cmp %g1, 0
4000949c: 02 80 00 08 be 400094bc <_RBTree_Sibling+0x44>
400094a0: 82 10 20 00 clr %g1
if(the_node == the_node->parent->child[RBT_LEFT])
400094a4: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400094a8: 80 a2 00 01 cmp %o0, %g1
400094ac: 22 80 00 04 be,a 400094bc <_RBTree_Sibling+0x44>
400094b0: c2 00 a0 08 ld [ %g2 + 8 ], %g1
return the_node->parent->child[RBT_RIGHT];
400094b4: 81 c3 e0 08 retl
400094b8: 90 10 00 01 mov %g1, %o0
else
return the_node->parent->child[RBT_LEFT];
}
400094bc: 90 10 00 01 mov %g1, %o0
400094c0: 81 c3 e0 08 retl
400080cc <_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 )
{
400080cc: 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 ];
400080d0: fa 06 21 4c ld [ %i0 + 0x14c ], %i5
if ( !api )
400080d4: 80 a7 60 00 cmp %i5, 0
400080d8: 02 80 00 1c be 40008148 <_RTEMS_signal_Post_switch_hook+0x7c><== NEVER TAKEN
400080dc: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
400080e0: 7f ff eb d3 call 4000302c <sparc_disable_interrupts>
400080e4: 01 00 00 00 nop
signal_set = asr->signals_posted;
400080e8: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
400080ec: c0 27 60 14 clr [ %i5 + 0x14 ]
_ISR_Enable( level );
400080f0: 7f ff eb d3 call 4000303c <sparc_enable_interrupts>
400080f4: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
400080f8: 80 a7 20 00 cmp %i4, 0
400080fc: 02 80 00 13 be 40008148 <_RTEMS_signal_Post_switch_hook+0x7c>
40008100: 94 07 bf fc add %fp, -4, %o2
return;
asr->nest_level += 1;
40008104: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008108: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
4000810c: 82 00 60 01 inc %g1
40008110: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008114: 37 00 00 3f sethi %hi(0xfc00), %i3
40008118: 40 00 01 03 call 40008524 <rtems_task_mode>
4000811c: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <PROM_START+0xffff>
(*asr->handler)( signal_set );
40008120: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40008124: 9f c0 40 00 call %g1
40008128: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
4000812c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008130: 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;
40008134: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008138: 92 16 e3 ff or %i3, 0x3ff, %o1
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
(*asr->handler)( signal_set );
asr->nest_level -= 1;
4000813c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008140: 40 00 00 f9 call 40008524 <rtems_task_mode>
40008144: 94 07 bf fc add %fp, -4, %o2
40008148: 81 c7 e0 08 ret
4000814c: 81 e8 00 00 restore
40032610 <_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
)
{
40032610: 9d e3 bf 98 save %sp, -104, %sp
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40032614: 13 10 01 8c sethi %hi(0x40063000), %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
40032618: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
4003261c: 90 07 bf f8 add %fp, -8, %o0
40032620: 7f ff 54 a7 call 400078bc <_TOD_Get_with_nanoseconds>
40032624: 92 12 61 10 or %o1, 0x110, %o1
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
40032628: c4 1f bf f8 ldd [ %fp + -8 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4003262c: 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) {
40032630: 09 10 01 8d sethi %hi(0x40063400), %g4
40032634: ba a0 c0 1d subcc %g3, %i5, %i5
40032638: 88 11 22 d0 or %g4, 0x2d0, %g4
4003263c: b8 60 80 1c subx %g2, %i4, %i4
40032640: f8 3e 40 00 std %i4, [ %i1 ]
40032644: fa 01 20 10 ld [ %g4 + 0x10 ], %i5
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
40032648: d8 1e e0 80 ldd [ %i3 + 0x80 ], %o4
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
4003264c: 80 a6 c0 1d cmp %i3, %i5
40032650: 12 80 00 15 bne 400326a4 <_Rate_monotonic_Get_status+0x94>
40032654: 82 10 20 01 mov 1, %g1
40032658: f8 19 20 20 ldd [ %g4 + 0x20 ], %i4
4003265c: 86 a0 c0 1d subcc %g3, %i5, %g3
40032660: 84 60 80 1c subx %g2, %i4, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40032664: ba 83 40 03 addcc %o5, %g3, %i5
40032668: b8 43 00 02 addx %o4, %g2, %i4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4003266c: c4 1e 20 48 ldd [ %i0 + 0x48 ], %g2
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
40032670: 80 a0 80 1c cmp %g2, %i4
40032674: 34 80 00 0c bg,a 400326a4 <_Rate_monotonic_Get_status+0x94><== NEVER TAKEN
40032678: 82 10 20 00 clr %g1 <== NOT EXECUTED
4003267c: 32 80 00 06 bne,a 40032694 <_Rate_monotonic_Get_status+0x84>
40032680: 86 a7 40 03 subcc %i5, %g3, %g3
40032684: 80 a0 c0 1d cmp %g3, %i5
40032688: 18 80 00 06 bgu 400326a0 <_Rate_monotonic_Get_status+0x90>
4003268c: 86 a7 40 03 subcc %i5, %g3, %g3
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
40032690: 82 10 20 01 mov 1, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40032694: 84 67 00 02 subx %i4, %g2, %g2
40032698: 10 80 00 03 b 400326a4 <_Rate_monotonic_Get_status+0x94>
4003269c: c4 3e 80 00 std %g2, [ %i2 ]
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
return false;
400326a0: 82 10 20 00 clr %g1
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
400326a4: b0 08 60 01 and %g1, 1, %i0
400326a8: 81 c7 e0 08 ret
400326ac: 81 e8 00 00 restore
40032a18 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
40032a18: 9d e3 bf 98 save %sp, -104, %sp
40032a1c: 11 10 01 8f sethi %hi(0x40063c00), %o0
40032a20: 92 10 00 18 mov %i0, %o1
40032a24: 90 12 20 98 or %o0, 0x98, %o0
40032a28: 7f ff 56 4c call 40008358 <_Objects_Get>
40032a2c: 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 ) {
40032a30: c2 07 bf fc ld [ %fp + -4 ], %g1
40032a34: 80 a0 60 00 cmp %g1, 0
40032a38: 12 80 00 24 bne 40032ac8 <_Rate_monotonic_Timeout+0xb0> <== NEVER TAKEN
40032a3c: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
40032a40: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40032a44: 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);
40032a48: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40032a4c: 80 88 80 01 btst %g2, %g1
40032a50: 22 80 00 0b be,a 40032a7c <_Rate_monotonic_Timeout+0x64>
40032a54: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40032a58: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
40032a5c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40032a60: 80 a0 80 01 cmp %g2, %g1
40032a64: 32 80 00 06 bne,a 40032a7c <_Rate_monotonic_Timeout+0x64>
40032a68: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40032a6c: 13 04 01 ff sethi %hi(0x1007fc00), %o1
40032a70: 7f ff 58 e5 call 40008e04 <_Thread_Clear_state>
40032a74: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
40032a78: 30 80 00 06 b,a 40032a90 <_Rate_monotonic_Timeout+0x78>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
40032a7c: 80 a0 60 01 cmp %g1, 1
40032a80: 12 80 00 0d bne 40032ab4 <_Rate_monotonic_Timeout+0x9c>
40032a84: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
40032a88: 82 10 20 03 mov 3, %g1
40032a8c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
40032a90: 7f ff ff 51 call 400327d4 <_Rate_monotonic_Initiate_statistics>
40032a94: 90 10 00 1d mov %i5, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40032a98: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40032a9c: 11 10 01 8c sethi %hi(0x40063000), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40032aa0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40032aa4: 90 12 22 58 or %o0, 0x258, %o0
40032aa8: 7f ff 5c bc call 40009d98 <_Watchdog_Insert>
40032aac: 92 07 60 10 add %i5, 0x10, %o1
40032ab0: 30 80 00 02 b,a 40032ab8 <_Rate_monotonic_Timeout+0xa0>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
40032ab4: 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;
40032ab8: 03 10 01 8c sethi %hi(0x40063000), %g1
40032abc: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 400631c0 <_Thread_Dispatch_disable_level>
--level;
40032ac0: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40032ac4: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ]
40032ac8: 81 c7 e0 08 ret
40032acc: 81 e8 00 00 restore
400326b0 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
400326b0: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
400326b4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
400326b8: 82 00 60 01 inc %g1
400326bc: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
400326c0: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
400326c4: 80 a0 60 04 cmp %g1, 4
400326c8: 12 80 00 05 bne 400326dc <_Rate_monotonic_Update_statistics+0x2c>
400326cc: 90 10 00 18 mov %i0, %o0
stats->missed_count++;
400326d0: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
400326d4: 82 00 60 01 inc %g1
400326d8: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
/*
* Grab status for time statistics.
*/
valid_status =
400326dc: 92 07 bf f8 add %fp, -8, %o1
400326e0: 7f ff ff cc call 40032610 <_Rate_monotonic_Get_status>
400326e4: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
400326e8: 80 8a 20 ff btst 0xff, %o0
400326ec: 02 80 00 38 be 400327cc <_Rate_monotonic_Update_statistics+0x11c>
400326f0: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
400326f4: 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 ) )
400326f8: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
400326fc: b6 87 40 03 addcc %i5, %g3, %i3
40032700: b4 47 00 02 addx %i4, %g2, %i2
40032704: 80 a0 40 02 cmp %g1, %g2
40032708: 14 80 00 09 bg 4003272c <_Rate_monotonic_Update_statistics+0x7c>
4003270c: f4 3e 20 70 std %i2, [ %i0 + 0x70 ]
40032710: 80 a0 40 02 cmp %g1, %g2
40032714: 32 80 00 08 bne,a 40032734 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
40032718: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
4003271c: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
40032720: 80 a0 40 03 cmp %g1, %g3
40032724: 28 80 00 04 bleu,a 40032734 <_Rate_monotonic_Update_statistics+0x84>
40032728: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
4003272c: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
40032730: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
40032734: 80 a0 40 02 cmp %g1, %g2
40032738: 26 80 00 0a bl,a 40032760 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
4003273c: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
40032740: 80 a0 40 02 cmp %g1, %g2
40032744: 32 80 00 08 bne,a 40032764 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
40032748: c4 1f bf f8 ldd [ %fp + -8 ], %g2 <== NOT EXECUTED
4003274c: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
40032750: 80 a0 40 03 cmp %g1, %g3
40032754: 3a 80 00 04 bcc,a 40032764 <_Rate_monotonic_Update_statistics+0xb4>
40032758: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
4003275c: c4 3e 20 68 std %g2, [ %i0 + 0x68 ]
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
40032760: c4 1f bf f8 ldd [ %fp + -8 ], %g2
40032764: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
40032768: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
4003276c: b6 87 40 03 addcc %i5, %g3, %i3
40032770: b4 47 00 02 addx %i4, %g2, %i2
40032774: 80 a0 40 02 cmp %g1, %g2
40032778: 14 80 00 09 bg 4003279c <_Rate_monotonic_Update_statistics+0xec>
4003277c: f4 3e 20 88 std %i2, [ %i0 + 0x88 ]
40032780: 80 a0 40 02 cmp %g1, %g2
40032784: 32 80 00 08 bne,a 400327a4 <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
40032788: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
4003278c: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
40032790: 80 a0 40 03 cmp %g1, %g3
40032794: 28 80 00 04 bleu,a 400327a4 <_Rate_monotonic_Update_statistics+0xf4>
40032798: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
4003279c: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
400327a0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
400327a4: 80 a0 40 02 cmp %g1, %g2
400327a8: 26 80 00 09 bl,a 400327cc <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
400327ac: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
400327b0: 80 a0 40 02 cmp %g1, %g2
400327b4: 12 80 00 06 bne 400327cc <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
400327b8: 01 00 00 00 nop
400327bc: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
400327c0: 80 a0 40 03 cmp %g1, %g3
400327c4: 2a 80 00 02 bcs,a 400327cc <_Rate_monotonic_Update_statistics+0x11c>
400327c8: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
400327cc: 81 c7 e0 08 ret
400327d0: 81 e8 00 00 restore
40009828 <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
40009828: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
4000982c: 40 00 06 8d call 4000b260 <_Workspace_Allocate>
40009830: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
40009834: 80 a2 20 00 cmp %o0, 0
40009838: 02 80 00 06 be 40009850 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
4000983c: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
40009840: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
40009844: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
40009848: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
4000984c: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
40009850: 81 c7 e0 08 ret
40009854: 91 e8 00 08 restore %g0, %o0, %o0
4000ab68 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
4000ab68: 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;
4000ab6c: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000ab70: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000ab74: 80 a0 40 09 cmp %g1, %o1
4000ab78: 32 80 00 02 bne,a 4000ab80 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
4000ab7c: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
4000ab80: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000ab84: 80 a0 40 09 cmp %g1, %o1
4000ab88: 02 80 00 04 be 4000ab98 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
4000ab8c: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
4000ab90: 40 00 01 83 call 4000b19c <_Thread_Change_priority>
4000ab94: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
4000ab98: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
4000ab9c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000aba0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000aba4: 80 a0 a0 00 cmp %g2, 0
4000aba8: 02 80 00 09 be 4000abcc <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
4000abac: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
4000abb0: d0 00 40 00 ld [ %g1 ], %o0
4000abb4: 7f ff ff d7 call 4000ab10 <_Scheduler_CBS_Get_server_id>
4000abb8: 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 );
4000abbc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000abc0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000abc4: 9f c0 40 00 call %g1
4000abc8: d0 07 bf fc ld [ %fp + -4 ], %o0
4000abcc: 81 c7 e0 08 ret
4000abd0: 81 e8 00 00 restore
4000a770 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
4000a770: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
4000a774: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000a778: 80 a0 60 00 cmp %g1, 0
4000a77c: 04 80 00 1d ble 4000a7f0 <_Scheduler_CBS_Create_server+0x80>
4000a780: 01 00 00 00 nop
4000a784: c2 06 00 00 ld [ %i0 ], %g1
4000a788: 80 a0 60 00 cmp %g1, 0
4000a78c: 04 80 00 19 ble 4000a7f0 <_Scheduler_CBS_Create_server+0x80>
4000a790: 03 10 00 83 sethi %hi(0x40020c00), %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++ ) {
4000a794: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 40020d70 <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list[i] )
4000a798: 03 10 00 87 sethi %hi(0x40021c00), %g1
4000a79c: c6 00 62 88 ld [ %g1 + 0x288 ], %g3 ! 40021e88 <_Scheduler_CBS_Server_list>
4000a7a0: 10 80 00 07 b 4000a7bc <_Scheduler_CBS_Create_server+0x4c>
4000a7a4: 82 10 20 00 clr %g1
4000a7a8: c8 00 c0 1c ld [ %g3 + %i4 ], %g4
4000a7ac: 80 a1 20 00 cmp %g4, 0
4000a7b0: 02 80 00 14 be 4000a800 <_Scheduler_CBS_Create_server+0x90>
4000a7b4: 3b 10 00 87 sethi %hi(0x40021c00), %i5
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000a7b8: 82 00 60 01 inc %g1
4000a7bc: 80 a0 40 02 cmp %g1, %g2
4000a7c0: 12 bf ff fa bne 4000a7a8 <_Scheduler_CBS_Create_server+0x38>
4000a7c4: b9 28 60 02 sll %g1, 2, %i4
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
4000a7c8: 81 c7 e0 08 ret
4000a7cc: 91 e8 3f e6 restore %g0, -26, %o0
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
4000a7d0: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000a7d4: c4 06 20 04 ld [ %i0 + 4 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
4000a7d8: f2 20 60 0c st %i1, [ %g1 + 0xc ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
4000a7dc: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
4000a7e0: 84 10 3f ff mov -1, %g2
4000a7e4: c4 20 40 00 st %g2, [ %g1 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
4000a7e8: 81 c7 e0 08 ret
4000a7ec: 91 e8 20 00 restore %g0, 0, %o0
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000a7f0: 81 c7 e0 08 ret
4000a7f4: 91 e8 3f ee restore %g0, -18, %o0
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
4000a7f8: 81 c7 e0 08 ret <== NOT EXECUTED
4000a7fc: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
4000a800: f6 07 62 88 ld [ %i5 + 0x288 ], %i3
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
4000a804: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
4000a808: 40 00 07 7f call 4000c604 <_Workspace_Allocate>
4000a80c: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
4000a810: 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 *)
4000a814: d0 26 c0 1c st %o0, [ %i3 + %i4 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
4000a818: c4 07 62 88 ld [ %i5 + 0x288 ], %g2
4000a81c: 83 28 60 02 sll %g1, 2, %g1
4000a820: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
4000a824: 80 a0 60 00 cmp %g1, 0
4000a828: 32 bf ff ea bne,a 4000a7d0 <_Scheduler_CBS_Create_server+0x60><== ALWAYS TAKEN
4000a82c: c4 06 00 00 ld [ %i0 ], %g2
4000a830: 30 bf ff f2 b,a 4000a7f8 <_Scheduler_CBS_Create_server+0x88><== NOT EXECUTED
4000a8a8 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
4000a8a8: 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);
4000a8ac: 90 10 00 19 mov %i1, %o0
4000a8b0: 40 00 03 61 call 4000b634 <_Thread_Get>
4000a8b4: 92 07 bf fc add %fp, -4, %o1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
4000a8b8: ba 92 20 00 orcc %o0, 0, %i5
4000a8bc: 02 80 00 05 be 4000a8d0 <_Scheduler_CBS_Detach_thread+0x28>
4000a8c0: 03 10 00 83 sethi %hi(0x40020c00), %g1
_Thread_Enable_dispatch();
4000a8c4: 40 00 03 50 call 4000b604 <_Thread_Enable_dispatch>
4000a8c8: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000a8cc: 03 10 00 83 sethi %hi(0x40020c00), %g1
4000a8d0: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 ! 40020d70 <_Scheduler_CBS_Maximum_servers>
4000a8d4: 80 a6 00 01 cmp %i0, %g1
4000a8d8: 1a 80 00 1b bcc 4000a944 <_Scheduler_CBS_Detach_thread+0x9c>
4000a8dc: 80 a7 60 00 cmp %i5, 0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
4000a8e0: 02 80 00 19 be 4000a944 <_Scheduler_CBS_Detach_thread+0x9c>
4000a8e4: 03 10 00 87 sethi %hi(0x40021c00), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
4000a8e8: c2 00 62 88 ld [ %g1 + 0x288 ], %g1 ! 40021e88 <_Scheduler_CBS_Server_list>
4000a8ec: b1 2e 20 02 sll %i0, 2, %i0
4000a8f0: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000a8f4: 80 a0 60 00 cmp %g1, 0
4000a8f8: 02 80 00 11 be 4000a93c <_Scheduler_CBS_Detach_thread+0x94>
4000a8fc: 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 )
4000a900: c4 00 40 00 ld [ %g1 ], %g2
4000a904: 80 a0 80 19 cmp %g2, %i1
4000a908: 12 80 00 0f bne 4000a944 <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
4000a90c: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
4000a910: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
4000a914: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
4000a918: c0 20 60 18 clr [ %g1 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000a91c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
4000a920: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
4000a924: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
4000a928: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000a92c: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
4000a930: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
4000a934: 81 c7 e0 08 ret
4000a938: 91 e8 20 00 restore %g0, 0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
4000a93c: 81 c7 e0 08 ret
4000a940: 91 e8 3f e7 restore %g0, -25, %o0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
4000a944: 81 c7 e0 08 ret
4000a948: 91 e8 3f ee restore %g0, -18, %o0
4000abd4 <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
4000abd4: 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*) );
4000abd8: 3b 10 00 83 sethi %hi(0x40020c00), %i5
4000abdc: d0 07 61 70 ld [ %i5 + 0x170 ], %o0 ! 40020d70 <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
4000abe0: 40 00 06 89 call 4000c604 <_Workspace_Allocate>
4000abe4: 91 2a 20 02 sll %o0, 2, %o0
4000abe8: 05 10 00 87 sethi %hi(0x40021c00), %g2
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
4000abec: 80 a2 20 00 cmp %o0, 0
4000abf0: 02 80 00 0d be 4000ac24 <_Scheduler_CBS_Initialize+0x50> <== NEVER TAKEN
4000abf4: d0 20 a2 88 st %o0, [ %g2 + 0x288 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000abf8: c6 07 61 70 ld [ %i5 + 0x170 ], %g3
4000abfc: 10 80 00 05 b 4000ac10 <_Scheduler_CBS_Initialize+0x3c>
4000ac00: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
4000ac04: 89 28 60 02 sll %g1, 2, %g4
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000ac08: 82 00 60 01 inc %g1
_Scheduler_CBS_Server_list[i] = NULL;
4000ac0c: c0 27 40 04 clr [ %i5 + %g4 ]
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000ac10: 80 a0 40 03 cmp %g1, %g3
4000ac14: 12 bf ff fc bne 4000ac04 <_Scheduler_CBS_Initialize+0x30>
4000ac18: fa 00 a2 88 ld [ %g2 + 0x288 ], %i5
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
4000ac1c: 81 c7 e0 08 ret
4000ac20: 91 e8 20 00 restore %g0, 0, %o0
}
4000ac24: 81 c7 e0 08 ret <== NOT EXECUTED
4000ac28: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
40009858 <_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;
40009858: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
4000985c: 80 a2 60 00 cmp %o1, 0
40009860: 02 80 00 10 be 400098a0 <_Scheduler_CBS_Release_job+0x48>
40009864: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
40009868: 80 a0 60 00 cmp %g1, 0
4000986c: 02 80 00 08 be 4000988c <_Scheduler_CBS_Release_job+0x34>
40009870: 05 10 00 7f sethi %hi(0x4001fc00), %g2
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
40009874: d2 00 a2 e8 ld [ %g2 + 0x2e8 ], %o1 ! 4001fee8 <_Watchdog_Ticks_since_boot>
40009878: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000987c: 92 02 40 02 add %o1, %g2, %o1
40009880: 05 20 00 00 sethi %hi(0x80000000), %g2
40009884: 10 80 00 0a b 400098ac <_Scheduler_CBS_Release_job+0x54>
40009888: 92 2a 40 02 andn %o1, %g2, %o1
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
4000988c: c2 00 a2 e8 ld [ %g2 + 0x2e8 ], %g1
40009890: 92 02 40 01 add %o1, %g1, %o1
40009894: 03 20 00 00 sethi %hi(0x80000000), %g1
40009898: 10 80 00 07 b 400098b4 <_Scheduler_CBS_Release_job+0x5c>
4000989c: 92 2a 40 01 andn %o1, %g1, %o1
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
400098a0: 80 a0 60 00 cmp %g1, 0
400098a4: 02 80 00 04 be 400098b4 <_Scheduler_CBS_Release_job+0x5c> <== NEVER TAKEN
400098a8: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
400098ac: c2 00 60 08 ld [ %g1 + 8 ], %g1
400098b0: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
400098b4: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
400098b8: 94 10 20 01 mov 1, %o2
400098bc: 82 13 c0 00 mov %o7, %g1
400098c0: 40 00 01 26 call 40009d58 <_Thread_Change_priority>
400098c4: 9e 10 40 00 mov %g1, %o7
400098c8 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
400098c8: 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);
400098cc: 40 00 00 4c call 400099fc <_Scheduler_EDF_Enqueue>
400098d0: 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;
400098d4: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
400098d8: 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) {
400098dc: 80 a7 60 00 cmp %i5, 0
400098e0: 02 80 00 18 be 40009940 <_Scheduler_CBS_Unblock+0x78>
400098e4: 03 10 00 7f sethi %hi(0x4001fc00), %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 ) {
400098e8: 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 -
400098ec: d0 00 62 e8 ld [ %g1 + 0x2e8 ], %o0
400098f0: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
400098f4: 40 00 3e fa call 400194dc <.umul>
400098f8: 90 27 00 08 sub %i4, %o0, %o0
400098fc: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
40009900: b6 10 00 08 mov %o0, %i3
40009904: 40 00 3e f6 call 400194dc <.umul>
40009908: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000990c: 80 a6 c0 08 cmp %i3, %o0
40009910: 24 80 00 0d ble,a 40009944 <_Scheduler_CBS_Unblock+0x7c>
40009914: 3b 10 00 80 sethi %hi(0x40020000), %i5
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
40009918: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000991c: 80 a7 00 09 cmp %i4, %o1
40009920: 32 80 00 02 bne,a 40009928 <_Scheduler_CBS_Unblock+0x60>
40009924: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
40009928: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000992c: 80 a0 40 09 cmp %g1, %o1
40009930: 02 80 00 04 be 40009940 <_Scheduler_CBS_Unblock+0x78>
40009934: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
40009938: 40 00 01 08 call 40009d58 <_Thread_Change_priority>
4000993c: 94 10 20 01 mov 1, %o2
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
40009940: 3b 10 00 80 sethi %hi(0x40020000), %i5
40009944: ba 17 63 10 or %i5, 0x310, %i5 ! 40020310 <_Per_CPU_Information>
40009948: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4000994c: 03 10 00 7c sethi %hi(0x4001f000), %g1
40009950: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40009954: c2 00 62 54 ld [ %g1 + 0x254 ], %g1
40009958: 9f c0 40 00 call %g1
4000995c: d2 00 a0 14 ld [ %g2 + 0x14 ], %o1
40009960: 80 a2 20 00 cmp %o0, 0
40009964: 04 80 00 0f ble 400099a0 <_Scheduler_CBS_Unblock+0xd8>
40009968: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
4000996c: 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;
40009970: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
40009974: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
40009978: 80 a0 60 00 cmp %g1, 0
4000997c: 12 80 00 06 bne 40009994 <_Scheduler_CBS_Unblock+0xcc>
40009980: 84 10 20 01 mov 1, %g2
40009984: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40009988: 80 a0 60 00 cmp %g1, 0
4000998c: 12 80 00 05 bne 400099a0 <_Scheduler_CBS_Unblock+0xd8> <== ALWAYS TAKEN
40009990: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
40009994: 03 10 00 80 sethi %hi(0x40020000), %g1
40009998: 82 10 63 10 or %g1, 0x310, %g1 ! 40020310 <_Per_CPU_Information>
4000999c: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
400099a0: 81 c7 e0 08 ret
400099a4: 81 e8 00 00 restore
40009828 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
40009828: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
4000982c: 40 00 06 62 call 4000b1b4 <_Workspace_Allocate>
40009830: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
40009834: 80 a2 20 00 cmp %o0, 0
40009838: 02 80 00 05 be 4000984c <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
4000983c: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
40009840: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
40009844: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
40009848: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
4000984c: 81 c7 e0 08 ret
40009850: 91 e8 00 08 restore %g0, %o0, %o0
400099f0 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
400099f0: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
400099f4: 7f ff ff ad call 400098a8 <_Scheduler_EDF_Enqueue>
400099f8: 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(
400099fc: 3b 10 00 80 sethi %hi(0x40020000), %i5
40009a00: ba 17 62 60 or %i5, 0x260, %i5 ! 40020260 <_Per_CPU_Information>
40009a04: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
40009a08: 03 10 00 7c sethi %hi(0x4001f000), %g1
40009a0c: d0 00 a0 14 ld [ %g2 + 0x14 ], %o0
40009a10: c2 00 61 a4 ld [ %g1 + 0x1a4 ], %g1
40009a14: 9f c0 40 00 call %g1
40009a18: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
40009a1c: 80 a2 20 00 cmp %o0, 0
40009a20: 16 80 00 0f bge 40009a5c <_Scheduler_EDF_Unblock+0x6c>
40009a24: 01 00 00 00 nop
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
40009a28: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
40009a2c: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
40009a30: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
40009a34: 80 a0 60 00 cmp %g1, 0
40009a38: 12 80 00 06 bne 40009a50 <_Scheduler_EDF_Unblock+0x60>
40009a3c: 84 10 20 01 mov 1, %g2
40009a40: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40009a44: 80 a0 60 00 cmp %g1, 0
40009a48: 12 80 00 05 bne 40009a5c <_Scheduler_EDF_Unblock+0x6c> <== ALWAYS TAKEN
40009a4c: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
40009a50: 03 10 00 80 sethi %hi(0x40020000), %g1
40009a54: 82 10 62 60 or %g1, 0x260, %g1 ! 40020260 <_Per_CPU_Information>
40009a58: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
40009a5c: 81 c7 e0 08 ret
40009a60: 81 e8 00 00 restore
400090fc <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
400090fc: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing;
executing = _Thread_Executing;
40009100: 03 10 00 79 sethi %hi(0x4001e400), %g1
40009104: fa 00 63 20 ld [ %g1 + 0x320 ], %i5 ! 4001e720 <_Per_CPU_Information+0x10>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
40009108: c2 0f 60 70 ldub [ %i5 + 0x70 ], %g1
4000910c: 80 a0 60 00 cmp %g1, 0
40009110: 02 80 00 25 be 400091a4 <_Scheduler_priority_Tick+0xa8>
40009114: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
40009118: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000911c: 80 a0 60 00 cmp %g1, 0
40009120: 12 80 00 21 bne 400091a4 <_Scheduler_priority_Tick+0xa8>
40009124: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
40009128: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
4000912c: 80 a0 60 01 cmp %g1, 1
40009130: 0a 80 00 14 bcs 40009180 <_Scheduler_priority_Tick+0x84>
40009134: 80 a0 60 02 cmp %g1, 2
40009138: 28 80 00 07 bleu,a 40009154 <_Scheduler_priority_Tick+0x58>
4000913c: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
40009140: 80 a0 60 03 cmp %g1, 3
40009144: 12 80 00 18 bne 400091a4 <_Scheduler_priority_Tick+0xa8> <== NEVER TAKEN
40009148: 01 00 00 00 nop
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
4000914c: 10 80 00 0f b 40009188 <_Scheduler_priority_Tick+0x8c>
40009150: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
40009154: 82 00 7f ff add %g1, -1, %g1
40009158: 80 a0 60 00 cmp %g1, 0
4000915c: 14 80 00 09 bg 40009180 <_Scheduler_priority_Tick+0x84>
40009160: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
40009164: 03 10 00 75 sethi %hi(0x4001d400), %g1
40009168: c2 00 62 b0 ld [ %g1 + 0x2b0 ], %g1 ! 4001d6b0 <_Scheduler+0xc>
4000916c: 9f c0 40 00 call %g1
40009170: 01 00 00 00 nop
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield();
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
40009174: 03 10 00 78 sethi %hi(0x4001e000), %g1
40009178: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 4001e160 <_Thread_Ticks_per_timeslice>
4000917c: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
40009180: 81 c7 e0 08 ret
40009184: 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 )
40009188: 82 00 7f ff add %g1, -1, %g1
4000918c: 80 a0 60 00 cmp %g1, 0
40009190: 12 bf ff fc bne 40009180 <_Scheduler_priority_Tick+0x84>
40009194: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*executing->budget_callout)( executing );
40009198: c2 07 60 7c ld [ %i5 + 0x7c ], %g1
4000919c: 9f c0 40 00 call %g1
400091a0: 90 10 00 1d mov %i5, %o0
400091a4: 81 c7 e0 08 ret
400091a8: 81 e8 00 00 restore
40007d3c <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
40007d3c: 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 /
40007d40: 03 10 00 76 sethi %hi(0x4001d800), %g1
40007d44: d2 00 61 dc ld [ %g1 + 0x1dc ], %o1 ! 4001d9dc <Configuration+0xc>
40007d48: 11 00 03 d0 sethi %hi(0xf4000), %o0
40007d4c: 40 00 48 2b call 40019df8 <.udiv>
40007d50: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
40007d54: 80 a6 20 00 cmp %i0, 0
40007d58: 02 80 00 28 be 40007df8 <_TOD_Validate+0xbc> <== NEVER TAKEN
40007d5c: 84 10 20 00 clr %g2
40007d60: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40007d64: 80 a0 40 08 cmp %g1, %o0
40007d68: 3a 80 00 25 bcc,a 40007dfc <_TOD_Validate+0xc0>
40007d6c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
40007d70: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40007d74: 80 a0 60 3b cmp %g1, 0x3b
40007d78: 38 80 00 21 bgu,a 40007dfc <_TOD_Validate+0xc0>
40007d7c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
40007d80: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40007d84: 80 a0 60 3b cmp %g1, 0x3b
40007d88: 38 80 00 1d bgu,a 40007dfc <_TOD_Validate+0xc0>
40007d8c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
40007d90: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40007d94: 80 a0 60 17 cmp %g1, 0x17
40007d98: 38 80 00 19 bgu,a 40007dfc <_TOD_Validate+0xc0>
40007d9c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
40007da0: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
40007da4: 80 a0 60 00 cmp %g1, 0
40007da8: 02 80 00 14 be 40007df8 <_TOD_Validate+0xbc> <== NEVER TAKEN
40007dac: 80 a0 60 0c cmp %g1, 0xc
(the_tod->month == 0) ||
40007db0: 38 80 00 13 bgu,a 40007dfc <_TOD_Validate+0xc0>
40007db4: b0 08 a0 01 and %g2, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
40007db8: c8 06 00 00 ld [ %i0 ], %g4
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
40007dbc: 80 a1 27 c3 cmp %g4, 0x7c3
40007dc0: 28 80 00 0f bleu,a 40007dfc <_TOD_Validate+0xc0>
40007dc4: b0 08 a0 01 and %g2, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
40007dc8: c6 06 20 08 ld [ %i0 + 8 ], %g3
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
40007dcc: 80 a0 e0 00 cmp %g3, 0
40007dd0: 02 80 00 0a be 40007df8 <_TOD_Validate+0xbc> <== NEVER TAKEN
40007dd4: 80 89 20 03 btst 3, %g4
40007dd8: 05 10 00 7a sethi %hi(0x4001e800), %g2
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
40007ddc: 12 80 00 03 bne 40007de8 <_TOD_Validate+0xac>
40007de0: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 4001ead0 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
40007de4: 82 00 60 0d add %g1, 0xd, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
40007de8: 83 28 60 02 sll %g1, 2, %g1
40007dec: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
40007df0: 80 a0 40 03 cmp %g1, %g3
40007df4: 84 60 3f ff subx %g0, -1, %g2
return false;
return true;
}
40007df8: b0 08 a0 01 and %g2, 1, %i0
40007dfc: 81 c7 e0 08 ret
40007e00: 81 e8 00 00 restore
400093b8 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
400093b8: 9d e3 bf a0 save %sp, -96, %sp
400093bc: ba 10 00 18 mov %i0, %i5
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
400093c0: f0 06 20 10 ld [ %i0 + 0x10 ], %i0
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
400093c4: 40 00 03 51 call 4000a108 <_Thread_Set_transient>
400093c8: 90 10 00 1d mov %i5, %o0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
400093cc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400093d0: 80 a0 40 19 cmp %g1, %i1
400093d4: 02 80 00 04 be 400093e4 <_Thread_Change_priority+0x2c>
400093d8: 90 10 00 1d mov %i5, %o0
_Thread_Set_priority( the_thread, new_priority );
400093dc: 40 00 03 32 call 4000a0a4 <_Thread_Set_priority>
400093e0: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
400093e4: 7f ff e3 31 call 400020a8 <sparc_disable_interrupts>
400093e8: 01 00 00 00 nop
400093ec: b6 10 00 08 mov %o0, %i3
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
400093f0: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
400093f4: 80 a7 20 04 cmp %i4, 4
400093f8: 02 80 00 10 be 40009438 <_Thread_Change_priority+0x80>
400093fc: 82 0e 20 04 and %i0, 4, %g1
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
40009400: 80 a0 60 00 cmp %g1, 0
40009404: 12 80 00 03 bne 40009410 <_Thread_Change_priority+0x58> <== NEVER TAKEN
40009408: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
4000940c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
40009410: 7f ff e3 2a call 400020b8 <sparc_enable_interrupts>
40009414: 90 10 00 1b mov %i3, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
40009418: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000941c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
40009420: 80 8f 00 01 btst %i4, %g1
40009424: 02 80 00 27 be 400094c0 <_Thread_Change_priority+0x108>
40009428: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
4000942c: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
40009430: 40 00 02 f0 call 40009ff0 <_Thread_queue_Requeue>
40009434: 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 ) ) {
40009438: 80 a0 60 00 cmp %g1, 0
4000943c: 12 80 00 0b bne 40009468 <_Thread_Change_priority+0xb0> <== NEVER TAKEN
40009440: 03 10 00 75 sethi %hi(0x4001d400), %g1
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
40009444: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( prepend_it )
40009448: 80 a6 a0 00 cmp %i2, 0
4000944c: 02 80 00 04 be 4000945c <_Thread_Change_priority+0xa4>
40009450: 82 10 62 a4 or %g1, 0x2a4, %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
40009454: 10 80 00 03 b 40009460 <_Thread_Change_priority+0xa8>
40009458: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
4000945c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40009460: 9f c0 40 00 call %g1
40009464: 90 10 00 1d mov %i5, %o0
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
40009468: 7f ff e3 14 call 400020b8 <sparc_enable_interrupts>
4000946c: 90 10 00 1b mov %i3, %o0
40009470: 7f ff e3 0e call 400020a8 <sparc_disable_interrupts>
40009474: 01 00 00 00 nop
40009478: 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();
4000947c: 03 10 00 75 sethi %hi(0x4001d400), %g1
40009480: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001d6ac <_Scheduler+0x8>
40009484: 9f c0 40 00 call %g1
40009488: 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 );
4000948c: 03 10 00 79 sethi %hi(0x4001e400), %g1
40009490: 82 10 63 10 or %g1, 0x310, %g1 ! 4001e710 <_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() &&
40009494: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
40009498: 80 a0 80 03 cmp %g2, %g3
4000949c: 02 80 00 07 be 400094b8 <_Thread_Change_priority+0x100>
400094a0: 01 00 00 00 nop
400094a4: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
400094a8: 80 a0 a0 00 cmp %g2, 0
400094ac: 02 80 00 03 be 400094b8 <_Thread_Change_priority+0x100>
400094b0: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
400094b4: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
_ISR_Enable( level );
400094b8: 7f ff e3 00 call 400020b8 <sparc_enable_interrupts>
400094bc: 81 e8 00 00 restore
400094c0: 81 c7 e0 08 ret
400094c4: 81 e8 00 00 restore
40009688 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
40009688: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000968c: 90 10 00 18 mov %i0, %o0
40009690: 40 00 00 70 call 40009850 <_Thread_Get>
40009694: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40009698: c2 07 bf fc ld [ %fp + -4 ], %g1
4000969c: 80 a0 60 00 cmp %g1, 0
400096a0: 12 80 00 08 bne 400096c0 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
400096a4: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
400096a8: 7f ff ff 88 call 400094c8 <_Thread_Clear_state>
400096ac: 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;
400096b0: 03 10 00 78 sethi %hi(0x4001e000), %g1
400096b4: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 4001e200 <_Thread_Dispatch_disable_level>
--level;
400096b8: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
400096bc: c4 20 62 00 st %g2, [ %g1 + 0x200 ]
400096c0: 81 c7 e0 08 ret
400096c4: 81 e8 00 00 restore
400096c8 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
400096c8: 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;
400096cc: 35 10 00 79 sethi %hi(0x4001e400), %i2
400096d0: 82 16 a3 10 or %i2, 0x310, %g1 ! 4001e710 <_Per_CPU_Information>
_ISR_Disable( level );
400096d4: 7f ff e2 75 call 400020a8 <sparc_disable_interrupts>
400096d8: f6 00 60 10 ld [ %g1 + 0x10 ], %i3
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
400096dc: 21 10 00 78 sethi %hi(0x4001e000), %l0
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
400096e0: 27 10 00 75 sethi %hi(0x4001d400), %l3
* This routine sets thread dispatch level to the
* value passed in.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_set_disable_level(uint32_t value)
{
_Thread_Dispatch_disable_level = value;
400096e4: 33 10 00 78 sethi %hi(0x4001e000), %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;
400096e8: 31 10 00 78 sethi %hi(0x4001e000), %i0
400096ec: a0 14 21 50 or %l0, 0x150, %l0
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
400096f0: 23 10 00 78 sethi %hi(0x4001e000), %l1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
400096f4: 25 10 00 75 sethi %hi(0x4001d400), %l2
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
400096f8: 10 80 00 3b b 400097e4 <_Thread_Dispatch+0x11c>
400096fc: a6 14 e3 d0 or %l3, 0x3d0, %l3
40009700: 84 10 20 01 mov 1, %g2
40009704: c4 26 62 00 st %g2, [ %i1 + 0x200 ]
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
40009708: c0 28 60 0c clrb [ %g1 + 0xc ]
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
4000970c: 80 a5 00 1b cmp %l4, %i3
40009710: 12 80 00 0a bne 40009738 <_Thread_Dispatch+0x70>
40009714: e8 20 60 10 st %l4, [ %g1 + 0x10 ]
40009718: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000971c: c0 20 62 00 clr [ %g1 + 0x200 ] ! 4001e200 <_Thread_Dispatch_disable_level>
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
40009720: 7f ff e2 66 call 400020b8 <sparc_enable_interrupts>
40009724: 39 10 00 78 sethi %hi(0x4001e000), %i4
40009728: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000972c: fa 00 62 70 ld [ %g1 + 0x270 ], %i5 ! 4001e270 <_API_extensions_Post_switch_list>
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
40009730: 10 80 00 37 b 4000980c <_Thread_Dispatch+0x144>
40009734: b8 17 22 74 or %i4, 0x274, %i4
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
40009738: c2 05 20 78 ld [ %l4 + 0x78 ], %g1
4000973c: 80 a0 60 01 cmp %g1, 1
40009740: 12 80 00 03 bne 4000974c <_Thread_Dispatch+0x84>
40009744: c2 06 21 60 ld [ %i0 + 0x160 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
40009748: c2 25 20 74 st %g1, [ %l4 + 0x74 ]
_ISR_Enable( level );
4000974c: 7f ff e2 5b call 400020b8 <sparc_enable_interrupts>
40009750: 01 00 00 00 nop
40009754: 90 07 bf f8 add %fp, -8, %o0
40009758: 7f ff f9 e0 call 40007ed8 <_TOD_Get_with_nanoseconds>
4000975c: 92 10 00 10 mov %l0, %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
40009760: c4 1f bf f8 ldd [ %fp + -8 ], %g2
40009764: 82 16 a3 10 or %i2, 0x310, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40009768: f8 18 60 20 ldd [ %g1 + 0x20 ], %i4
4000976c: 96 a0 c0 1d subcc %g3, %i5, %o3
40009770: 94 60 80 1c subx %g2, %i4, %o2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40009774: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
40009778: 9a 87 40 0b addcc %i5, %o3, %o5
4000977c: 98 47 00 0a addx %i4, %o2, %o4
40009780: d8 3e e0 80 std %o4, [ %i3 + 0x80 ]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
40009784: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
40009788: c2 04 62 6c ld [ %l1 + 0x26c ], %g1
4000978c: 80 a0 60 00 cmp %g1, 0
40009790: 22 80 00 0c be,a 400097c0 <_Thread_Dispatch+0xf8> <== NEVER TAKEN
40009794: fa 04 a3 cc ld [ %l2 + 0x3cc ], %i5 <== NOT EXECUTED
executing->libc_reent = *_Thread_libc_reent;
40009798: c4 00 40 00 ld [ %g1 ], %g2
4000979c: c4 26 e1 48 st %g2, [ %i3 + 0x148 ]
*_Thread_libc_reent = heir->libc_reent;
400097a0: c4 05 21 48 ld [ %l4 + 0x148 ], %g2
400097a4: c4 20 40 00 st %g2, [ %g1 ]
400097a8: 10 80 00 06 b 400097c0 <_Thread_Dispatch+0xf8>
400097ac: fa 04 a3 cc ld [ %l2 + 0x3cc ], %i5
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
400097b0: 90 10 00 1b mov %i3, %o0
400097b4: 9f c0 40 00 call %g1
400097b8: 92 10 00 14 mov %l4, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
400097bc: 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 ) {
400097c0: 80 a7 40 13 cmp %i5, %l3
400097c4: 32 bf ff fb bne,a 400097b0 <_Thread_Dispatch+0xe8>
400097c8: 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 );
400097cc: 90 06 e0 c0 add %i3, 0xc0, %o0
400097d0: 40 00 04 30 call 4000a890 <_CPU_Context_switch>
400097d4: 92 05 20 c0 add %l4, 0xc0, %o1
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
400097d8: 82 16 a3 10 or %i2, 0x310, %g1
_ISR_Disable( level );
400097dc: 7f ff e2 33 call 400020a8 <sparc_disable_interrupts>
400097e0: f6 00 60 10 ld [ %g1 + 0x10 ], %i3
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
400097e4: 82 16 a3 10 or %i2, 0x310, %g1
400097e8: c4 08 60 0c ldub [ %g1 + 0xc ], %g2
400097ec: 80 a0 a0 00 cmp %g2, 0
400097f0: 32 bf ff c4 bne,a 40009700 <_Thread_Dispatch+0x38>
400097f4: e8 00 60 14 ld [ %g1 + 0x14 ], %l4
400097f8: 10 bf ff c9 b 4000971c <_Thread_Dispatch+0x54>
400097fc: 03 10 00 78 sethi %hi(0x4001e000), %g1
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
40009800: 9f c0 40 00 call %g1
40009804: 90 10 00 1b mov %i3, %o0
40009808: 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 ) {
4000980c: 80 a7 40 1c cmp %i5, %i4
40009810: 32 bf ff fc bne,a 40009800 <_Thread_Dispatch+0x138>
40009814: c2 07 60 08 ld [ %i5 + 8 ], %g1
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
40009818: 81 c7 e0 08 ret
4000981c: 81 e8 00 00 restore
4000e848 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
4000e848: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
4000e84c: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000e850: fa 00 63 20 ld [ %g1 + 0x320 ], %i5 ! 4001e720 <_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();
4000e854: 3f 10 00 3a sethi %hi(0x4000e800), %i7
4000e858: be 17 e0 48 or %i7, 0x48, %i7 ! 4000e848 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4000e85c: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
4000e860: 7f ff ce 16 call 400020b8 <sparc_enable_interrupts>
4000e864: 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;
4000e868: 03 10 00 77 sethi %hi(0x4001dc00), %g1
doneConstructors = true;
4000e86c: 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;
4000e870: f8 08 62 f8 ldub [ %g1 + 0x2f8 ], %i4
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
4000e874: 90 10 00 1d mov %i5, %o0
4000e878: 13 10 00 28 sethi %hi(0x4000a000), %o1
4000e87c: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 4000a2e8 <_User_extensions_Thread_begin_visitor>
4000e880: 7f ff ee b7 call 4000a35c <_User_extensions_Iterate>
4000e884: c4 28 62 f8 stb %g2, [ %g1 + 0x2f8 ]
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4000e888: 7f ff eb e6 call 40009820 <_Thread_Enable_dispatch>
4000e88c: 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) */ {
4000e890: 80 8f 20 ff btst 0xff, %i4
4000e894: 32 80 00 05 bne,a 4000e8a8 <_Thread_Handler+0x60>
4000e898: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
INIT_NAME ();
4000e89c: 40 00 3b 4f call 4001d5d8 <_init>
4000e8a0: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4000e8a4: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
4000e8a8: 80 a0 60 00 cmp %g1, 0
4000e8ac: 12 80 00 05 bne 4000e8c0 <_Thread_Handler+0x78>
4000e8b0: 80 a0 60 01 cmp %g1, 1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4000e8b4: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
4000e8b8: 10 80 00 06 b 4000e8d0 <_Thread_Handler+0x88>
4000e8bc: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
4000e8c0: 12 80 00 08 bne 4000e8e0 <_Thread_Handler+0x98> <== NEVER TAKEN
4000e8c4: 90 10 00 1d mov %i5, %o0
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
4000e8c8: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
4000e8cc: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
4000e8d0: 9f c0 40 00 call %g1
4000e8d4: 01 00 00 00 nop
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
4000e8d8: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
4000e8dc: 90 10 00 1d mov %i5, %o0
4000e8e0: 13 10 00 28 sethi %hi(0x4000a000), %o1
4000e8e4: 7f ff ee 9e call 4000a35c <_User_extensions_Iterate>
4000e8e8: 92 12 63 0c or %o1, 0x30c, %o1 ! 4000a30c <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
4000e8ec: 90 10 20 00 clr %o0
4000e8f0: 92 10 20 01 mov 1, %o1
4000e8f4: 7f ff e6 ad call 400083a8 <_Internal_error_Occurred>
4000e8f8: 94 10 20 05 mov 5, %o2
40009ad8 <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
40009ad8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
40009adc: 03 10 00 6d sethi %hi(0x4001b400), %g1
40009ae0: 82 10 63 58 or %g1, 0x358, %g1 ! 4001b758 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
40009ae4: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
40009ae8: fa 00 60 14 ld [ %g1 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
40009aec: 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 ||
40009af0: 80 a0 e0 00 cmp %g3, 0
40009af4: 02 80 00 06 be 40009b0c <_Thread_Handler_initialization+0x34><== NEVER TAKEN
40009af8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40009afc: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
40009b00: 80 a0 e0 00 cmp %g3, 0
40009b04: 12 80 00 06 bne 40009b1c <_Thread_Handler_initialization+0x44>
40009b08: 80 a0 a0 00 cmp %g2, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
40009b0c: 90 10 20 00 clr %o0
40009b10: 92 10 20 01 mov 1, %o1
40009b14: 7f ff fa 25 call 400083a8 <_Internal_error_Occurred>
40009b18: 94 10 20 0e mov 0xe, %o2
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
40009b1c: 22 80 00 05 be,a 40009b30 <_Thread_Handler_initialization+0x58>
40009b20: 03 10 00 79 sethi %hi(0x4001e400), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
40009b24: 9f c0 80 00 call %g2
40009b28: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 4001e404 <_POSIX_Threads_Information>
_Thread_Dispatch_necessary = false;
40009b2c: 03 10 00 79 sethi %hi(0x4001e400), %g1
40009b30: 82 10 63 10 or %g1, 0x310, %g1 ! 4001e710 <_Per_CPU_Information>
40009b34: c0 28 60 0c clrb [ %g1 + 0xc ]
_Thread_Executing = NULL;
40009b38: c0 20 60 10 clr [ %g1 + 0x10 ]
_Thread_Heir = NULL;
40009b3c: 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;
40009b40: 03 10 00 78 sethi %hi(0x4001e000), %g1
40009b44: f8 20 62 7c st %i4, [ %g1 + 0x27c ] ! 4001e27c <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
40009b48: 03 10 00 78 sethi %hi(0x4001e000), %g1
40009b4c: fa 20 61 60 st %i5, [ %g1 + 0x160 ] ! 4001e160 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
40009b50: 82 10 20 08 mov 8, %g1
40009b54: 11 10 00 78 sethi %hi(0x4001e000), %o0
40009b58: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40009b5c: 90 12 22 f0 or %o0, 0x2f0, %o0
40009b60: 92 10 20 01 mov 1, %o1
40009b64: 94 10 20 01 mov 1, %o2
40009b68: 96 10 20 01 mov 1, %o3
40009b6c: 98 10 21 60 mov 0x160, %o4
40009b70: 7f ff fb 9e call 400089e8 <_Objects_Initialize_information>
40009b74: 9a 10 20 00 clr %o5
40009b78: 81 c7 e0 08 ret
40009b7c: 81 e8 00 00 restore
40009900 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
40009900: 9d e3 bf 98 save %sp, -104, %sp
40009904: 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;
40009908: c0 26 61 4c clr [ %i1 + 0x14c ]
4000990c: c0 26 61 50 clr [ %i1 + 0x150 ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
40009910: 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
)
{
40009914: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
40009918: e2 00 40 00 ld [ %g1 ], %l1
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
4000991c: 80 a6 a0 00 cmp %i2, 0
40009920: 12 80 00 0d bne 40009954 <_Thread_Initialize+0x54>
40009924: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
40009928: 90 10 00 19 mov %i1, %o0
4000992c: 40 00 02 06 call 4000a144 <_Thread_Stack_Allocate>
40009930: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
40009934: 80 a2 00 1b cmp %o0, %i3
40009938: 0a 80 00 64 bcs 40009ac8 <_Thread_Initialize+0x1c8>
4000993c: 80 a2 20 00 cmp %o0, 0
40009940: 02 80 00 62 be 40009ac8 <_Thread_Initialize+0x1c8> <== NEVER TAKEN
40009944: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
40009948: f4 06 60 bc ld [ %i1 + 0xbc ], %i2
the_thread->Start.core_allocated_stack = true;
4000994c: 10 80 00 04 b 4000995c <_Thread_Initialize+0x5c>
40009950: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
40009954: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
40009958: 90 10 00 1b mov %i3, %o0
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
the_stack->size = size;
4000995c: d0 26 60 b4 st %o0, [ %i1 + 0xb4 ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
40009960: 03 10 00 78 sethi %hi(0x4001e000), %g1
40009964: d0 00 62 7c ld [ %g1 + 0x27c ], %o0 ! 4001e27c <_Thread_Maximum_extensions>
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
40009968: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4000996c: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
40009970: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
40009974: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
40009978: c0 26 60 6c clr [ %i1 + 0x6c ]
4000997c: 80 a2 20 00 cmp %o0, 0
40009980: 02 80 00 08 be 400099a0 <_Thread_Initialize+0xa0>
40009984: b8 10 20 00 clr %i4
extensions_area = _Workspace_Allocate(
40009988: 90 02 20 01 inc %o0
4000998c: 40 00 03 a5 call 4000a820 <_Workspace_Allocate>
40009990: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
40009994: b8 92 20 00 orcc %o0, 0, %i4
40009998: 02 80 00 40 be 40009a98 <_Thread_Initialize+0x198>
4000999c: b6 10 20 00 clr %i3
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
400099a0: 80 a7 20 00 cmp %i4, 0
400099a4: 12 80 00 0a bne 400099cc <_Thread_Initialize+0xcc>
400099a8: f8 26 61 54 st %i4, [ %i1 + 0x154 ]
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
400099ac: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
400099b0: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
400099b4: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
400099b8: 80 a4 20 02 cmp %l0, 2
400099bc: 12 80 00 12 bne 40009a04 <_Thread_Initialize+0x104>
400099c0: 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;
400099c4: 10 80 00 0e b 400099fc <_Thread_Initialize+0xfc>
400099c8: 03 10 00 78 sethi %hi(0x4001e000), %g1
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
400099cc: 03 10 00 78 sethi %hi(0x4001e000), %g1
400099d0: c4 00 62 7c ld [ %g1 + 0x27c ], %g2 ! 4001e27c <_Thread_Maximum_extensions>
400099d4: 10 80 00 05 b 400099e8 <_Thread_Initialize+0xe8>
400099d8: 82 10 20 00 clr %g1
the_thread->extensions[i] = NULL;
400099dc: 87 28 60 02 sll %g1, 2, %g3
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
400099e0: 82 00 60 01 inc %g1
the_thread->extensions[i] = NULL;
400099e4: c0 21 00 03 clr [ %g4 + %g3 ]
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
400099e8: 80 a0 40 02 cmp %g1, %g2
400099ec: 28 bf ff fc bleu,a 400099dc <_Thread_Initialize+0xdc>
400099f0: c8 06 61 54 ld [ %i1 + 0x154 ], %g4
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
400099f4: 10 bf ff ef b 400099b0 <_Thread_Initialize+0xb0>
400099f8: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
400099fc: c2 00 61 60 ld [ %g1 + 0x160 ], %g1
40009a00: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
40009a04: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->current_state = STATES_DORMANT;
40009a08: b4 10 20 01 mov 1, %i2
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
40009a0c: c2 26 60 a8 st %g1, [ %i1 + 0xa8 ]
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
40009a10: 03 10 00 75 sethi %hi(0x4001d400), %g1
40009a14: c2 00 62 bc ld [ %g1 + 0x2bc ], %g1 ! 4001d6bc <_Scheduler+0x18>
the_thread->current_state = STATES_DORMANT;
40009a18: f4 26 60 10 st %i2, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
40009a1c: c0 26 60 44 clr [ %i1 + 0x44 ]
the_thread->resource_count = 0;
40009a20: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
40009a24: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
40009a28: fa 26 60 ac st %i5, [ %i1 + 0xac ]
40009a2c: 9f c0 40 00 call %g1
40009a30: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
40009a34: b6 92 20 00 orcc %o0, 0, %i3
40009a38: 02 80 00 18 be 40009a98 <_Thread_Initialize+0x198>
40009a3c: 90 10 00 19 mov %i1, %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
40009a40: 40 00 01 99 call 4000a0a4 <_Thread_Set_priority>
40009a44: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40009a48: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
40009a4c: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
40009a50: c0 26 60 80 clr [ %i1 + 0x80 ]
40009a54: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40009a58: 83 28 60 02 sll %g1, 2, %g1
40009a5c: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
40009a60: e2 26 60 0c st %l1, [ %i1 + 0xc ]
* @{
*/
static inline bool _User_extensions_Thread_create( Thread_Control *created )
{
User_extensions_Thread_create_context ctx = { created, true };
40009a64: f2 27 bf f8 st %i1, [ %fp + -8 ]
40009a68: f4 2f bf fc stb %i2, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
40009a6c: 90 07 bf f8 add %fp, -8, %o0
40009a70: 13 10 00 28 sethi %hi(0x4000a000), %o1
40009a74: 40 00 02 3a call 4000a35c <_User_extensions_Iterate>
40009a78: 92 12 62 38 or %o1, 0x238, %o1 ! 4000a238 <_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 )
40009a7c: c2 0f bf fc ldub [ %fp + -4 ], %g1
40009a80: 80 a0 60 00 cmp %g1, 0
40009a84: 02 80 00 05 be 40009a98 <_Thread_Initialize+0x198>
40009a88: b0 10 20 01 mov 1, %i0
40009a8c: b0 0e 20 01 and %i0, 1, %i0
40009a90: 81 c7 e0 08 ret
40009a94: 81 e8 00 00 restore
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
40009a98: 40 00 03 6a call 4000a840 <_Workspace_Free>
40009a9c: d0 06 61 48 ld [ %i1 + 0x148 ], %o0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
40009aa0: 40 00 03 68 call 4000a840 <_Workspace_Free>
40009aa4: d0 06 61 4c ld [ %i1 + 0x14c ], %o0
40009aa8: 40 00 03 66 call 4000a840 <_Workspace_Free>
40009aac: d0 06 61 50 ld [ %i1 + 0x150 ], %o0
_Workspace_Free( extensions_area );
40009ab0: 40 00 03 64 call 4000a840 <_Workspace_Free>
40009ab4: 90 10 00 1c mov %i4, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
#endif
_Workspace_Free( sched );
40009ab8: 40 00 03 62 call 4000a840 <_Workspace_Free>
40009abc: 90 10 00 1b mov %i3, %o0
_Thread_Stack_Free( the_thread );
40009ac0: 40 00 01 b1 call 4000a184 <_Thread_Stack_Free>
40009ac4: 90 10 00 19 mov %i1, %o0
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
40009ac8: b0 10 20 00 clr %i0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
40009acc: b0 0e 20 01 and %i0, 1, %i0
40009ad0: 81 c7 e0 08 ret
40009ad4: 81 e8 00 00 restore
4000a184 <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000a184: 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 )
4000a188: c4 0e 20 b0 ldub [ %i0 + 0xb0 ], %g2
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
4000a18c: 03 10 00 6d sethi %hi(0x4001b400), %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 )
4000a190: 80 a0 a0 00 cmp %g2, 0
4000a194: 02 80 00 04 be 4000a1a4 <_Thread_Stack_Free+0x20> <== NEVER TAKEN
4000a198: c2 00 63 84 ld [ %g1 + 0x384 ], %g1
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
(*stack_free_hook)( the_thread->Start.Initial_stack.area );
4000a19c: 9f c0 40 00 call %g1
4000a1a0: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
4000a1a4: 81 c7 e0 08 ret
4000a1a8: 81 e8 00 00 restore
4000e900 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4000e900: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
4000e904: 7f ff cd e9 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
4000e908: 01 00 00 00 nop <== NOT EXECUTED
4000e90c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000e910: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000e914: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
4000e918: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
4000e91c: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
4000e920: 32 80 00 04 bne,a 4000e930 <_Thread_queue_Extract_fifo+0x30><== NOT EXECUTED
4000e924: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED
_ISR_Enable( level );
4000e928: 7f ff cd e4 call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
4000e92c: 81 e8 00 00 restore <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000e930: c4 06 40 00 ld [ %i1 ], %g2 <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
4000e934: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000e938: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4000e93c: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED
4000e940: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
4000e944: 02 80 00 06 be 4000e95c <_Thread_queue_Extract_fifo+0x5c> <== NOT EXECUTED
4000e948: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED
_ISR_Enable( level );
4000e94c: 7f ff cd db call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
4000e950: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
4000e954: 10 80 00 09 b 4000e978 <_Thread_queue_Extract_fifo+0x78> <== NOT EXECUTED
4000e958: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
4000e95c: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
4000e960: c2 26 60 50 st %g1, [ %i1 + 0x50 ] <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4000e964: 7f ff cd d5 call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
4000e968: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4000e96c: 7f ff ef 14 call 4000a5bc <_Watchdog_Remove> <== NOT EXECUTED
4000e970: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED
4000e974: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
4000e978: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4000e97c: 7f ff ea d3 call 400094c8 <_Thread_Clear_state> <== NOT EXECUTED
4000e980: 81 e8 00 00 restore <== NOT EXECUTED
40009ff0 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
40009ff0: 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 )
40009ff4: 80 a6 20 00 cmp %i0, 0
40009ff8: 02 80 00 19 be 4000a05c <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
40009ffc: 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 ) {
4000a000: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
4000a004: 80 a7 60 01 cmp %i5, 1
4000a008: 12 80 00 15 bne 4000a05c <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
4000a00c: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
4000a010: 7f ff e0 26 call 400020a8 <sparc_disable_interrupts>
4000a014: 01 00 00 00 nop
4000a018: b8 10 00 08 mov %o0, %i4
4000a01c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000a020: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000a024: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
4000a028: 80 88 80 01 btst %g2, %g1
4000a02c: 02 80 00 0a be 4000a054 <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
4000a030: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
4000a034: 92 10 00 19 mov %i1, %o1
4000a038: 94 10 20 01 mov 1, %o2
4000a03c: 40 00 0b b6 call 4000cf14 <_Thread_queue_Extract_priority_helper>
4000a040: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000a044: 90 10 00 18 mov %i0, %o0
4000a048: 92 10 00 19 mov %i1, %o1
4000a04c: 7f ff ff 50 call 40009d8c <_Thread_queue_Enqueue_priority>
4000a050: 94 07 bf fc add %fp, -4, %o2
}
_ISR_Enable( level );
4000a054: 7f ff e0 19 call 400020b8 <sparc_enable_interrupts>
4000a058: 90 10 00 1c mov %i4, %o0
4000a05c: 81 c7 e0 08 ret
4000a060: 81 e8 00 00 restore
4000a064 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4000a064: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000a068: 90 10 00 18 mov %i0, %o0
4000a06c: 7f ff fd f9 call 40009850 <_Thread_Get>
4000a070: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000a074: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a078: 80 a0 60 00 cmp %g1, 0
4000a07c: 12 80 00 08 bne 4000a09c <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
4000a080: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000a084: 40 00 0b db call 4000cff0 <_Thread_queue_Process_timeout>
4000a088: 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;
4000a08c: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000a090: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 4001e200 <_Thread_Dispatch_disable_level>
--level;
4000a094: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000a098: c4 20 62 00 st %g2, [ %g1 + 0x200 ]
4000a09c: 81 c7 e0 08 ret
4000a0a0: 81 e8 00 00 restore
40018288 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
40018288: 9d e3 bf 88 save %sp, -120, %sp
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
4001828c: 27 10 00 f5 sethi %hi(0x4003d400), %l3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40018290: a4 07 bf e8 add %fp, -24, %l2
40018294: aa 07 bf ec add %fp, -20, %l5
40018298: b8 07 bf f4 add %fp, -12, %i4
4001829c: b2 07 bf f8 add %fp, -8, %i1
400182a0: ea 27 bf e8 st %l5, [ %fp + -24 ]
head->previous = NULL;
400182a4: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
400182a8: 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;
400182ac: f2 27 bf f4 st %i1, [ %fp + -12 ]
head->previous = NULL;
400182b0: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
400182b4: f8 27 bf fc st %i4, [ %fp + -4 ]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
400182b8: b4 06 20 30 add %i0, 0x30, %i2
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
400182bc: 29 10 00 f5 sethi %hi(0x4003d400), %l4
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
400182c0: b6 06 20 68 add %i0, 0x68, %i3
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
400182c4: a2 06 20 08 add %i0, 8, %l1
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
400182c8: a0 06 20 40 add %i0, 0x40, %l0
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
400182cc: 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;
400182d0: c2 04 e2 78 ld [ %l3 + 0x278 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
400182d4: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
400182d8: 90 10 00 1a mov %i2, %o0
400182dc: 92 20 40 09 sub %g1, %o1, %o1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
400182e0: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
400182e4: 40 00 11 79 call 4001c8c8 <_Watchdog_Adjust_to_chain>
400182e8: 94 10 00 1c mov %i4, %o2
400182ec: d0 1d 20 d8 ldd [ %l4 + 0xd8 ], %o0
400182f0: 94 10 20 00 clr %o2
400182f4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400182f8: 40 00 4f 75 call 4002c0cc <__divdi3>
400182fc: 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;
40018300: 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 ) {
40018304: 80 a2 40 0a cmp %o1, %o2
40018308: 08 80 00 07 bleu 40018324 <_Timer_server_Body+0x9c>
4001830c: ba 10 00 09 mov %o1, %i5
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40018310: 92 22 40 0a sub %o1, %o2, %o1
40018314: 90 10 00 1b mov %i3, %o0
40018318: 40 00 11 6c call 4001c8c8 <_Watchdog_Adjust_to_chain>
4001831c: 94 10 00 1c mov %i4, %o2
40018320: 30 80 00 06 b,a 40018338 <_Timer_server_Body+0xb0>
} else if ( snapshot < last_snapshot ) {
40018324: 1a 80 00 05 bcc 40018338 <_Timer_server_Body+0xb0>
40018328: 90 10 00 1b mov %i3, %o0
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
4001832c: 92 10 20 01 mov 1, %o1
40018330: 40 00 11 3e call 4001c828 <_Watchdog_Adjust>
40018334: 94 22 80 1d sub %o2, %i5, %o2
}
watchdogs->last_snapshot = snapshot;
40018338: fa 26 20 74 st %i5, [ %i0 + 0x74 ]
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
4001833c: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
40018340: 40 00 02 f4 call 40018f10 <_Chain_Get>
40018344: 01 00 00 00 nop
if ( timer == NULL ) {
40018348: 92 92 20 00 orcc %o0, 0, %o1
4001834c: 02 80 00 0c be 4001837c <_Timer_server_Body+0xf4>
40018350: 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 ) {
40018354: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
40018358: 80 a0 60 01 cmp %g1, 1
4001835c: 02 80 00 05 be 40018370 <_Timer_server_Body+0xe8>
40018360: 90 10 00 1a mov %i2, %o0
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
40018364: 80 a0 60 03 cmp %g1, 3
40018368: 12 bf ff f5 bne 4001833c <_Timer_server_Body+0xb4> <== NEVER TAKEN
4001836c: 90 10 00 1b mov %i3, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
40018370: 40 00 11 80 call 4001c970 <_Watchdog_Insert>
40018374: 92 02 60 10 add %o1, 0x10, %o1
40018378: 30 bf ff f1 b,a 4001833c <_Timer_server_Body+0xb4>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
4001837c: 7f ff df a6 call 40010214 <sparc_disable_interrupts>
40018380: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
40018384: c2 07 bf e8 ld [ %fp + -24 ], %g1
40018388: 80 a0 40 15 cmp %g1, %l5
4001838c: 12 80 00 0a bne 400183b4 <_Timer_server_Body+0x12c> <== NEVER TAKEN
40018390: 01 00 00 00 nop
ts->insert_chain = NULL;
40018394: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
40018398: 7f ff df a3 call 40010224 <sparc_enable_interrupts>
4001839c: 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 ) ) {
400183a0: c2 07 bf f4 ld [ %fp + -12 ], %g1
400183a4: 80 a0 40 19 cmp %g1, %i1
400183a8: 12 80 00 06 bne 400183c0 <_Timer_server_Body+0x138>
400183ac: 01 00 00 00 nop
400183b0: 30 80 00 18 b,a 40018410 <_Timer_server_Body+0x188>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
400183b4: 7f ff df 9c call 40010224 <sparc_enable_interrupts> <== NOT EXECUTED
400183b8: 01 00 00 00 nop <== NOT EXECUTED
400183bc: 30 bf ff c5 b,a 400182d0 <_Timer_server_Body+0x48> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
400183c0: 7f ff df 95 call 40010214 <sparc_disable_interrupts>
400183c4: 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;
400183c8: fa 07 bf f4 ld [ %fp + -12 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
400183cc: 80 a7 40 19 cmp %i5, %i1
400183d0: 02 80 00 0d be 40018404 <_Timer_server_Body+0x17c>
400183d4: 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;
400183d8: c2 07 40 00 ld [ %i5 ], %g1
head->next = new_first;
new_first->previous = head;
400183dc: 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;
400183e0: c2 27 bf f4 st %g1, [ %fp + -12 ]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
400183e4: c0 27 60 08 clr [ %i5 + 8 ]
_ISR_Enable( level );
400183e8: 7f ff df 8f call 40010224 <sparc_enable_interrupts>
400183ec: 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 );
400183f0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400183f4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
400183f8: 9f c0 40 00 call %g1
400183fc: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
}
40018400: 30 bf ff f0 b,a 400183c0 <_Timer_server_Body+0x138>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
40018404: 7f ff df 88 call 40010224 <sparc_enable_interrupts>
40018408: 01 00 00 00 nop
4001840c: 30 bf ff b0 b,a 400182cc <_Timer_server_Body+0x44>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
40018410: 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;
40018414: 03 10 00 f5 sethi %hi(0x4003d400), %g1
40018418: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4003d590 <_Thread_Dispatch_disable_level>
++level;
4001841c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40018420: c4 20 61 90 st %g2, [ %g1 + 0x190 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
40018424: d0 06 00 00 ld [ %i0 ], %o0
40018428: 40 00 10 1a call 4001c490 <_Thread_Set_state>
4001842c: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
40018430: 7f ff ff 6e call 400181e8 <_Timer_server_Reset_interval_system_watchdog>
40018434: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
40018438: 7f ff ff 80 call 40018238 <_Timer_server_Reset_tod_system_watchdog>
4001843c: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
40018440: 40 00 0d ce call 4001bb78 <_Thread_Enable_dispatch>
40018444: 01 00 00 00 nop
ts->active = true;
40018448: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
4001844c: 90 10 00 11 mov %l1, %o0
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
40018450: c2 2e 20 7c stb %g1, [ %i0 + 0x7c ]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
40018454: 40 00 11 9f call 4001cad0 <_Watchdog_Remove>
40018458: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
4001845c: 40 00 11 9d call 4001cad0 <_Watchdog_Remove>
40018460: 90 10 00 10 mov %l0, %o0
40018464: 30 bf ff 9a b,a 400182cc <_Timer_server_Body+0x44>
40018468 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
40018468: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
4001846c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
40018470: 80 a0 60 00 cmp %g1, 0
40018474: 12 80 00 51 bne 400185b8 <_Timer_server_Schedule_operation_method+0x150>
40018478: ba 10 00 19 mov %i1, %i5
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
4001847c: 03 10 00 f5 sethi %hi(0x4003d400), %g1
40018480: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4003d590 <_Thread_Dispatch_disable_level>
++level;
40018484: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40018488: c4 20 61 90 st %g2, [ %g1 + 0x190 ]
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
4001848c: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
40018490: 80 a0 60 01 cmp %g1, 1
40018494: 12 80 00 1f bne 40018510 <_Timer_server_Schedule_operation_method+0xa8>
40018498: 80 a0 60 03 cmp %g1, 3
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
4001849c: 7f ff df 5e call 40010214 <sparc_disable_interrupts>
400184a0: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
400184a4: 03 10 00 f5 sethi %hi(0x4003d400), %g1
400184a8: c4 00 62 78 ld [ %g1 + 0x278 ], %g2 ! 4003d678 <_Watchdog_Ticks_since_boot>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
400184ac: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
400184b0: 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 );
400184b4: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
400184b8: 80 a0 40 03 cmp %g1, %g3
400184bc: 02 80 00 08 be 400184dc <_Timer_server_Schedule_operation_method+0x74>
400184c0: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
400184c4: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
400184c8: 80 a7 00 04 cmp %i4, %g4
400184cc: 08 80 00 03 bleu 400184d8 <_Timer_server_Schedule_operation_method+0x70>
400184d0: 86 10 20 00 clr %g3
delta_interval -= delta;
400184d4: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
400184d8: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
400184dc: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
400184e0: 7f ff df 51 call 40010224 <sparc_enable_interrupts>
400184e4: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
400184e8: 90 06 20 30 add %i0, 0x30, %o0
400184ec: 40 00 11 21 call 4001c970 <_Watchdog_Insert>
400184f0: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
400184f4: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
400184f8: 80 a0 60 00 cmp %g1, 0
400184fc: 12 80 00 2d bne 400185b0 <_Timer_server_Schedule_operation_method+0x148>
40018500: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
40018504: 7f ff ff 39 call 400181e8 <_Timer_server_Reset_interval_system_watchdog>
40018508: 90 10 00 18 mov %i0, %o0
4001850c: 30 80 00 29 b,a 400185b0 <_Timer_server_Schedule_operation_method+0x148>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
40018510: 12 80 00 28 bne 400185b0 <_Timer_server_Schedule_operation_method+0x148>
40018514: 01 00 00 00 nop
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
40018518: 7f ff df 3f call 40010214 <sparc_disable_interrupts>
4001851c: 01 00 00 00 nop
40018520: b8 10 00 08 mov %o0, %i4
40018524: 03 10 00 f5 sethi %hi(0x4003d400), %g1
40018528: d0 18 60 d8 ldd [ %g1 + 0xd8 ], %o0 ! 4003d4d8 <_TOD>
4001852c: 94 10 20 00 clr %o2
40018530: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40018534: 40 00 4e e6 call 4002c0cc <__divdi3>
40018538: 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;
4001853c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
40018540: 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 );
40018544: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
40018548: 80 a0 40 03 cmp %g1, %g3
4001854c: 02 80 00 0d be 40018580 <_Timer_server_Schedule_operation_method+0x118>
40018550: 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 ) {
40018554: 08 80 00 08 bleu 40018574 <_Timer_server_Schedule_operation_method+0x10c>
40018558: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
4001855c: 88 22 40 02 sub %o1, %g2, %g4
if (delta_interval > delta) {
40018560: 80 a0 c0 04 cmp %g3, %g4
40018564: 08 80 00 06 bleu 4001857c <_Timer_server_Schedule_operation_method+0x114><== NEVER TAKEN
40018568: 84 10 20 00 clr %g2
delta_interval -= delta;
4001856c: 10 80 00 04 b 4001857c <_Timer_server_Schedule_operation_method+0x114>
40018570: 84 20 c0 04 sub %g3, %g4, %g2
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
40018574: 84 00 c0 02 add %g3, %g2, %g2
delta_interval += delta;
40018578: 84 20 80 09 sub %g2, %o1, %g2
}
first_watchdog->delta_interval = delta_interval;
4001857c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
40018580: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
40018584: 7f ff df 28 call 40010224 <sparc_enable_interrupts>
40018588: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
4001858c: 90 06 20 68 add %i0, 0x68, %o0
40018590: 40 00 10 f8 call 4001c970 <_Watchdog_Insert>
40018594: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
40018598: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
4001859c: 80 a0 60 00 cmp %g1, 0
400185a0: 12 80 00 04 bne 400185b0 <_Timer_server_Schedule_operation_method+0x148>
400185a4: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
400185a8: 7f ff ff 24 call 40018238 <_Timer_server_Reset_tod_system_watchdog>
400185ac: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
400185b0: 40 00 0d 72 call 4001bb78 <_Thread_Enable_dispatch>
400185b4: 81 e8 00 00 restore
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
400185b8: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
400185bc: 40 00 02 49 call 40018ee0 <_Chain_Append>
400185c0: 81 e8 00 00 restore
4000bb2c <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
4000bb2c: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
4000bb30: d4 1e 40 00 ldd [ %i1 ], %o2
4000bb34: 80 92 80 0b orcc %o2, %o3, %g0
4000bb38: 32 80 00 06 bne,a 4000bb50 <_Timestamp64_Divide+0x24> <== ALWAYS TAKEN
4000bb3c: d8 1e 00 00 ldd [ %i0 ], %o4
*_ival_percentage = 0;
4000bb40: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*_fval_percentage = 0;
4000bb44: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
4000bb48: 81 c7 e0 08 ret <== NOT EXECUTED
4000bb4c: 81 e8 00 00 restore <== NOT EXECUTED
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
4000bb50: 83 2b 20 02 sll %o4, 2, %g1
4000bb54: 87 2b 60 02 sll %o5, 2, %g3
4000bb58: 89 33 60 1e srl %o5, 0x1e, %g4
4000bb5c: bb 28 e0 05 sll %g3, 5, %i5
4000bb60: 84 11 00 01 or %g4, %g1, %g2
4000bb64: 83 30 e0 1b srl %g3, 0x1b, %g1
4000bb68: b9 28 a0 05 sll %g2, 5, %i4
4000bb6c: 86 a7 40 03 subcc %i5, %g3, %g3
4000bb70: b8 10 40 1c or %g1, %i4, %i4
4000bb74: 84 67 00 02 subx %i4, %g2, %g2
4000bb78: b2 80 c0 0d addcc %g3, %o5, %i1
4000bb7c: b0 40 80 0c addx %g2, %o4, %i0
4000bb80: 83 36 60 1e srl %i1, 0x1e, %g1
4000bb84: 87 2e 60 02 sll %i1, 2, %g3
4000bb88: 85 2e 20 02 sll %i0, 2, %g2
4000bb8c: 84 10 40 02 or %g1, %g2, %g2
4000bb90: ba 86 40 03 addcc %i1, %g3, %i5
4000bb94: b8 46 00 02 addx %i0, %g2, %i4
4000bb98: 83 37 60 1e srl %i5, 0x1e, %g1
4000bb9c: 87 2f 60 02 sll %i5, 2, %g3
4000bba0: 85 2f 20 02 sll %i4, 2, %g2
4000bba4: 84 10 40 02 or %g1, %g2, %g2
4000bba8: 92 87 40 03 addcc %i5, %g3, %o1
4000bbac: 90 47 00 02 addx %i4, %g2, %o0
4000bbb0: 87 32 60 1b srl %o1, 0x1b, %g3
4000bbb4: 85 2a 20 05 sll %o0, 5, %g2
4000bbb8: 83 2a 60 05 sll %o1, 5, %g1
4000bbbc: 90 10 c0 02 or %g3, %g2, %o0
4000bbc0: 40 00 39 e6 call 4001a358 <__divdi3>
4000bbc4: 92 10 00 01 mov %g1, %o1
*_ival_percentage = answer / 1000;
4000bbc8: 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;
4000bbcc: b8 10 00 08 mov %o0, %i4
4000bbd0: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
4000bbd4: 40 00 39 e1 call 4001a358 <__divdi3>
4000bbd8: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
4000bbdc: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
4000bbe0: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
4000bbe4: 94 10 20 00 clr %o2
4000bbe8: 92 10 00 1d mov %i5, %o1
4000bbec: 40 00 3a c6 call 4001a704 <__moddi3>
4000bbf0: 96 10 23 e8 mov 0x3e8, %o3
4000bbf4: d2 26 c0 00 st %o1, [ %i3 ]
4000bbf8: 81 c7 e0 08 ret
4000bbfc: 81 e8 00 00 restore
4000a41c <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
4000a41c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t number_of_initial_extensions =
4000a420: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000a424: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 4001b798 <Configuration+0x40>
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
4000a428: 80 a0 60 00 cmp %g1, 0
4000a42c: 02 80 00 0a be 4000a454 <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
4000a430: 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 )
4000a434: 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 =
4000a438: 40 00 01 08 call 4000a858 <_Workspace_Allocate_or_fatal_error>
4000a43c: 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 );
4000a440: 13 10 00 28 sethi %hi(0x4000a000), %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 };
4000a444: d0 27 bf fc st %o0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000a448: 92 12 63 d8 or %o1, 0x3d8, %o1
4000a44c: 7f ff ff c4 call 4000a35c <_User_extensions_Iterate>
4000a450: 90 07 bf fc add %fp, -4, %o0
4000a454: 81 c7 e0 08 ret
4000a458: 81 e8 00 00 restore
4000be64 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
4000be64: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
4000be68: 7f ff dc 22 call 40002ef0 <sparc_disable_interrupts>
4000be6c: 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;
4000be70: 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 );
4000be74: 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 ) ) {
4000be78: 80 a0 40 1c cmp %g1, %i4
4000be7c: 02 80 00 20 be 4000befc <_Watchdog_Adjust+0x98>
4000be80: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
4000be84: 02 80 00 1b be 4000bef0 <_Watchdog_Adjust+0x8c>
4000be88: b6 10 20 01 mov 1, %i3
4000be8c: 80 a6 60 01 cmp %i1, 1
4000be90: 12 80 00 1b bne 4000befc <_Watchdog_Adjust+0x98> <== NEVER TAKEN
4000be94: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
4000be98: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000be9c: 10 80 00 07 b 4000beb8 <_Watchdog_Adjust+0x54>
4000bea0: b4 00 80 1a add %g2, %i2, %i2
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
4000bea4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000bea8: 80 a6 80 02 cmp %i2, %g2
4000beac: 3a 80 00 05 bcc,a 4000bec0 <_Watchdog_Adjust+0x5c>
4000beb0: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
4000beb4: b4 20 80 1a sub %g2, %i2, %i2
break;
4000beb8: 10 80 00 11 b 4000befc <_Watchdog_Adjust+0x98>
4000bebc: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
} else {
units -= _Watchdog_First( header )->delta_interval;
4000bec0: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
4000bec4: 7f ff dc 0f call 40002f00 <sparc_enable_interrupts>
4000bec8: 01 00 00 00 nop
_Watchdog_Tickle( header );
4000becc: 40 00 00 90 call 4000c10c <_Watchdog_Tickle>
4000bed0: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
4000bed4: 7f ff dc 07 call 40002ef0 <sparc_disable_interrupts>
4000bed8: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
4000bedc: c2 06 00 00 ld [ %i0 ], %g1
4000bee0: 80 a0 40 1c cmp %g1, %i4
4000bee4: 12 80 00 04 bne 4000bef4 <_Watchdog_Adjust+0x90>
4000bee8: 80 a6 a0 00 cmp %i2, 0
4000beec: 30 80 00 04 b,a 4000befc <_Watchdog_Adjust+0x98>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
4000bef0: 80 a6 a0 00 cmp %i2, 0
4000bef4: 32 bf ff ec bne,a 4000bea4 <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
4000bef8: c2 06 00 00 ld [ %i0 ], %g1
}
break;
}
}
_ISR_Enable( level );
4000befc: 7f ff dc 01 call 40002f00 <sparc_enable_interrupts>
4000bf00: 91 e8 00 08 restore %g0, %o0, %o0
4000a5bc <_Watchdog_Remove>:
#include <rtems/score/watchdog.h>
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
4000a5bc: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
4000a5c0: 7f ff de ba call 400020a8 <sparc_disable_interrupts>
4000a5c4: ba 10 00 18 mov %i0, %i5
previous_state = the_watchdog->state;
4000a5c8: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
4000a5cc: 80 a6 20 01 cmp %i0, 1
4000a5d0: 22 80 00 1e be,a 4000a648 <_Watchdog_Remove+0x8c>
4000a5d4: c0 27 60 08 clr [ %i5 + 8 ]
4000a5d8: 0a 80 00 1d bcs 4000a64c <_Watchdog_Remove+0x90>
4000a5dc: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000a5e0: 80 a6 20 03 cmp %i0, 3
4000a5e4: 18 80 00 1a bgu 4000a64c <_Watchdog_Remove+0x90> <== NEVER TAKEN
4000a5e8: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
4000a5ec: 10 80 00 02 b 4000a5f4 <_Watchdog_Remove+0x38>
4000a5f0: c2 07 40 00 ld [ %i5 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
4000a5f4: c0 27 60 08 clr [ %i5 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
4000a5f8: c4 00 40 00 ld [ %g1 ], %g2
4000a5fc: 80 a0 a0 00 cmp %g2, 0
4000a600: 02 80 00 07 be 4000a61c <_Watchdog_Remove+0x60>
4000a604: 05 10 00 78 sethi %hi(0x4001e000), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
4000a608: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000a60c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000a610: 84 00 c0 02 add %g3, %g2, %g2
4000a614: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
4000a618: 05 10 00 78 sethi %hi(0x4001e000), %g2
4000a61c: c4 00 a2 e4 ld [ %g2 + 0x2e4 ], %g2 ! 4001e2e4 <_Watchdog_Sync_count>
4000a620: 80 a0 a0 00 cmp %g2, 0
4000a624: 22 80 00 07 be,a 4000a640 <_Watchdog_Remove+0x84>
4000a628: c4 07 60 04 ld [ %i5 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
4000a62c: 05 10 00 79 sethi %hi(0x4001e400), %g2
4000a630: c6 00 a3 18 ld [ %g2 + 0x318 ], %g3 ! 4001e718 <_Per_CPU_Information+0x8>
4000a634: 05 10 00 78 sethi %hi(0x4001e000), %g2
4000a638: c6 20 a2 84 st %g3, [ %g2 + 0x284 ] ! 4001e284 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000a63c: c4 07 60 04 ld [ %i5 + 4 ], %g2
next->previous = previous;
4000a640: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
4000a644: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000a648: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000a64c: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 4001e2e8 <_Watchdog_Ticks_since_boot>
4000a650: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_ISR_Enable( level );
4000a654: 7f ff de 99 call 400020b8 <sparc_enable_interrupts>
4000a658: 01 00 00 00 nop
return( previous_state );
}
4000a65c: 81 c7 e0 08 ret
4000a660: 81 e8 00 00 restore
4000b810 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
4000b810: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
4000b814: 7f ff dc 94 call 40002a64 <sparc_disable_interrupts>
4000b818: b8 10 00 18 mov %i0, %i4
4000b81c: b0 10 00 08 mov %o0, %i0
printk( "Watchdog Chain: %s %p\n", name, header );
4000b820: 11 10 00 78 sethi %hi(0x4001e000), %o0
4000b824: 94 10 00 19 mov %i1, %o2
4000b828: 90 12 23 50 or %o0, 0x350, %o0
4000b82c: 7f ff e3 e5 call 400047c0 <printk>
4000b830: 92 10 00 1c mov %i4, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000b834: 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 );
4000b838: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
4000b83c: 80 a7 40 19 cmp %i5, %i1
4000b840: 12 80 00 04 bne 4000b850 <_Watchdog_Report_chain+0x40>
4000b844: 92 10 00 1d mov %i5, %o1
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
4000b848: 10 80 00 0d b 4000b87c <_Watchdog_Report_chain+0x6c>
4000b84c: 11 10 00 78 sethi %hi(0x4001e000), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
4000b850: 40 00 00 0f call 4000b88c <_Watchdog_Report>
4000b854: 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 )
4000b858: 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 ) ;
4000b85c: 80 a7 40 19 cmp %i5, %i1
4000b860: 12 bf ff fc bne 4000b850 <_Watchdog_Report_chain+0x40> <== NEVER TAKEN
4000b864: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
4000b868: 11 10 00 78 sethi %hi(0x4001e000), %o0
4000b86c: 92 10 00 1c mov %i4, %o1
4000b870: 7f ff e3 d4 call 400047c0 <printk>
4000b874: 90 12 23 68 or %o0, 0x368, %o0
4000b878: 30 80 00 03 b,a 4000b884 <_Watchdog_Report_chain+0x74>
} else {
printk( "Chain is empty\n" );
4000b87c: 7f ff e3 d1 call 400047c0 <printk>
4000b880: 90 12 23 78 or %o0, 0x378, %o0
}
_ISR_Enable( level );
4000b884: 7f ff dc 7c call 40002a74 <sparc_enable_interrupts>
4000b888: 81 e8 00 00 restore
4000a664 <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
4000a664: 9d e3 bf a0 save %sp, -96, %sp
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
4000a668: 7f ff de 90 call 400020a8 <sparc_disable_interrupts>
4000a66c: b8 10 00 18 mov %i0, %i4
4000a670: b0 10 00 08 mov %o0, %i0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000a674: fa 07 00 00 ld [ %i4 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4000a678: b6 07 20 04 add %i4, 4, %i3
if ( _Chain_Is_empty( header ) )
4000a67c: 80 a7 40 1b cmp %i5, %i3
4000a680: 02 80 00 1f be 4000a6fc <_Watchdog_Tickle+0x98>
4000a684: 01 00 00 00 nop
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
4000a688: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000a68c: 80 a0 60 00 cmp %g1, 0
4000a690: 02 80 00 06 be 4000a6a8 <_Watchdog_Tickle+0x44> <== NEVER TAKEN
4000a694: 82 00 7f ff add %g1, -1, %g1
the_watchdog->delta_interval--;
4000a698: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
if ( the_watchdog->delta_interval != 0 )
4000a69c: 80 a0 60 00 cmp %g1, 0
4000a6a0: 12 80 00 17 bne 4000a6fc <_Watchdog_Tickle+0x98>
4000a6a4: 01 00 00 00 nop
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
4000a6a8: 7f ff ff c5 call 4000a5bc <_Watchdog_Remove>
4000a6ac: 90 10 00 1d mov %i5, %o0
4000a6b0: b4 10 00 08 mov %o0, %i2
_ISR_Enable( level );
4000a6b4: 7f ff de 81 call 400020b8 <sparc_enable_interrupts>
4000a6b8: 90 10 00 18 mov %i0, %o0
switch( watchdog_state ) {
4000a6bc: 80 a6 a0 02 cmp %i2, 2
4000a6c0: 12 80 00 06 bne 4000a6d8 <_Watchdog_Tickle+0x74>
4000a6c4: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
4000a6c8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000a6cc: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000a6d0: 9f c0 40 00 call %g1
4000a6d4: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
4000a6d8: 7f ff de 74 call 400020a8 <sparc_disable_interrupts>
4000a6dc: 01 00 00 00 nop
4000a6e0: b0 10 00 08 mov %o0, %i0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000a6e4: fa 07 00 00 ld [ %i4 ], %i5
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
4000a6e8: 80 a7 40 1b cmp %i5, %i3
4000a6ec: 02 80 00 04 be 4000a6fc <_Watchdog_Tickle+0x98>
4000a6f0: 01 00 00 00 nop
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
4000a6f4: 10 bf ff ea b 4000a69c <_Watchdog_Tickle+0x38>
4000a6f8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
4000a6fc: 7f ff de 6f call 400020b8 <sparc_enable_interrupts>
4000a700: 81 e8 00 00 restore
4000a704 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
4000a704: 9d e3 bf a0 save %sp, -96, %sp
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
4000a708: 05 10 00 6d sethi %hi(0x4001b400), %g2
4000a70c: 82 10 a3 58 or %g2, 0x358, %g1 ! 4001b758 <Configuration>
4000a710: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
4000a714: fa 00 a3 58 ld [ %g2 + 0x358 ], %i5
4000a718: 80 a0 e0 00 cmp %g3, 0
4000a71c: 12 80 00 03 bne 4000a728 <_Workspace_Handler_initialization+0x24>
4000a720: 84 10 20 00 clr %g2
4000a724: c4 00 60 04 ld [ %g1 + 4 ], %g2
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000a728: 21 10 00 20 sethi %hi(0x40008000), %l0
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000a72c: 27 10 00 78 sethi %hi(0x4001e000), %l3
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
4000a730: ba 00 80 1d add %g2, %i5, %i5
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000a734: b6 10 20 00 clr %i3
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000a738: a0 14 21 5c or %l0, 0x15c, %l0
size_t i;
for (i = 0; i < area_count; ++i) {
Heap_Area *area = &areas [i];
if ( do_zero ) {
4000a73c: e2 08 60 30 ldub [ %g1 + 0x30 ], %l1
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000a740: e4 08 60 31 ldub [ %g1 + 0x31 ], %l2
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000a744: 10 80 00 2c b 4000a7f4 <_Workspace_Handler_initialization+0xf0>
4000a748: a6 14 e2 10 or %l3, 0x210, %l3
Heap_Area *area = &areas [i];
if ( do_zero ) {
4000a74c: 22 80 00 07 be,a 4000a768 <_Workspace_Handler_initialization+0x64>
4000a750: f8 06 20 04 ld [ %i0 + 4 ], %i4
memset( area->begin, 0, area->size );
4000a754: d0 06 00 00 ld [ %i0 ], %o0
4000a758: d4 06 20 04 ld [ %i0 + 4 ], %o2
4000a75c: 40 00 13 52 call 4000f4a4 <memset>
4000a760: 92 10 20 00 clr %o1
}
if ( area->size > overhead ) {
4000a764: f8 06 20 04 ld [ %i0 + 4 ], %i4
4000a768: 80 a7 20 16 cmp %i4, 0x16
4000a76c: 28 80 00 21 bleu,a 4000a7f0 <_Workspace_Handler_initialization+0xec>
4000a770: b6 06 e0 01 inc %i3
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000a774: 80 a4 a0 00 cmp %l2, 0
4000a778: 32 80 00 0c bne,a 4000a7a8 <_Workspace_Handler_initialization+0xa4>
4000a77c: d2 06 00 00 ld [ %i0 ], %o1
size = area->size;
} else {
if ( remaining > 0 ) {
4000a780: 80 a7 60 00 cmp %i5, 0
4000a784: 22 80 00 08 be,a 4000a7a4 <_Workspace_Handler_initialization+0xa0><== NEVER TAKEN
4000a788: b8 10 20 00 clr %i4 <== NOT EXECUTED
size = remaining < area->size - overhead ?
4000a78c: 82 07 3f ea add %i4, -22, %g1
remaining + overhead : area->size;
4000a790: 80 a7 40 01 cmp %i5, %g1
4000a794: 2a 80 00 04 bcs,a 4000a7a4 <_Workspace_Handler_initialization+0xa0><== ALWAYS TAKEN
4000a798: b8 07 60 16 add %i5, 0x16, %i4
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000a79c: 10 80 00 03 b 4000a7a8 <_Workspace_Handler_initialization+0xa4><== NOT EXECUTED
4000a7a0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
4000a7a4: d2 06 00 00 ld [ %i0 ], %o1
4000a7a8: 94 10 00 1c mov %i4, %o2
4000a7ac: 90 10 00 13 mov %l3, %o0
4000a7b0: 9f c4 00 00 call %l0
4000a7b4: 96 10 20 08 mov 8, %o3
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000a7b8: c2 06 00 00 ld [ %i0 ], %g1
area->size -= size;
if ( space_available < remaining ) {
4000a7bc: 80 a2 00 1d cmp %o0, %i5
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000a7c0: 82 00 40 1c add %g1, %i4, %g1
4000a7c4: c2 26 00 00 st %g1, [ %i0 ]
area->size -= size;
4000a7c8: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000a7cc: b8 20 40 1c sub %g1, %i4, %i4
if ( space_available < remaining ) {
4000a7d0: 1a 80 00 05 bcc 4000a7e4 <_Workspace_Handler_initialization+0xe0><== ALWAYS TAKEN
4000a7d4: f8 26 20 04 st %i4, [ %i0 + 4 ]
remaining -= space_available;
4000a7d8: ba 27 40 08 sub %i5, %o0, %i5 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4000a7dc: 10 80 00 04 b 4000a7ec <_Workspace_Handler_initialization+0xe8><== NOT EXECUTED
4000a7e0: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED
4000a7e4: a0 10 00 1a mov %i2, %l0
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
4000a7e8: ba 10 20 00 clr %i5
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000a7ec: b6 06 e0 01 inc %i3
4000a7f0: b0 06 20 08 add %i0, 8, %i0
4000a7f4: 80 a6 c0 19 cmp %i3, %i1
4000a7f8: 12 bf ff d5 bne 4000a74c <_Workspace_Handler_initialization+0x48>
4000a7fc: 80 a4 60 00 cmp %l1, 0
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
4000a800: 80 a7 60 00 cmp %i5, 0
4000a804: 02 80 00 05 be 4000a818 <_Workspace_Handler_initialization+0x114>
4000a808: 90 10 20 00 clr %o0
_Internal_error_Occurred(
4000a80c: 92 10 20 01 mov 1, %o1
4000a810: 7f ff f6 e6 call 400083a8 <_Internal_error_Occurred>
4000a814: 94 10 20 02 mov 2, %o2
4000a818: 81 c7 e0 08 ret
4000a81c: 81 e8 00 00 restore
4001a854 <_calloc_r>:
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
4001a854: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
4001a858: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4001a85c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001a860: 7f ff a1 28 call 40002d00 <calloc> <== NOT EXECUTED
4001a864: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001a8dc <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
4001a8dc: 90 10 00 09 mov %o1, %o0
4001a8e0: 82 13 c0 00 mov %o7, %g1
4001a8e4: 7f ff ff e1 call 4001a868 <close>
4001a8e8: 9e 10 40 00 mov %g1, %o7
400124d4 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
400124d4: 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)
400124d8: 10 80 00 17 b 40012534 <_fat_block_read+0x60>
400124dc: ba 10 20 00 clr %i5
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
400124e0: 92 10 00 19 mov %i1, %o1
400124e4: 94 10 20 01 mov 1, %o2
400124e8: 7f ff ff cc call 40012418 <fat_buf_access>
400124ec: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
400124f0: 80 a2 20 00 cmp %o0, 0
400124f4: 32 80 00 15 bne,a 40012548 <_fat_block_read+0x74> <== NEVER TAKEN
400124f8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
400124fc: e0 16 00 00 lduh [ %i0 ], %l0
40012500: a0 24 00 1a sub %l0, %i2, %l0
40012504: 80 a4 00 1b cmp %l0, %i3
40012508: 38 80 00 02 bgu,a 40012510 <_fat_block_read+0x3c>
4001250c: a0 10 00 1b mov %i3, %l0
memcpy((buff + cmpltd), (sec_buf + ofs), c);
40012510: d2 07 bf fc ld [ %fp + -4 ], %o1
40012514: 90 07 00 1d add %i4, %i5, %o0
40012518: 92 02 40 1a add %o1, %i2, %o1
4001251c: 94 10 00 10 mov %l0, %o2
40012520: 40 00 23 90 call 4001b360 <memcpy>
40012524: b6 26 c0 10 sub %i3, %l0, %i3
count -= c;
cmpltd += c;
40012528: ba 04 00 1d add %l0, %i5, %i5
sec_num++;
4001252c: b2 06 60 01 inc %i1
ofs = 0;
40012530: b4 10 20 00 clr %i2
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
40012534: 80 a6 e0 00 cmp %i3, 0
40012538: 12 bf ff ea bne 400124e0 <_fat_block_read+0xc>
4001253c: 90 10 00 18 mov %i0, %o0
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
40012540: 81 c7 e0 08 ret
40012544: 91 e8 00 1d restore %g0, %i5, %o0
40012548: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001254c: 81 c7 e0 08 ret <== NOT EXECUTED
40012550: 81 e8 00 00 restore <== NOT EXECUTED
40003c90 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40003c90: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40003c94: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40003c98: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40003c9c: 7f ff ff e9 call 40003c40 <lstat> <== NOT EXECUTED
40003ca0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40003e8c <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40003e8c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40003e90: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40003e94: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40003e98: 7f ff ff e9 call 40003e3c <stat> <== NOT EXECUTED
40003e9c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40006cfc <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
40006cfc: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
40006d00: 3b 10 00 60 sethi %hi(0x40018000), %i5
40006d04: 40 00 04 68 call 40007ea4 <pthread_mutex_lock>
40006d08: 90 17 62 74 or %i5, 0x274, %o0 ! 40018274 <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
40006d0c: 90 10 00 18 mov %i0, %o0
40006d10: 40 00 1a 1d call 4000d584 <fcntl>
40006d14: 92 10 20 01 mov 1, %o1
40006d18: 80 a2 20 00 cmp %o0, 0
40006d1c: 16 80 00 08 bge 40006d3c <aio_cancel+0x40>
40006d20: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
40006d24: 40 00 04 81 call 40007f28 <pthread_mutex_unlock>
40006d28: 90 17 62 74 or %i5, 0x274, %o0
rtems_set_errno_and_return_minus_one (EBADF);
40006d2c: 40 00 27 4d call 40010a60 <__errno>
40006d30: 01 00 00 00 nop
40006d34: 10 80 00 54 b 40006e84 <aio_cancel+0x188>
40006d38: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
40006d3c: 32 80 00 35 bne,a 40006e10 <aio_cancel+0x114>
40006d40: f8 06 40 00 ld [ %i1 ], %i4
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
40006d44: 11 10 00 60 sethi %hi(0x40018000), %o0
40006d48: 92 10 00 18 mov %i0, %o1
40006d4c: 90 12 22 bc or %o0, 0x2bc, %o0
40006d50: 40 00 01 71 call 40007314 <rtems_aio_search_fd>
40006d54: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40006d58: b8 92 20 00 orcc %o0, 0, %i4
40006d5c: 12 80 00 20 bne 40006ddc <aio_cancel+0xe0>
40006d60: b6 07 20 1c add %i4, 0x1c, %i3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
40006d64: ba 17 62 74 or %i5, 0x274, %i5
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40006d68: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
40006d6c: 82 07 60 58 add %i5, 0x58, %g1
40006d70: 80 a0 80 01 cmp %g2, %g1
40006d74: 02 80 00 08 be 40006d94 <aio_cancel+0x98> <== NEVER TAKEN
40006d78: 92 10 00 18 mov %i0, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40006d7c: 90 07 60 54 add %i5, 0x54, %o0
40006d80: 40 00 01 65 call 40007314 <rtems_aio_search_fd>
40006d84: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40006d88: b8 92 20 00 orcc %o0, 0, %i4
40006d8c: 12 80 00 08 bne 40006dac <aio_cancel+0xb0>
40006d90: 01 00 00 00 nop
pthread_mutex_unlock(&aio_request_queue.mutex);
40006d94: 11 10 00 60 sethi %hi(0x40018000), %o0
return AIO_ALLDONE;
40006d98: b0 10 20 02 mov 2, %i0
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
40006d9c: 40 00 04 63 call 40007f28 <pthread_mutex_unlock>
40006da0: 90 12 22 74 or %o0, 0x274, %o0
return AIO_ALLDONE;
40006da4: 81 c7 e0 08 ret
40006da8: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40006dac: 40 00 0a cf call 400098e8 <_Chain_Extract>
40006db0: b6 07 20 1c add %i4, 0x1c, %i3
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
40006db4: 40 00 01 80 call 400073b4 <rtems_aio_remove_fd>
40006db8: 90 10 00 1c mov %i4, %o0
pthread_mutex_destroy (&r_chain->mutex);
40006dbc: 40 00 03 8d call 40007bf0 <pthread_mutex_destroy>
40006dc0: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->mutex);
40006dc4: 40 00 02 ae call 4000787c <pthread_cond_destroy>
40006dc8: 90 10 00 1b mov %i3, %o0
free (r_chain);
40006dcc: 7f ff f1 45 call 400032e0 <free>
40006dd0: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40006dd4: 10 80 00 0b b 40006e00 <aio_cancel+0x104>
40006dd8: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
40006ddc: 40 00 04 32 call 40007ea4 <pthread_mutex_lock>
40006de0: 90 10 00 1b mov %i3, %o0
40006de4: 40 00 0a c1 call 400098e8 <_Chain_Extract>
40006de8: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
40006dec: 40 00 01 72 call 400073b4 <rtems_aio_remove_fd>
40006df0: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
40006df4: 40 00 04 4d call 40007f28 <pthread_mutex_unlock>
40006df8: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40006dfc: 90 17 62 74 or %i5, 0x274, %o0
40006e00: 40 00 04 4a call 40007f28 <pthread_mutex_unlock>
40006e04: b0 10 20 00 clr %i0
return AIO_CANCELED;
40006e08: 81 c7 e0 08 ret
40006e0c: 81 e8 00 00 restore
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
40006e10: 80 a7 00 18 cmp %i4, %i0
40006e14: 12 80 00 17 bne 40006e70 <aio_cancel+0x174>
40006e18: 90 17 62 74 or %i5, 0x274, %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);
40006e1c: 11 10 00 60 sethi %hi(0x40018000), %o0
40006e20: 92 10 00 1c mov %i4, %o1
40006e24: 90 12 22 bc or %o0, 0x2bc, %o0
40006e28: 40 00 01 3b call 40007314 <rtems_aio_search_fd>
40006e2c: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40006e30: b6 92 20 00 orcc %o0, 0, %i3
40006e34: 32 80 00 1c bne,a 40006ea4 <aio_cancel+0x1a8>
40006e38: b8 06 e0 1c add %i3, 0x1c, %i4
40006e3c: ba 17 62 74 or %i5, 0x274, %i5
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40006e40: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
40006e44: 82 07 60 58 add %i5, 0x58, %g1
40006e48: 80 a0 80 01 cmp %g2, %g1
40006e4c: 02 bf ff d2 be 40006d94 <aio_cancel+0x98> <== NEVER TAKEN
40006e50: 92 10 00 1c mov %i4, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40006e54: 90 07 60 54 add %i5, 0x54, %o0
40006e58: 40 00 01 2f call 40007314 <rtems_aio_search_fd>
40006e5c: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40006e60: 80 a2 20 00 cmp %o0, 0
40006e64: 12 80 00 0b bne 40006e90 <aio_cancel+0x194>
40006e68: 90 02 20 08 add %o0, 8, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40006e6c: 90 10 00 1d mov %i5, %o0
40006e70: 40 00 04 2e call 40007f28 <pthread_mutex_unlock>
40006e74: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one (EINVAL);
40006e78: 40 00 26 fa call 40010a60 <__errno>
40006e7c: 01 00 00 00 nop
40006e80: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40006e84: c2 22 00 00 st %g1, [ %o0 ]
40006e88: 81 c7 e0 08 ret
40006e8c: 91 e8 3f ff restore %g0, -1, %o0
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40006e90: 40 00 01 5d call 40007404 <rtems_aio_remove_req>
40006e94: 92 10 00 19 mov %i1, %o1
40006e98: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
40006e9c: 10 80 00 0b b 40006ec8 <aio_cancel+0x1cc>
40006ea0: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
40006ea4: 40 00 04 00 call 40007ea4 <pthread_mutex_lock>
40006ea8: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40006eac: 92 10 00 19 mov %i1, %o1
40006eb0: 40 00 01 55 call 40007404 <rtems_aio_remove_req>
40006eb4: 90 06 e0 08 add %i3, 8, %o0
40006eb8: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
40006ebc: 40 00 04 1b call 40007f28 <pthread_mutex_unlock>
40006ec0: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40006ec4: 90 17 62 74 or %i5, 0x274, %o0
40006ec8: 40 00 04 18 call 40007f28 <pthread_mutex_unlock>
40006ecc: 01 00 00 00 nop
return result;
}
return AIO_ALLDONE;
}
40006ed0: 81 c7 e0 08 ret
40006ed4: 81 e8 00 00 restore
40006ee0 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
40006ee0: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
40006ee4: 03 00 00 08 sethi %hi(0x2000), %g1
40006ee8: 80 a6 00 01 cmp %i0, %g1
40006eec: 12 80 00 10 bne 40006f2c <aio_fsync+0x4c>
40006ef0: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40006ef4: d0 06 40 00 ld [ %i1 ], %o0
40006ef8: 40 00 19 a3 call 4000d584 <fcntl>
40006efc: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40006f00: 90 0a 20 03 and %o0, 3, %o0
40006f04: 90 02 3f ff add %o0, -1, %o0
40006f08: 80 a2 20 01 cmp %o0, 1
40006f0c: 18 80 00 08 bgu 40006f2c <aio_fsync+0x4c>
40006f10: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40006f14: 7f ff f2 13 call 40003760 <malloc>
40006f18: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40006f1c: b0 92 20 00 orcc %o0, 0, %i0
40006f20: 32 80 00 09 bne,a 40006f44 <aio_fsync+0x64> <== ALWAYS TAKEN
40006f24: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40006f28: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40006f2c: 82 10 3f ff mov -1, %g1
40006f30: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
40006f34: 40 00 26 cb call 40010a60 <__errno>
40006f38: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
40006f3c: 10 80 00 06 b 40006f54 <aio_fsync+0x74>
40006f40: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
40006f44: 82 10 20 03 mov 3, %g1
40006f48: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
40006f4c: 40 00 01 4e call 40007484 <rtems_aio_enqueue>
40006f50: 81 e8 00 00 restore
}
40006f54: 81 c7 e0 08 ret
40006f58: 91 e8 3f ff restore %g0, -1, %o0
4000769c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
4000769c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
400076a0: d0 06 00 00 ld [ %i0 ], %o0
400076a4: 92 10 20 03 mov 3, %o1
400076a8: 40 00 17 b7 call 4000d584 <fcntl>
400076ac: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
400076b0: 80 8a 20 01 btst 1, %o0
400076b4: 12 80 00 11 bne 400076f8 <aio_read+0x5c>
400076b8: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
400076bc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400076c0: 80 a0 60 00 cmp %g1, 0
400076c4: 22 80 00 04 be,a 400076d4 <aio_read+0x38>
400076c8: c2 06 20 08 ld [ %i0 + 8 ], %g1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
400076cc: 10 80 00 0b b 400076f8 <aio_read+0x5c>
400076d0: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
400076d4: 80 a0 60 00 cmp %g1, 0
400076d8: 06 80 00 08 bl 400076f8 <aio_read+0x5c>
400076dc: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
400076e0: 7f ff f0 20 call 40003760 <malloc>
400076e4: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
400076e8: b0 92 20 00 orcc %o0, 0, %i0
400076ec: 32 80 00 09 bne,a 40007710 <aio_read+0x74> <== ALWAYS TAKEN
400076f0: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
400076f4: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
400076f8: 82 10 3f ff mov -1, %g1
400076fc: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
40007700: 40 00 24 d8 call 40010a60 <__errno>
40007704: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
40007708: 10 80 00 06 b 40007720 <aio_read+0x84>
4000770c: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
40007710: 82 10 20 01 mov 1, %g1
40007714: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
40007718: 7f ff ff 5b call 40007484 <rtems_aio_enqueue>
4000771c: 81 e8 00 00 restore
}
40007720: 81 c7 e0 08 ret
40007724: 91 e8 3f ff restore %g0, -1, %o0
40007730 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
40007730: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40007734: d0 06 00 00 ld [ %i0 ], %o0
40007738: 40 00 17 93 call 4000d584 <fcntl>
4000773c: 92 10 20 03 mov 3, %o1
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
40007740: ba 10 00 18 mov %i0, %i5
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40007744: 90 0a 20 03 and %o0, 3, %o0
40007748: 90 02 3f ff add %o0, -1, %o0
4000774c: 80 a2 20 01 cmp %o0, 1
40007750: 18 80 00 11 bgu 40007794 <aio_write+0x64>
40007754: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
40007758: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000775c: 80 a0 60 00 cmp %g1, 0
40007760: 22 80 00 04 be,a 40007770 <aio_write+0x40>
40007764: c2 06 20 08 ld [ %i0 + 8 ], %g1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
40007768: 10 80 00 0b b 40007794 <aio_write+0x64>
4000776c: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
40007770: 80 a0 60 00 cmp %g1, 0
40007774: 06 80 00 08 bl 40007794 <aio_write+0x64>
40007778: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
4000777c: 7f ff ef f9 call 40003760 <malloc>
40007780: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40007784: b0 92 20 00 orcc %o0, 0, %i0
40007788: 32 80 00 09 bne,a 400077ac <aio_write+0x7c> <== ALWAYS TAKEN
4000778c: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40007790: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
40007794: 82 10 3f ff mov -1, %g1
40007798: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
4000779c: 40 00 24 b1 call 40010a60 <__errno>
400077a0: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
400077a4: 10 80 00 06 b 400077bc <aio_write+0x8c>
400077a8: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
400077ac: 82 10 20 02 mov 2, %g1
400077b0: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
400077b4: 7f ff ff 34 call 40007484 <rtems_aio_enqueue>
400077b8: 81 e8 00 00 restore
}
400077bc: 81 c7 e0 08 ret
400077c0: 91 e8 3f ff restore %g0, -1, %o0
400038c0 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
400038c0: 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(
400038c4: 94 10 20 19 mov 0x19, %o2
400038c8: 92 10 00 18 mov %i0, %o1
400038cc: 90 07 bf c8 add %fp, -56, %o0
400038d0: 17 10 00 51 sethi %hi(0x40014400), %o3
400038d4: 96 12 e3 a4 or %o3, 0x3a4, %o3 ! 400147a4 <rtems_global_user_env+0x4>
400038d8: 40 00 04 c3 call 40004be4 <rtems_filesystem_eval_path_start_with_root_and_current>
400038dc: 98 02 ff fc add %o3, -4, %o4
400038e0: 90 07 bf b0 add %fp, -80, %o0
400038e4: 40 00 05 da call 4000504c <rtems_filesystem_location_copy_and_detach>
400038e8: 92 07 bf e0 add %fp, -32, %o1
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
400038ec: 40 00 06 50 call 4000522c <rtems_filesystem_location_transform_to_global>
400038f0: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
400038f4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400038f8: 39 10 00 4f sethi %hi(0x40013c00), %i4
400038fc: b8 17 20 54 or %i4, 0x54, %i4 ! 40013c54 <rtems_filesystem_null_handlers>
40003900: 80 a0 40 1c cmp %g1, %i4
40003904: 02 80 00 29 be 400039a8 <chroot+0xe8>
40003908: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
4000390c: 40 00 06 16 call 40005164 <rtems_filesystem_global_location_obtain>
40003910: 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)(
40003914: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40003918: 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 =
4000391c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40003920: 9f c0 40 00 call %g1
40003924: 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 ) {
40003928: 80 a2 20 00 cmp %o0, 0
4000392c: 32 80 00 17 bne,a 40003988 <chroot+0xc8>
40003930: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
40003934: 40 00 03 1d call 400045a8 <rtems_libio_set_private_env>
40003938: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
4000393c: 80 a2 20 00 cmp %o0, 0
40003940: 12 80 00 0c bne 40003970 <chroot+0xb0>
40003944: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
40003948: 39 10 00 51 sethi %hi(0x40014400), %i4
4000394c: d0 07 23 9c ld [ %i4 + 0x39c ], %o0 ! 4001479c <rtems_current_user_env>
40003950: 92 10 00 1d mov %i5, %o1
40003954: 40 00 05 fb call 40005140 <rtems_filesystem_global_location_assign>
40003958: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
4000395c: d0 07 23 9c ld [ %i4 + 0x39c ], %o0
40003960: d2 07 bf ac ld [ %fp + -84 ], %o1
40003964: 40 00 05 f7 call 40005140 <rtems_filesystem_global_location_assign>
40003968: b0 10 20 00 clr %i0
4000396c: 30 80 00 10 b,a 400039ac <chroot+0xec>
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
40003970: 02 80 00 18 be 400039d0 <chroot+0x110> <== NEVER TAKEN
40003974: 01 00 00 00 nop
errno = ENOMEM;
40003978: 40 00 1f 6b call 4000b724 <__errno>
4000397c: 01 00 00 00 nop
40003980: 10 80 00 08 b 400039a0 <chroot+0xe0>
40003984: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
static inline void rtems_filesystem_location_error(
const rtems_filesystem_location_info_t *loc,
int eno
)
{
if ( !rtems_filesystem_location_is_null( loc ) ) {
40003988: 80 a0 40 1c cmp %g1, %i4
4000398c: 02 80 00 11 be 400039d0 <chroot+0x110> <== NEVER TAKEN
40003990: 01 00 00 00 nop
errno = eno;
40003994: 40 00 1f 64 call 4000b724 <__errno>
40003998: 01 00 00 00 nop
4000399c: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
400039a0: 10 80 00 0c b 400039d0 <chroot+0x110>
400039a4: c2 22 00 00 st %g1, [ %o0 ]
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
}
} else {
rv = -1;
400039a8: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
400039ac: 40 00 04 d4 call 40004cfc <rtems_filesystem_eval_path_cleanup>
400039b0: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
400039b4: 80 a6 20 00 cmp %i0, 0
400039b8: 02 80 00 0a be 400039e0 <chroot+0x120>
400039bc: 01 00 00 00 nop
rtems_filesystem_global_location_release( new_current_loc );
400039c0: 40 00 05 c8 call 400050e0 <rtems_filesystem_global_location_release>
400039c4: d0 07 bf ac ld [ %fp + -84 ], %o0
400039c8: 81 c7 e0 08 ret
400039cc: 81 e8 00 00 restore
rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
rv = -1;
}
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
400039d0: 40 00 05 c4 call 400050e0 <rtems_filesystem_global_location_release>
400039d4: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
400039d8: 10 bf ff f5 b 400039ac <chroot+0xec>
400039dc: b0 10 3f ff mov -1, %i0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
}
return rv;
}
400039e0: 81 c7 e0 08 ret
400039e4: 81 e8 00 00 restore
40006918 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40006918: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
4000691c: 80 a6 60 00 cmp %i1, 0
40006920: 02 80 00 26 be 400069b8 <clock_gettime+0xa0>
40006924: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40006928: 12 80 00 16 bne 40006980 <clock_gettime+0x68>
4000692c: 80 a6 20 04 cmp %i0, 4
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40006930: 90 07 bf f8 add %fp, -8, %o0
40006934: 13 10 00 65 sethi %hi(0x40019400), %o1
40006938: 40 00 08 1d call 400089ac <_TOD_Get_with_nanoseconds>
4000693c: 92 12 61 c8 or %o1, 0x1c8, %o1 ! 400195c8 <_TOD>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
40006940: 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);
40006944: 94 10 20 00 clr %o2
40006948: 90 10 00 1c mov %i4, %o0
4000694c: 92 10 00 1d mov %i5, %o1
40006950: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006954: 40 00 3c 14 call 400159a4 <__divdi3>
40006958: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
4000695c: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
40006960: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006964: 94 10 20 00 clr %o2
40006968: 92 10 00 1d mov %i5, %o1
4000696c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006970: 40 00 3c f8 call 40015d50 <__moddi3>
40006974: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
40006978: 10 80 00 06 b 40006990 <clock_gettime+0x78>
4000697c: d2 26 60 04 st %o1, [ %i1 + 4 ]
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
40006980: 12 80 00 06 bne 40006998 <clock_gettime+0x80> <== ALWAYS TAKEN
40006984: 80 a6 20 02 cmp %i0, 2
_TOD_Get_uptime_as_timespec( tp );
40006988: 40 00 08 1a call 400089f0 <_TOD_Get_uptime_as_timespec>
4000698c: 90 10 00 19 mov %i1, %o0
return 0;
40006990: 81 c7 e0 08 ret
40006994: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40006998: 02 bf ff fc be 40006988 <clock_gettime+0x70>
4000699c: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
400069a0: 12 80 00 06 bne 400069b8 <clock_gettime+0xa0>
400069a4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
400069a8: 40 00 23 6d call 4000f75c <__errno>
400069ac: 01 00 00 00 nop
400069b0: 10 80 00 05 b 400069c4 <clock_gettime+0xac>
400069b4: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
400069b8: 40 00 23 69 call 4000f75c <__errno>
400069bc: 01 00 00 00 nop
400069c0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
400069c4: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
400069c8: 81 c7 e0 08 ret
400069cc: 91 e8 3f ff restore %g0, -1, %o0
40024e7c <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
40024e7c: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40024e80: 82 96 60 00 orcc %i1, 0, %g1
40024e84: 02 80 00 4b be 40024fb0 <clock_settime+0x134> <== NEVER TAKEN
40024e88: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40024e8c: 12 80 00 41 bne 40024f90 <clock_settime+0x114>
40024e90: 80 a6 20 02 cmp %i0, 2
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
40024e94: c6 00 40 00 ld [ %g1 ], %g3
40024e98: 05 08 76 b9 sethi %hi(0x21dae400), %g2
40024e9c: 84 10 a0 ff or %g2, 0xff, %g2 ! 21dae4ff <RAM_SIZE+0x219ae4ff>
40024ea0: 80 a0 c0 02 cmp %g3, %g2
40024ea4: 08 80 00 43 bleu 40024fb0 <clock_settime+0x134>
40024ea8: 05 10 01 8c sethi %hi(0x40063000), %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;
40024eac: c6 00 a1 c0 ld [ %g2 + 0x1c0 ], %g3 ! 400631c0 <_Thread_Dispatch_disable_level>
++level;
40024eb0: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
40024eb4: c6 20 a1 c0 st %g3, [ %g2 + 0x1c0 ]
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40024eb8: c6 00 40 00 ld [ %g1 ], %g3
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
40024ebc: 90 07 bf f8 add %fp, -8, %o0
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40024ec0: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
40024ec4: 89 28 a0 03 sll %g2, 3, %g4
40024ec8: bb 28 e0 03 sll %g3, 3, %i5
40024ecc: b7 30 e0 1d srl %g3, 0x1d, %i3
40024ed0: b8 16 c0 04 or %i3, %g4, %i4
40024ed4: 89 37 60 1b srl %i5, 0x1b, %g4
40024ed8: b5 2f 20 05 sll %i4, 5, %i2
40024edc: b7 2f 60 05 sll %i5, 5, %i3
40024ee0: b4 11 00 1a or %g4, %i2, %i2
40024ee4: ba a6 c0 1d subcc %i3, %i5, %i5
40024ee8: 89 37 60 1a srl %i5, 0x1a, %g4
40024eec: b8 66 80 1c subx %i2, %i4, %i4
40024ef0: b7 2f 60 06 sll %i5, 6, %i3
40024ef4: b5 2f 20 06 sll %i4, 6, %i2
40024ef8: b6 a6 c0 1d subcc %i3, %i5, %i3
40024efc: b4 11 00 1a or %g4, %i2, %i2
40024f00: b4 66 80 1c subx %i2, %i4, %i2
40024f04: b2 86 c0 03 addcc %i3, %g3, %i1
40024f08: b0 46 80 02 addx %i2, %g2, %i0
40024f0c: 89 36 60 1e srl %i1, 0x1e, %g4
40024f10: 85 2e 20 02 sll %i0, 2, %g2
40024f14: 84 11 00 02 or %g4, %g2, %g2
40024f18: 87 2e 60 02 sll %i1, 2, %g3
40024f1c: ba 86 40 03 addcc %i1, %g3, %i5
40024f20: b8 46 00 02 addx %i0, %g2, %i4
40024f24: 89 37 60 1e srl %i5, 0x1e, %g4
40024f28: 85 2f 20 02 sll %i4, 2, %g2
40024f2c: 84 11 00 02 or %g4, %g2, %g2
40024f30: 87 2f 60 02 sll %i5, 2, %g3
40024f34: b6 87 40 03 addcc %i5, %g3, %i3
40024f38: b4 47 00 02 addx %i4, %g2, %i2
40024f3c: bb 2e e0 02 sll %i3, 2, %i5
40024f40: 85 36 e0 1e srl %i3, 0x1e, %g2
40024f44: 86 86 c0 1d addcc %i3, %i5, %g3
40024f48: b9 2e a0 02 sll %i2, 2, %i4
40024f4c: b8 10 80 1c or %g2, %i4, %i4
40024f50: 84 46 80 1c addx %i2, %i4, %g2
40024f54: bb 28 a0 09 sll %g2, 9, %i5
40024f58: b9 30 e0 17 srl %g3, 0x17, %i4
40024f5c: 84 17 00 1d or %i4, %i5, %g2
40024f60: fa 00 60 04 ld [ %g1 + 4 ], %i5
40024f64: 89 28 e0 09 sll %g3, 9, %g4
40024f68: b6 81 00 1d addcc %g4, %i5, %i3
40024f6c: b9 3f 60 1f sra %i5, 0x1f, %i4
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
40024f70: b0 10 20 00 clr %i0
40024f74: b4 40 80 1c addx %g2, %i4, %i2
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
40024f78: 40 00 04 4d call 400260ac <_TOD_Set_with_timestamp>
40024f7c: f4 3f bf f8 std %i2, [ %fp + -8 ]
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
40024f80: 7f ff 90 77 call 4000915c <_Thread_Enable_dispatch>
40024f84: 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;
40024f88: 81 c7 e0 08 ret
40024f8c: 81 e8 00 00 restore
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
40024f90: 02 80 00 04 be 40024fa0 <clock_settime+0x124>
40024f94: 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 )
40024f98: 12 80 00 06 bne 40024fb0 <clock_settime+0x134>
40024f9c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
40024fa0: 40 00 44 a0 call 40036220 <__errno>
40024fa4: 01 00 00 00 nop
40024fa8: 10 80 00 05 b 40024fbc <clock_settime+0x140>
40024fac: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
40024fb0: 40 00 44 9c call 40036220 <__errno>
40024fb4: 01 00 00 00 nop
40024fb8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40024fbc: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
40024fc0: 81 c7 e0 08 ret
40024fc4: 91 e8 3f ff restore %g0, -1, %o0
40003074 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
40003074: 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) {
40003078: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000307c: e0 00 62 58 ld [ %g1 + 0x258 ], %l0 ! 40019e58 <disktab_size>
40003080: 80 a6 00 10 cmp %i0, %l0
40003084: 0a 80 00 16 bcs 400030dc <create_disk+0x68>
40003088: 03 10 00 67 sethi %hi(0x40019c00), %g1
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
4000308c: bb 2c 20 01 sll %l0, 1, %i5
if (major >= new_size) {
40003090: 80 a6 00 1d cmp %i0, %i5
40003094: 0a 80 00 03 bcs 400030a0 <create_disk+0x2c> <== NEVER TAKEN
40003098: d0 00 62 5c ld [ %g1 + 0x25c ], %o0
new_size = major + 1;
4000309c: ba 06 20 01 add %i0, 1, %i5
}
table = realloc(table, new_size * sizeof(*table));
400030a0: 40 00 07 ce call 40004fd8 <realloc>
400030a4: 93 2f 60 03 sll %i5, 3, %o1
if (table == NULL) {
400030a8: a2 92 20 00 orcc %o0, 0, %l1
400030ac: 02 80 00 58 be 4000320c <create_disk+0x198> <== ALWAYS TAKEN
400030b0: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
400030b4: 91 2c 20 03 sll %l0, 3, %o0 <== NOT EXECUTED
400030b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400030bc: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
400030c0: 40 00 41 bd call 400137b4 <memset> <== NOT EXECUTED
400030c4: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
400030c8: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED
400030cc: e2 20 62 5c st %l1, [ %g1 + 0x25c ] ! 40019e5c <disktab> <== NOT EXECUTED
disktab_size = new_size;
400030d0: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED
400030d4: fa 20 62 58 st %i5, [ %g1 + 0x258 ] ! 40019e58 <disktab_size><== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
400030d8: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED
400030dc: e4 00 62 5c ld [ %g1 + 0x25c ], %l2 ! 40019e5c <disktab>
400030e0: a3 2e 20 03 sll %i0, 3, %l1
400030e4: d0 04 80 11 ld [ %l2 + %l1 ], %o0
400030e8: a8 04 80 11 add %l2, %l1, %l4
400030ec: 80 a2 20 00 cmp %o0, 0
400030f0: 02 80 00 05 be 40003104 <create_disk+0x90>
400030f4: e0 05 20 04 ld [ %l4 + 4 ], %l0
400030f8: 80 a6 40 10 cmp %i1, %l0
400030fc: 2a 80 00 16 bcs,a 40003154 <create_disk+0xe0>
40003100: e2 04 80 11 ld [ %l2 + %l1 ], %l1
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
40003104: 80 a4 20 00 cmp %l0, 0
40003108: 02 80 00 03 be 40003114 <create_disk+0xa0>
4000310c: ba 10 20 08 mov 8, %i5
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
40003110: bb 2c 20 01 sll %l0, 1, %i5
}
if (minor >= new_size) {
40003114: 80 a6 40 1d cmp %i1, %i5
40003118: 3a 80 00 02 bcc,a 40003120 <create_disk+0xac>
4000311c: ba 06 60 01 add %i1, 1, %i5
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
40003120: 40 00 07 ae call 40004fd8 <realloc>
40003124: 93 2f 60 02 sll %i5, 2, %o1
if (table == NULL) {
40003128: a6 92 20 00 orcc %o0, 0, %l3
4000312c: 02 80 00 38 be 4000320c <create_disk+0x198>
40003130: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40003134: 91 2c 20 02 sll %l0, 2, %o0
40003138: 92 10 20 00 clr %o1
4000313c: 90 04 c0 08 add %l3, %o0, %o0
40003140: 40 00 41 9d call 400137b4 <memset>
40003144: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
40003148: e6 24 80 11 st %l3, [ %l2 + %l1 ]
disktab [major].size = new_size;
4000314c: fa 25 20 04 st %i5, [ %l4 + 4 ]
}
return disktab [major].minor + minor;
40003150: e2 04 80 11 ld [ %l2 + %l1 ], %l1
40003154: a1 2e 60 02 sll %i1, 2, %l0
40003158: 82 04 40 10 add %l1, %l0, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
4000315c: 80 a0 60 00 cmp %g1, 0
40003160: 32 80 00 04 bne,a 40003170 <create_disk+0xfc> <== ALWAYS TAKEN
40003164: c4 04 40 10 ld [ %l1 + %l0 ], %g2
return RTEMS_NO_MEMORY;
40003168: 10 80 00 2a b 40003210 <create_disk+0x19c> <== NOT EXECUTED
4000316c: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
if (*dd_entry != NULL) {
40003170: 80 a0 a0 00 cmp %g2, 0
40003174: 12 80 00 27 bne 40003210 <create_disk+0x19c>
40003178: 82 10 20 0c mov 0xc, %g1
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
4000317c: 40 00 04 f5 call 40004550 <malloc>
40003180: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
40003184: ba 92 20 00 orcc %o0, 0, %i5
40003188: 02 80 00 21 be 4000320c <create_disk+0x198> <== NEVER TAKEN
4000318c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
40003190: 02 80 00 11 be 400031d4 <create_disk+0x160>
40003194: a4 10 20 00 clr %l2
alloc_name = strdup(name);
40003198: 40 00 42 61 call 40013b1c <strdup>
4000319c: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
400031a0: a4 92 20 00 orcc %o0, 0, %l2
400031a4: 12 80 00 11 bne 400031e8 <create_disk+0x174> <== ALWAYS TAKEN
400031a8: b4 10 00 08 mov %o0, %i2
free(dd);
400031ac: 40 00 03 a8 call 4000404c <free> <== NOT EXECUTED
400031b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
400031b4: 10 80 00 17 b 40003210 <create_disk+0x19c> <== NOT EXECUTED
400031b8: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
400031bc: 40 00 03 a4 call 4000404c <free> <== NOT EXECUTED
400031c0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
400031c4: 40 00 03 a2 call 4000404c <free> <== NOT EXECUTED
400031c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
400031cc: 10 80 00 11 b 40003210 <create_disk+0x19c> <== NOT EXECUTED
400031d0: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
}
}
*dd_entry = dd;
400031d4: fa 24 40 10 st %i5, [ %l1 + %l0 ]
*dd_ptr = dd;
400031d8: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
400031dc: e4 27 00 00 st %l2, [ %i4 ]
return RTEMS_SUCCESSFUL;
400031e0: 10 80 00 0c b 40003210 <create_disk+0x19c>
400031e4: 82 10 20 00 clr %g1
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
400031e8: 13 00 00 18 sethi %hi(0x6000), %o1
400031ec: 94 10 00 18 mov %i0, %o2
400031f0: 92 12 61 ff or %o1, 0x1ff, %o1
400031f4: 40 00 05 47 call 40004710 <mknod>
400031f8: 96 10 00 19 mov %i1, %o3
400031fc: 80 a2 20 00 cmp %o0, 0
40003200: 36 bf ff f6 bge,a 400031d8 <create_disk+0x164> <== ALWAYS TAKEN
40003204: fa 24 40 10 st %i5, [ %l1 + %l0 ]
40003208: 30 bf ff ed b,a 400031bc <create_disk+0x148> <== NOT EXECUTED
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
4000320c: 82 10 20 1a mov 0x1a, %g1
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
40003210: 81 c7 e0 08 ret
40003214: 91 e8 00 01 restore %g0, %g1, %o0
400042d8 <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)
400042d8: 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)
400042dc: 90 10 20 01 mov 1, %o0
* RTEMS_SUCCESSFUL, if success;
* RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure;
* RTEMS_INTERNAL_ERROR, if other error occurs.
*/
static rtems_status_code
data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)
400042e0: b8 10 00 18 mov %i0, %i4
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
400042e4: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
400042e8: 92 10 20 28 mov 0x28, %o1
400042ec: 40 00 03 1a call 40004f54 <calloc>
400042f0: b0 10 20 1a mov 0x1a, %i0
400042f4: 80 a2 20 00 cmp %o0, 0
400042f8: 02 80 00 27 be 40004394 <data_to_part_desc.part.1+0xbc> <== NEVER TAKEN
400042fc: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
40004300: c2 0f 00 00 ldub [ %i4 ], %g1
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40004304: 92 07 20 08 add %i4, 8, %o1
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
40004308: c2 2a 00 00 stb %g1, [ %o0 ]
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
4000430c: f6 0f 20 04 ldub [ %i4 + 4 ], %i3
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40004310: 94 10 20 04 mov 4, %o2
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
40004314: f6 2a 20 01 stb %i3, [ %o0 + 1 ]
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40004318: 40 00 41 b2 call 400149e0 <memcpy>
4000431c: 90 07 bf fc add %fp, -4, %o0
part_desc->start = LE_TO_CPU_U32(temp);
40004320: 7f ff ff ac call 400041d0 <CPU_swap_u32>
40004324: d0 07 bf fc ld [ %fp + -4 ], %o0
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40004328: 92 07 20 0c add %i4, 0xc, %o1
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
part_desc->start = LE_TO_CPU_U32(temp);
4000432c: d0 27 60 04 st %o0, [ %i5 + 4 ]
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40004330: 94 10 20 04 mov 4, %o2
40004334: 40 00 41 ab call 400149e0 <memcpy>
40004338: 90 07 bf fc add %fp, -4, %o0
part_desc->size = LE_TO_CPU_U32(temp);
4000433c: 7f ff ff a5 call 400041d0 <CPU_swap_u32>
40004340: d0 07 bf fc ld [ %fp + -4 ], %o0
40004344: d0 27 60 08 st %o0, [ %i5 + 8 ]
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
40004348: 82 0e e0 7f and %i3, 0x7f, %g1
4000434c: 80 a0 60 05 cmp %g1, 5
40004350: 02 80 00 0c be 40004380 <data_to_part_desc.part.1+0xa8>
40004354: b8 10 00 08 mov %o0, %i4
DOS_P32MB_PARTITION,
FAT32_PARTITION ,FAT32_LBA_PARTITION,
FAT16_LBA_PARTITION
};
return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
40004358: 11 10 00 90 sethi %hi(0x40024000), %o0
4000435c: 92 0e e0 ff and %i3, 0xff, %o1
40004360: 90 12 23 98 or %o0, 0x398, %o0
40004364: 40 00 41 31 call 40014828 <memchr>
40004368: 94 10 20 06 mov 6, %o2
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
4000436c: 80 a2 20 00 cmp %o0, 0
40004370: 02 80 00 06 be 40004388 <data_to_part_desc.part.1+0xb0>
40004374: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
40004378: 02 80 00 04 be 40004388 <data_to_part_desc.part.1+0xb0> <== NEVER TAKEN
4000437c: 01 00 00 00 nop
*new_part_desc = part_desc;
40004380: 10 80 00 04 b 40004390 <data_to_part_desc.part.1+0xb8>
40004384: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
40004388: 40 00 03 2b call 40005034 <free>
4000438c: 90 10 00 1d mov %i5, %o0
}
return RTEMS_SUCCESSFUL;
40004390: b0 10 20 00 clr %i0
}
40004394: 81 c7 e0 08 ret
40004398: 81 e8 00 00 restore
40002408 <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
40002408: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
4000240c: 03 10 00 4a sethi %hi(0x40012800), %g1
40002410: c2 00 61 48 ld [ %g1 + 0x148 ], %g1 ! 40012948 <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
40002414: 05 10 00 47 sethi %hi(0x40011c00), %g2
40002418: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000241c: 84 10 a1 7c or %g2, 0x17c, %g2
40002420: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40002424: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40002428: 80 a0 c0 02 cmp %g3, %g2
4000242c: 12 80 00 25 bne 400024c0 <devFS_Show+0xb8> <== NEVER TAKEN
40002430: 33 10 00 47 sethi %hi(0x40011c00), %i1
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return (const devFS_data *) loc->mt_entry->immutable_fs_info;
40002434: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
40002438: 31 10 00 47 sethi %hi(0x40011c00), %i0
}
printk(
4000243c: 21 10 00 47 sethi %hi(0x40011c00), %l0
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
if (rootloc->mt_entry->ops == &devFS_ops) {
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
40002440: f4 00 60 04 ld [ %g1 + 4 ], %i2
40002444: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
40002448: b6 10 20 00 clr %i3
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
4000244c: b2 16 61 d0 or %i1, 0x1d0, %i1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
40002450: b0 16 21 d8 or %i0, 0x1d8, %i0
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
40002454: 10 80 00 18 b 400024b4 <devFS_Show+0xac>
40002458: a0 14 21 e0 or %l0, 0x1e0, %l0
devFS_node *current = nodes + i;
if (current->name != NULL) {
4000245c: 80 a0 60 00 cmp %g1, 0
40002460: 22 80 00 14 be,a 400024b0 <devFS_Show+0xa8>
40002464: b6 06 e0 01 inc %i3
size_t j = 0;
size_t m = current->namelen;
40002468: e2 07 60 04 ld [ %i5 + 4 ], %l1
printk("/");
4000246c: 90 10 00 19 mov %i1, %o0
40002470: 40 00 03 d1 call 400033b4 <printk>
40002474: b8 10 20 00 clr %i4
for (j = 0; j < m; ++j) {
40002478: 10 80 00 07 b 40002494 <devFS_Show+0x8c>
4000247c: 80 a7 00 11 cmp %i4, %l1
printk("%c", current->name [j]);
40002480: 90 10 00 18 mov %i0, %o0
40002484: d2 48 40 1c ldsb [ %g1 + %i4 ], %o1
40002488: 40 00 03 cb call 400033b4 <printk>
4000248c: b8 07 20 01 inc %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
40002490: 80 a7 00 11 cmp %i4, %l1
40002494: 32 bf ff fb bne,a 40002480 <devFS_Show+0x78>
40002498: c2 07 40 00 ld [ %i5 ], %g1
printk("%c", current->name [j]);
}
printk(
4000249c: d2 07 60 08 ld [ %i5 + 8 ], %o1
400024a0: d4 07 60 0c ld [ %i5 + 0xc ], %o2
400024a4: 40 00 03 c4 call 400033b4 <printk>
400024a8: 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) {
400024ac: b6 06 e0 01 inc %i3
400024b0: ba 07 60 14 add %i5, 0x14, %i5
400024b4: 80 a6 c0 1a cmp %i3, %i2
400024b8: 32 bf ff e9 bne,a 4000245c <devFS_Show+0x54>
400024bc: c2 07 40 00 ld [ %i5 ], %g1
400024c0: 81 c7 e0 08 ret
400024c4: 81 e8 00 00 restore
4000bdcc <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
4000bdcc: 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;
4000bdd0: 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;
4000bdd4: f2 06 00 00 ld [ %i0 ], %i1
4000bdd8: 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;
4000bddc: f6 06 20 04 ld [ %i0 + 4 ], %i3
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
4000bde0: e2 00 60 04 ld [ %g1 + 4 ], %l1
4000bde4: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
4000bde8: b8 10 20 00 clr %i4
devFS_node *free_node = NULL;
4000bdec: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000bdf0: 10 80 00 12 b 4000be38 <devFS_eval_path+0x6c>
4000bdf4: b4 10 20 00 clr %i2
devFS_node *current = nodes + i;
if (current->name != NULL) {
4000bdf8: 80 a2 20 00 cmp %o0, 0
4000bdfc: 02 80 00 0c be 4000be2c <devFS_eval_path+0x60>
4000be00: a0 10 00 1d mov %i5, %l0
if (
4000be04: c4 07 60 04 ld [ %i5 + 4 ], %g2
4000be08: 80 a0 80 1b cmp %g2, %i3
4000be0c: 12 80 00 08 bne 4000be2c <devFS_eval_path+0x60>
4000be10: a0 10 00 01 mov %g1, %l0
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
4000be14: 92 10 00 19 mov %i1, %o1
4000be18: 40 00 0c c0 call 4000f118 <memcmp>
4000be1c: 94 10 00 1b mov %i3, %o2
4000be20: 80 a2 20 00 cmp %o0, 0
4000be24: 22 80 00 02 be,a 4000be2c <devFS_eval_path+0x60>
4000be28: b8 10 00 1d mov %i5, %i4
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000be2c: b4 06 a0 01 inc %i2
4000be30: ba 07 60 14 add %i5, 0x14, %i5
4000be34: 82 10 00 10 mov %l0, %g1
4000be38: 80 a7 20 00 cmp %i4, 0
4000be3c: 02 80 00 0a be 4000be64 <devFS_eval_path+0x98>
4000be40: 80 a6 80 11 cmp %i2, %l1
4000be44: 80 a0 60 00 cmp %g1, 0
4000be48: 02 80 00 07 be 4000be64 <devFS_eval_path+0x98> <== NEVER TAKEN
4000be4c: 80 a6 80 11 cmp %i2, %l1
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
4000be50: 80 a7 20 00 cmp %i4, 0
4000be54: 12 80 00 08 bne 4000be74 <devFS_eval_path+0xa8>
4000be58: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
4000be5c: 10 80 00 0b b 4000be88 <devFS_eval_path+0xbc>
4000be60: 80 88 a0 20 btst 0x20, %g2
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000be64: 32 bf ff e5 bne,a 4000bdf8 <devFS_eval_path+0x2c>
4000be68: d0 07 40 00 ld [ %i5 ], %o0
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
4000be6c: 10 bf ff fa b 4000be54 <devFS_eval_path+0x88>
4000be70: 80 a7 20 00 cmp %i4, 0
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
4000be74: 80 88 a0 40 btst 0x40, %g2
4000be78: 12 80 00 12 bne 4000bec0 <devFS_eval_path+0xf4>
4000be7c: b2 10 20 11 mov 0x11, %i1
currentloc->node_access = node;
4000be80: 10 80 00 0a b 4000bea8 <devFS_eval_path+0xdc>
4000be84: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
4000be88: 02 80 00 0d be 4000bebc <devFS_eval_path+0xf0> <== NEVER TAKEN
4000be8c: 80 a0 60 00 cmp %g1, 0
if (free_node != NULL) {
4000be90: 02 80 00 09 be 4000beb4 <devFS_eval_path+0xe8>
4000be94: 84 10 21 ff mov 0x1ff, %g2
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
4000be98: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
currentloc->node_access = free_node;
4000be9c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
4000bea0: f2 26 20 08 st %i1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
4000bea4: f6 26 20 0c st %i3, [ %i0 + 0xc ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
4000bea8: c0 26 20 04 clr [ %i0 + 4 ]
4000beac: 81 c7 e0 08 ret
4000beb0: 81 e8 00 00 restore
rtems_filesystem_eval_path_get_path(ctx),
rtems_filesystem_eval_path_get_pathlen(ctx)
);
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
4000beb4: 10 80 00 03 b 4000bec0 <devFS_eval_path+0xf4>
4000beb8: b2 10 20 1c mov 0x1c, %i1
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000bebc: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
4000bec0: 7f ff e4 7f call 400050bc <rtems_filesystem_eval_path_error>
4000bec4: 81 e8 00 00 restore
40003ea0 <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40003ea0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
40003ea4: 80 a6 a0 03 cmp %i2, 3
40003ea8: 12 80 00 0e bne 40003ee0 <devFS_mknod+0x40>
40003eac: 05 00 00 2c sethi %hi(0xb000), %g2
40003eb0: c2 4e 40 00 ldsb [ %i1 ], %g1
40003eb4: 80 a0 60 64 cmp %g1, 0x64
40003eb8: 12 80 00 0b bne 40003ee4 <devFS_mknod+0x44> <== NEVER TAKEN
40003ebc: 03 00 00 08 sethi %hi(0x2000), %g1
40003ec0: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
40003ec4: 80 a0 60 65 cmp %g1, 0x65
40003ec8: 12 80 00 07 bne 40003ee4 <devFS_mknod+0x44> <== NEVER TAKEN
40003ecc: 03 00 00 08 sethi %hi(0x2000), %g1
40003ed0: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
40003ed4: 80 a0 60 76 cmp %g1, 0x76
40003ed8: 02 80 00 1b be 40003f44 <devFS_mknod+0xa4> <== ALWAYS TAKEN
40003edc: 03 00 00 3c sethi %hi(0xf000), %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
40003ee0: 03 00 00 08 sethi %hi(0x2000), %g1
40003ee4: 84 0e c0 02 and %i3, %g2, %g2
40003ee8: 80 a0 80 01 cmp %g2, %g1
40003eec: 12 80 00 1b bne 40003f58 <devFS_mknod+0xb8>
40003ef0: 01 00 00 00 nop
char *dupname = malloc(namelen);
40003ef4: 40 00 01 47 call 40004410 <malloc>
40003ef8: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
40003efc: 84 92 20 00 orcc %o0, 0, %g2
40003f00: 02 80 00 0d be 40003f34 <devFS_mknod+0x94>
40003f04: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
40003f08: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
40003f0c: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
40003f10: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
40003f14: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
40003f18: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
40003f1c: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
40003f20: 94 10 00 1a mov %i2, %o2
40003f24: 40 00 2c a7 call 4000f1c0 <memcpy>
40003f28: b0 10 20 00 clr %i0
40003f2c: 81 c7 e0 08 ret
40003f30: 81 e8 00 00 restore
} else {
errno = ENOMEM;
40003f34: 40 00 28 9e call 4000e1ac <__errno>
40003f38: 01 00 00 00 nop
40003f3c: 10 80 00 0a b 40003f64 <devFS_mknod+0xc4>
40003f40: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
40003f44: b6 0e c0 01 and %i3, %g1, %i3
40003f48: 03 00 00 10 sethi %hi(0x4000), %g1
40003f4c: 80 a6 c0 01 cmp %i3, %g1
40003f50: 02 bf ff f7 be 40003f2c <devFS_mknod+0x8c> <== ALWAYS TAKEN
40003f54: b0 10 20 00 clr %i0
errno = ENOTSUP;
40003f58: 40 00 28 95 call 4000e1ac <__errno>
40003f5c: 01 00 00 00 nop
40003f60: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
40003f64: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
40003f68: b0 10 3f ff mov -1, %i0
}
}
return rv;
}
40003f6c: 81 c7 e0 08 ret
40003f70: 81 e8 00 00 restore
40003004 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
40003004: 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);
40003008: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000300c: d0 00 62 54 ld [ %g1 + 0x254 ], %o0 ! 40019e54 <diskdevs_mutex>
40003010: 92 10 20 00 clr %o1
40003014: 94 10 20 00 clr %o2
40003018: 40 00 14 91 call 4000825c <rtems_semaphore_obtain>
4000301c: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
40003020: 80 a2 20 00 cmp %o0, 0
40003024: 12 80 00 05 bne 40003038 <disk_lock+0x34> <== NEVER TAKEN
40003028: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
4000302c: 03 10 00 67 sethi %hi(0x40019c00), %g1
return RTEMS_SUCCESSFUL;
40003030: 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;
40003034: c4 28 62 50 stb %g2, [ %g1 + 0x250 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
40003038: 81 c7 e0 08 ret
4000303c: 81 e8 00 00 restore
40003040 <disk_unlock>:
static void
disk_unlock(void)
{
40003040: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
40003044: 03 10 00 67 sethi %hi(0x40019c00), %g1
40003048: c0 28 62 50 clrb [ %g1 + 0x250 ] ! 40019e50 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
4000304c: 03 10 00 67 sethi %hi(0x40019c00), %g1
40003050: 40 00 14 cc call 40008380 <rtems_semaphore_release>
40003054: d0 00 62 54 ld [ %g1 + 0x254 ], %o0 ! 40019e54 <diskdevs_mutex>
if (sc != RTEMS_SUCCESSFUL) {
40003058: 80 a2 20 00 cmp %o0, 0
4000305c: 02 80 00 04 be 4000306c <disk_unlock+0x2c> <== ALWAYS TAKEN
40003060: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
40003064: 40 00 16 31 call 40008928 <rtems_fatal_error_occurred> <== NOT EXECUTED
40003068: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
4000306c: 81 c7 e0 08 ret
40003070: 81 e8 00 00 restore
40004a0c <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
40004a0c: 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);
40004a10: 7f ff f5 a6 call 400020a8 <sparc_disable_interrupts>
40004a14: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
40004a18: 10 80 00 0f b 40004a54 <drainOutput.part.0+0x48>
40004a1c: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2>
rtems_interrupt_enable (level);
40004a20: 7f ff f5 a6 call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
40004a24: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
40004a28: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
40004a2c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40004a30: 40 00 09 50 call 40006f70 <rtems_semaphore_obtain> <== NOT EXECUTED
40004a34: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40004a38: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004a3c: 02 80 00 04 be 40004a4c <drainOutput.part.0+0x40> <== NOT EXECUTED
40004a40: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40004a44: 40 00 0b 28 call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004a48: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
40004a4c: 7f ff f5 97 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
40004a50: 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) {
40004a54: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
40004a58: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40004a5c: 80 a0 80 01 cmp %g2, %g1
40004a60: 32 bf ff f0 bne,a 40004a20 <drainOutput.part.0+0x14> <== NEVER TAKEN
40004a64: 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);
40004a68: 7f ff f5 94 call 400020b8 <sparc_enable_interrupts>
40004a6c: 91 e8 00 08 restore %g0, %o0, %o0
400034a8 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
400034a8: 92 10 20 00 clr %o1
400034ac: 94 10 20 00 clr %o2
400034b0: 82 13 c0 00 mov %o7, %g1
400034b4: 40 00 00 0c call 400034e4 <fcntl>
400034b8: 9e 10 40 00 mov %g1, %o7
400034bc: 40 00 35 64 call 40010a4c <putc+0x80> <== NOT EXECUTED
400034c0: 40 00 36 40 call 40010dc0 <strcmp> <== NOT EXECUTED
400034c4: 40 00 36 4c call 40010df4 <strcmp+0x34> <== NOT EXECUTED
400034c8: 40 00 36 64 call 40010e58 <strcmp+0x98> <== NOT EXECUTED
400034cc: 40 00 36 74 call 40010e9c <strcpy+0x30> <== NOT EXECUTED
400034d0: 40 00 36 98 call 40010f30 <_strdup_r+0x24> <== NOT EXECUTED
400034d4: 40 00 36 98 call 40010f34 <_strdup_r+0x28> <== NOT EXECUTED
400034d8: 40 00 36 98 call 40010f38 <_strdup_r+0x2c> <== NOT EXECUTED
400034dc: 40 00 36 98 call 40010f3c <_strdup_r+0x30> <== NOT EXECUTED
400034e0: 40 00 36 98 call 40010f40 <_strdup_r+0x34> <== NOT EXECUTED
4000345c <dup2>:
*/
int dup2(
int fildes,
int fildes2
)
{
4000345c: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
40003460: 90 10 00 18 mov %i0, %o0
40003464: 40 00 01 46 call 4000397c <fstat>
40003468: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
4000346c: 80 a2 3f ff cmp %o0, -1
40003470: 12 80 00 04 bne 40003480 <dup2+0x24>
40003474: 90 10 00 19 mov %i1, %o0
return -1;
40003478: 81 c7 e0 08 ret
4000347c: 91 e8 3f ff restore %g0, -1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
40003480: 40 00 01 3f call 4000397c <fstat>
40003484: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
40003488: 80 a2 3f ff cmp %o0, -1
4000348c: 02 bf ff fb be 40003478 <dup2+0x1c> <== NEVER TAKEN
40003490: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
40003494: 92 10 20 00 clr %o1
40003498: 40 00 00 13 call 400034e4 <fcntl>
4000349c: 94 10 00 19 mov %i1, %o2
}
400034a0: 81 c7 e0 08 ret
400034a4: 91 e8 00 08 restore %g0, %o0, %o0
400057f8 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
400057f8: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
400057fc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005800: 80 88 62 00 btst 0x200, %g1
40005804: 02 80 00 19 be 40005868 <echo+0x70> <== NEVER TAKEN
40005808: 03 10 00 76 sethi %hi(0x4001d800), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
4000580c: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 4001d8a0 <__ctype_ptr__>
40005810: 82 00 40 18 add %g1, %i0, %g1
40005814: 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) &&
40005818: 80 88 60 20 btst 0x20, %g1
4000581c: 02 80 00 14 be 4000586c <echo+0x74>
40005820: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
40005824: 82 06 3f f7 add %i0, -9, %g1
40005828: 82 08 60 ff and %g1, 0xff, %g1
4000582c: 80 a0 60 01 cmp %g1, 1
40005830: 08 80 00 0f bleu 4000586c <echo+0x74>
40005834: 82 10 20 5e mov 0x5e, %g1
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
40005838: 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] = '^';
4000583c: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
40005840: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
40005844: 90 07 bf f8 add %fp, -8, %o0
40005848: 92 10 20 02 mov 2, %o1
4000584c: 7f ff ff 43 call 40005558 <rtems_termios_puts>
40005850: 94 10 00 19 mov %i1, %o2
tty->column += 2;
40005854: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
40005858: 82 00 60 02 add %g1, 2, %g1
4000585c: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
40005860: 81 c7 e0 08 ret
40005864: 81 e8 00 00 restore
} else {
oproc (c, tty);
40005868: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000586c: 7f ff ff 84 call 4000567c <oproc>
40005870: 92 10 00 19 mov %i1, %o1
40005874: 81 c7 e0 08 ret
40005878: 81 e8 00 00 restore
40023d80 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
40023d80: 03 10 01 8b sethi %hi(0x40062c00), %g1
40023d84: d0 00 60 00 ld [ %g1 ], %o0
40023d88: 80 a2 20 00 cmp %o0, 0
40023d8c: 02 80 00 05 be 40023da0 <endgrent+0x20> <== NEVER TAKEN
40023d90: 01 00 00 00 nop
fclose(group_fp);
40023d94: 82 13 c0 00 mov %o7, %g1
40023d98: 40 00 49 74 call 40036368 <fclose>
40023d9c: 9e 10 40 00 mov %g1, %o7
40023da0: 81 c3 e0 08 retl <== NOT EXECUTED
40023bdc <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
40023bdc: 03 10 01 8a sethi %hi(0x40062800), %g1
40023be0: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 40062b20 <passwd_fp>
40023be4: 80 a2 20 00 cmp %o0, 0
40023be8: 02 80 00 05 be 40023bfc <endpwent+0x20> <== NEVER TAKEN
40023bec: 01 00 00 00 nop
fclose(passwd_fp);
40023bf0: 82 13 c0 00 mov %o7, %g1
40023bf4: 40 00 49 dd call 40036368 <fclose>
40023bf8: 9e 10 40 00 mov %g1, %o7
40023bfc: 81 c3 e0 08 retl <== NOT EXECUTED
4000587c <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)
4000587c: 9d e3 bf a0 save %sp, -96, %sp
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
40005880: 35 10 00 70 sethi %hi(0x4001c000), %i2
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
40005884: ba 10 00 18 mov %i0, %i5
40005888: 37 10 00 76 sethi %hi(0x4001d800), %i3
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
4000588c: 31 10 00 70 sethi %hi(0x4001c000), %i0
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
40005890: b4 16 a2 a0 or %i2, 0x2a0, %i2
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40005894: 10 80 00 62 b 40005a1c <erase.part.2+0x1a0>
40005898: b0 16 22 98 or %i0, 0x298, %i0
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
4000589c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
400058a0: 86 00 ff ff add %g3, -1, %g3
400058a4: c6 27 60 20 st %g3, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
400058a8: 80 88 60 08 btst 8, %g1
400058ac: 02 80 00 59 be 40005a10 <erase.part.2+0x194> <== NEVER TAKEN
400058b0: f8 09 00 03 ldub [ %g4 + %g3 ], %i4
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
400058b4: 80 a6 60 00 cmp %i1, 0
400058b8: 32 80 00 08 bne,a 400058d8 <erase.part.2+0x5c>
400058bc: b8 0f 20 ff and %i4, 0xff, %i4
400058c0: 80 88 60 10 btst 0x10, %g1
400058c4: 32 80 00 05 bne,a 400058d8 <erase.part.2+0x5c> <== ALWAYS TAKEN
400058c8: b8 0f 20 ff and %i4, 0xff, %i4
echo (tty->termios.c_cc[VERASE], tty);
400058cc: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
400058d0: 7f ff ff ca call 400057f8 <echo> <== NOT EXECUTED
400058d4: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
} else if (c == '\t') {
400058d8: 80 a7 20 09 cmp %i4, 9
400058dc: 32 80 00 28 bne,a 4000597c <erase.part.2+0x100>
400058e0: c4 06 e0 a0 ld [ %i3 + 0xa0 ], %g2
int col = tty->read_start_column;
400058e4: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
400058e8: da 06 e0 a0 ld [ %i3 + 0xa0 ], %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;
400058ec: 84 10 20 00 clr %g2
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
400058f0: 10 80 00 12 b 40005938 <erase.part.2+0xbc>
400058f4: 82 08 62 00 and %g1, 0x200, %g1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
400058f8: 80 a3 e0 09 cmp %o7, 9
400058fc: 12 80 00 04 bne 4000590c <erase.part.2+0x90>
40005900: 84 00 a0 01 inc %g2
col = (col | 7) + 1;
40005904: 10 80 00 0c b 40005934 <erase.part.2+0xb8>
40005908: b8 17 20 07 or %i4, 7, %i4
} else if (iscntrl (c)) {
4000590c: 9e 03 40 0f add %o5, %o7, %o7
40005910: de 0b e0 01 ldub [ %o7 + 1 ], %o7
40005914: 80 8b e0 20 btst 0x20, %o7
40005918: 22 80 00 08 be,a 40005938 <erase.part.2+0xbc> <== ALWAYS TAKEN
4000591c: b8 07 20 01 inc %i4
if (tty->termios.c_lflag & ECHOCTL)
40005920: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005924: 32 80 00 05 bne,a 40005938 <erase.part.2+0xbc> <== NOT EXECUTED
40005928: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
4000592c: 10 80 00 04 b 4000593c <erase.part.2+0xc0> <== NOT EXECUTED
40005930: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
40005934: b8 07 20 01 inc %i4
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40005938: 80 a0 80 03 cmp %g2, %g3
4000593c: 32 bf ff ef bne,a 400058f8 <erase.part.2+0x7c>
40005940: de 09 00 02 ldub [ %g4 + %g2 ], %o7
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40005944: 10 80 00 09 b 40005968 <erase.part.2+0xec>
40005948: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_termios_puts ("\b", 1, tty);
4000594c: 92 10 20 01 mov 1, %o1
40005950: 7f ff ff 02 call 40005558 <rtems_termios_puts>
40005954: 94 10 00 1d mov %i5, %o2
tty->column--;
40005958: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
4000595c: 82 00 7f ff add %g1, -1, %g1
40005960: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40005964: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40005968: 80 a0 40 1c cmp %g1, %i4
4000596c: 14 bf ff f8 bg 4000594c <erase.part.2+0xd0>
40005970: 90 10 00 18 mov %i0, %o0
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
40005974: 10 80 00 28 b 40005a14 <erase.part.2+0x198>
40005978: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
4000597c: b8 07 20 01 inc %i4
40005980: c4 08 80 1c ldub [ %g2 + %i4 ], %g2
40005984: 80 88 a0 20 btst 0x20, %g2
40005988: 22 80 00 10 be,a 400059c8 <erase.part.2+0x14c> <== ALWAYS TAKEN
4000598c: c2 06 e0 a0 ld [ %i3 + 0xa0 ], %g1
40005990: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
40005994: 02 80 00 0d be 400059c8 <erase.part.2+0x14c> <== NOT EXECUTED
40005998: c2 06 e0 a0 ld [ %i3 + 0xa0 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4000599c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400059a0: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
400059a4: 7f ff fe ed call 40005558 <rtems_termios_puts> <== NOT EXECUTED
400059a8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
400059ac: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
400059b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400059b4: 22 80 00 05 be,a 400059c8 <erase.part.2+0x14c> <== NOT EXECUTED
400059b8: c2 06 e0 a0 ld [ %i3 + 0xa0 ], %g1 <== NOT EXECUTED
tty->column--;
400059bc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400059c0: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
400059c4: c2 06 e0 a0 ld [ %i3 + 0xa0 ], %g1 <== NOT EXECUTED
400059c8: c2 08 40 1c ldub [ %g1 + %i4 ], %g1
400059cc: 80 88 60 20 btst 0x20, %g1
400059d0: 02 80 00 07 be 400059ec <erase.part.2+0x170> <== ALWAYS TAKEN
400059d4: 90 10 00 1a mov %i2, %o0
400059d8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
400059dc: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
400059e0: 02 80 00 0d be 40005a14 <erase.part.2+0x198> <== NOT EXECUTED
400059e4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
400059e8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400059ec: 92 10 20 03 mov 3, %o1
400059f0: 7f ff fe da call 40005558 <rtems_termios_puts>
400059f4: 94 10 00 1d mov %i5, %o2
if (tty->column)
400059f8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400059fc: 80 a0 60 00 cmp %g1, 0
40005a00: 02 80 00 05 be 40005a14 <erase.part.2+0x198> <== NEVER TAKEN
40005a04: 80 a6 60 00 cmp %i1, 0
tty->column--;
40005a08: 82 00 7f ff add %g1, -1, %g1
40005a0c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
40005a10: 80 a6 60 00 cmp %i1, 0
40005a14: 02 80 00 06 be 40005a2c <erase.part.2+0x1b0>
40005a18: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
40005a1c: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
40005a20: 80 a0 e0 00 cmp %g3, 0
40005a24: 32 bf ff 9e bne,a 4000589c <erase.part.2+0x20>
40005a28: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
40005a2c: 81 c7 e0 08 ret
40005a30: 81 e8 00 00 restore
40004028 <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
)
{
40004028: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
4000402c: 92 10 20 00 clr %o1
40004030: 90 10 00 18 mov %i0, %o0
40004034: 40 00 2d 1c call 4000f4a4 <memset>
40004038: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
4000403c: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
40004040: 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) {
40004044: 80 a6 a0 00 cmp %i2, 0
40004048: 02 80 00 19 be 400040ac <eval_path_start+0x84>
4000404c: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40004050: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40004054: 40 00 01 79 call 40004638 <rtems_filesystem_global_location_obtain>
40004058: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
4000405c: 83 2e e0 18 sll %i3, 0x18, %g1
40004060: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40004064: 80 a0 60 5c cmp %g1, 0x5c
40004068: 02 80 00 05 be 4000407c <eval_path_start+0x54> <== NEVER TAKEN
4000406c: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40004070: 80 a0 60 2f cmp %g1, 0x2f
40004074: 12 80 00 0a bne 4000409c <eval_path_start+0x74>
40004078: 90 10 00 1d mov %i5, %o0
++ctx->path;
4000407c: c2 06 00 00 ld [ %i0 ], %g1
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
40004080: 90 06 20 30 add %i0, 0x30, %o0
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
40004084: 82 00 60 01 inc %g1
40004088: c2 26 00 00 st %g1, [ %i0 ]
--ctx->pathlen;
4000408c: c2 06 20 04 ld [ %i0 + 4 ], %g1
40004090: 82 00 7f ff add %g1, -1, %g1
40004094: 10 80 00 02 b 4000409c <eval_path_start+0x74>
40004098: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
);
} else {
ctx->startloc = rtems_filesystem_global_location_obtain(
4000409c: 40 00 01 67 call 40004638 <rtems_filesystem_global_location_obtain>
400040a0: 01 00 00 00 nop
400040a4: 10 80 00 0d b 400040d8 <eval_path_start+0xb0>
400040a8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
400040ac: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
400040b0: 40 00 01 62 call 40004638 <rtems_filesystem_global_location_obtain>
400040b4: 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;
400040b8: c0 27 bf fc clr [ %fp + -4 ]
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
400040bc: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
400040c0: 40 00 01 5e call 40004638 <rtems_filesystem_global_location_obtain>
400040c4: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
400040c8: 40 00 2a 69 call 4000ea6c <__errno>
400040cc: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
400040d0: 82 10 20 02 mov 2, %g1
400040d4: c2 22 00 00 st %g1, [ %o0 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400040d8: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
400040dc: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
400040e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400040e4: c2 00 40 00 ld [ %g1 ], %g1
400040e8: 9f c0 40 00 call %g1
400040ec: 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(
400040f0: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
400040f4: 40 00 1c d8 call 4000b454 <rtems_filesystem_location_clone>
400040f8: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
400040fc: 90 10 00 18 mov %i0, %o0
40004100: 7f ff ff b0 call 40003fc0 <rtems_filesystem_eval_path_continue>
40004104: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
40004108: 81 c7 e0 08 ret
4000410c: 81 e8 00 00 restore
40012418 <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)
{
40012418: 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);
4001241c: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
40012420: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2
40012424: 84 20 80 01 sub %g2, %g1, %g2
40012428: 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);
4001242c: b9 2f 40 02 sll %i5, %g2, %i4
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
40012430: b8 26 40 1c sub %i1, %i4, %i4
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
40012434: b9 2f 00 01 sll %i4, %g1, %i4
sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset (fs_info,
sec_num,
0);
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
40012438: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
4001243c: 80 a0 60 00 cmp %g1, 0
40012440: 02 80 00 06 be 40012458 <fat_buf_access+0x40>
40012444: 01 00 00 00 nop
40012448: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4001244c: 80 a0 40 19 cmp %g1, %i1
40012450: 22 80 00 1c be,a 400124c0 <fat_buf_access+0xa8>
40012454: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
{
fat_buf_release(fs_info);
40012458: 7f ff ff 7c call 40012248 <fat_buf_release>
4001245c: 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);
40012460: 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)
40012464: 80 a6 a0 01 cmp %i2, 1
40012468: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
4001246c: 12 80 00 06 bne 40012484 <fat_buf_access+0x6c>
40012470: 94 06 20 8c add %i0, 0x8c, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
40012474: 7f ff f7 ae call 4001032c <rtems_bdbuf_read>
40012478: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
4001247c: 10 80 00 05 b 40012490 <fat_buf_access+0x78>
40012480: 80 a2 20 00 cmp %o0, 0
fat_buf_release(fs_info);
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
40012484: 7f ff f7 79 call 40010268 <rtems_bdbuf_get>
40012488: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
4001248c: 80 a2 20 00 cmp %o0, 0
40012490: 02 80 00 08 be 400124b0 <fat_buf_access+0x98> <== ALWAYS TAKEN
40012494: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
40012498: 40 00 21 0d call 4001a8cc <__errno> <== NOT EXECUTED
4001249c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400124a0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400124a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400124a8: 81 c7 e0 08 ret <== NOT EXECUTED
400124ac: 81 e8 00 00 restore <== NOT EXECUTED
fs_info->c.blk_num = sec_num;
400124b0: f2 26 20 84 st %i1, [ %i0 + 0x84 ]
fs_info->c.modified = 0;
400124b4: c0 2e 20 88 clrb [ %i0 + 0x88 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
400124b8: c2 2e 20 89 stb %g1, [ %i0 + 0x89 ]
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
400124bc: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
400124c0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400124c4: b8 00 40 1c add %g1, %i4, %i4
400124c8: f8 26 c0 00 st %i4, [ %i3 ]
return RC_OK;
}
400124cc: 81 c7 e0 08 ret
400124d0: 91 e8 20 00 restore %g0, 0, %o0
40012248 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
40012248: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
4001224c: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
40012250: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
40012254: 80 a0 60 00 cmp %g1, 0
40012258: 02 80 00 6e be 40012410 <fat_buf_release+0x1c8>
4001225c: b0 10 20 00 clr %i0
return RC_OK;
if (fs_info->c.modified)
40012260: c2 0f 60 88 ldub [ %i5 + 0x88 ], %g1
40012264: 80 a0 60 00 cmp %g1, 0
40012268: 02 80 00 5d be 400123dc <fat_buf_release+0x194>
4001226c: 01 00 00 00 nop
{
uint32_t sec_num = fs_info->c.blk_num;
40012270: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
40012274: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
40012278: 80 a0 40 02 cmp %g1, %g2
4001227c: 0a 80 00 05 bcs 40012290 <fat_buf_release+0x48>
40012280: b8 10 20 00 clr %i4
40012284: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40012288: 80 a0 40 02 cmp %g1, %g2
4001228c: b8 40 20 00 addx %g0, 0, %i4
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
40012290: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
40012294: 80 8f 20 ff btst 0xff, %i4
40012298: 02 80 00 12 be 400122e0 <fat_buf_release+0x98>
4001229c: c6 0f 60 0c ldub [ %i5 + 0xc ], %g3
400122a0: c8 0f 60 54 ldub [ %i5 + 0x54 ], %g4
400122a4: 80 a1 20 00 cmp %g4, 0
400122a8: 12 80 00 0e bne 400122e0 <fat_buf_release+0x98> <== NEVER TAKEN
400122ac: 84 08 a0 ff and %g2, 0xff, %g2
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
400122b0: c8 07 60 8c ld [ %i5 + 0x8c ], %g4
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
400122b4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
400122b8: d2 01 20 1c ld [ %g4 + 0x1c ], %o1
400122bc: d4 17 40 00 lduh [ %i5 ], %o2
400122c0: 86 08 e0 ff and %g3, 0xff, %g3
400122c4: 86 20 c0 02 sub %g3, %g2, %g3
400122c8: b7 30 40 03 srl %g1, %g3, %i3
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400122cc: 87 2e c0 03 sll %i3, %g3, %g3
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
400122d0: 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);
400122d4: 85 28 40 02 sll %g1, %g2, %g2
400122d8: 40 00 24 22 call 4001b360 <memcpy>
400122dc: 92 02 40 02 add %o1, %g2, %o1
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
400122e0: 7f ff f8 c4 call 400105f0 <rtems_bdbuf_release_modified>
400122e4: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
400122e8: 80 a2 20 00 cmp %o0, 0
400122ec: 12 80 00 41 bne 400123f0 <fat_buf_release+0x1a8> <== NEVER TAKEN
400122f0: 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)
400122f4: 02 80 00 45 be 40012408 <fat_buf_release+0x1c0>
400122f8: c0 2f 60 88 clrb [ %i5 + 0x88 ]
400122fc: c2 0f 60 54 ldub [ %i5 + 0x54 ], %g1
40012300: 80 a0 60 00 cmp %g1, 0
40012304: 22 80 00 2f be,a 400123c0 <fat_buf_release+0x178> <== ALWAYS TAKEN
40012308: b8 10 20 01 mov 1, %i4
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
4001230c: 10 80 00 40 b 4001240c <fat_buf_release+0x1c4> <== NOT EXECUTED
40012310: c0 2f 60 89 clrb [ %i5 + 0x89 ] <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
40012314: 7f ff c0 cf call 40002650 <.umul>
40012318: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001231c: f6 07 60 84 ld [ %i5 + 0x84 ], %i3
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40012320: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
40012324: 90 02 00 1b add %o0, %i3, %o0
40012328: f6 0f 60 0c ldub [ %i5 + 0xc ], %i3
4001232c: b6 26 c0 01 sub %i3, %g1, %i3
40012330: 93 32 00 1b srl %o0, %i3, %o1
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40012334: b7 2a 40 1b sll %o1, %i3, %i3
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
40012338: b6 22 00 1b sub %o0, %i3, %i3
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
4001233c: b7 2e c0 01 sll %i3, %g1, %i3
blk = fat_sector_num_to_block_num(fs_info, sec_num);
blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (blk_ofs == 0
40012340: 80 a6 e0 00 cmp %i3, 0
40012344: 12 80 00 0b bne 40012370 <fat_buf_release+0x128>
40012348: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
4001234c: c4 17 40 00 lduh [ %i5 ], %g2
40012350: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
40012354: 80 a0 80 01 cmp %g2, %g1
40012358: 12 80 00 06 bne 40012370 <fat_buf_release+0x128>
4001235c: 01 00 00 00 nop
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
40012360: 7f ff f7 c2 call 40010268 <rtems_bdbuf_get>
40012364: 94 07 bf fc add %fp, -4, %o2
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
}
if ( sc != RTEMS_SUCCESSFUL)
40012368: 10 80 00 05 b 4001237c <fat_buf_release+0x134>
4001236c: 80 a2 20 00 cmp %o0, 0
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
40012370: 7f ff f7 ef call 4001032c <rtems_bdbuf_read>
40012374: 94 07 bf fc add %fp, -4, %o2
}
if ( sc != RTEMS_SUCCESSFUL)
40012378: 80 a2 20 00 cmp %o0, 0
4001237c: 22 80 00 03 be,a 40012388 <fat_buf_release+0x140> <== ALWAYS TAKEN
40012380: c2 07 bf fc ld [ %fp + -4 ], %g1
40012384: 30 80 00 0b b,a 400123b0 <fat_buf_release+0x168> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
40012388: d2 07 60 90 ld [ %i5 + 0x90 ], %o1
4001238c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40012390: d4 17 40 00 lduh [ %i5 ], %o2
40012394: 40 00 23 f3 call 4001b360 <memcpy>
40012398: 90 02 00 1b add %o0, %i3, %o0
sc = rtems_bdbuf_release_modified(bd);
4001239c: 7f ff f8 95 call 400105f0 <rtems_bdbuf_release_modified>
400123a0: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
400123a4: 80 a2 20 00 cmp %o0, 0
400123a8: 22 80 00 06 be,a 400123c0 <fat_buf_release+0x178> <== ALWAYS TAKEN
400123ac: b8 07 20 01 inc %i4
rtems_set_errno_and_return_minus_one(ENOMEM);
400123b0: 40 00 21 47 call 4001a8cc <__errno> <== NOT EXECUTED
400123b4: 01 00 00 00 nop <== NOT EXECUTED
400123b8: 10 80 00 11 b 400123fc <fat_buf_release+0x1b4> <== NOT EXECUTED
400123bc: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
400123c0: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
400123c4: 90 0f 20 ff and %i4, 0xff, %o0
400123c8: 80 a2 00 01 cmp %o0, %g1
400123cc: 0a bf ff d2 bcs 40012314 <fat_buf_release+0xcc>
400123d0: 01 00 00 00 nop
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
400123d4: 10 80 00 0e b 4001240c <fat_buf_release+0x1c4>
400123d8: c0 2f 60 89 clrb [ %i5 + 0x89 ]
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
400123dc: 7f ff f8 50 call 4001051c <rtems_bdbuf_release>
400123e0: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
400123e4: 80 a2 20 00 cmp %o0, 0
400123e8: 22 80 00 09 be,a 4001240c <fat_buf_release+0x1c4> <== ALWAYS TAKEN
400123ec: c0 2f 60 89 clrb [ %i5 + 0x89 ]
rtems_set_errno_and_return_minus_one(EIO);
400123f0: 40 00 21 37 call 4001a8cc <__errno> <== NOT EXECUTED
400123f4: 01 00 00 00 nop <== NOT EXECUTED
400123f8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
400123fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012400: 81 c7 e0 08 ret <== NOT EXECUTED
40012404: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
40012408: c0 2f 60 89 clrb [ %i5 + 0x89 ]
return RC_OK;
4001240c: b0 10 20 00 clr %i0
}
40012410: 81 c7 e0 08 ret
40012414: 81 e8 00 00 restore
400121ec <fat_cluster_num_to_block_num>:
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400121ec: 80 a2 60 00 cmp %o1, 0
400121f0: 32 80 00 0c bne,a 40012220 <fat_cluster_num_to_block_num+0x34>
400121f4: c2 0a 20 0c ldub [ %o0 + 0xc ], %g1
400121f8: c2 0a 20 0e ldub [ %o0 + 0xe ], %g1
400121fc: 80 88 60 03 btst 3, %g1
40012200: 22 80 00 08 be,a 40012220 <fat_cluster_num_to_block_num+0x34><== NEVER TAKEN
40012204: c2 0a 20 0c ldub [ %o0 + 0xc ], %g1 <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40012208: c4 0a 20 0c ldub [ %o0 + 0xc ], %g2
4001220c: c2 0a 20 02 ldub [ %o0 + 2 ], %g1
40012210: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
40012214: 82 20 80 01 sub %g2, %g1, %g1
40012218: 81 c3 e0 08 retl
4001221c: 91 32 00 01 srl %o0, %g1, %o0
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40012220: c4 0a 20 08 ldub [ %o0 + 8 ], %g2
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
40012224: 92 02 7f fe add %o1, -2, %o1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40012228: 84 20 80 01 sub %g2, %g1, %g2
4001222c: 93 2a 40 02 sll %o1, %g2, %o1
40012230: c4 0a 20 02 ldub [ %o0 + 2 ], %g2
40012234: d0 02 20 34 ld [ %o0 + 0x34 ], %o0
40012238: 82 20 40 02 sub %g1, %g2, %g1
4001223c: 91 32 00 01 srl %o0, %g1, %o0
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
}
return blk;
}
40012240: 81 c3 e0 08 retl
40012244: 90 02 00 09 add %o0, %o1, %o0
40011548 <fat_cluster_num_to_sector_num>:
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40011548: 80 a2 60 00 cmp %o1, 0
4001154c: 32 80 00 08 bne,a 4001156c <fat_cluster_num_to_sector_num+0x24>
40011550: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
40011554: c2 0a 20 0e ldub [ %o0 + 0xe ], %g1
40011558: 80 88 60 03 btst 3, %g1
4001155c: 22 80 00 04 be,a 4001156c <fat_cluster_num_to_sector_num+0x24><== NEVER TAKEN
40011560: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40011564: 81 c3 e0 08 retl
40011568: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4001156c: 92 02 7f fe add %o1, -2, %o1
40011570: 93 2a 40 01 sll %o1, %g1, %o1
40011574: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
fs_info->vol.data_fsec);
}
40011578: 81 c3 e0 08 retl
4001157c: 90 02 40 01 add %o1, %g1, %o0
400125ec <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)
{
400125ec: 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));
400125f0: c2 16 20 06 lduh [ %i0 + 6 ], %g1
400125f4: 82 20 40 1a sub %g1, %i2, %g1
400125f8: 80 a6 c0 01 cmp %i3, %g1
400125fc: 38 80 00 02 bgu,a 40012604 <fat_cluster_set+0x18> <== NEVER TAKEN
40012600: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
40012604: 90 10 00 18 mov %i0, %o0
40012608: 7f ff fe f9 call 400121ec <fat_cluster_num_to_block_num>
4001260c: 92 10 00 19 mov %i1, %o1
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
40012610: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
ssize_t bytes_written = 0;
40012614: a0 10 20 00 clr %l0
const uint8_t pattern)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
40012618: a3 36 80 01 srl %i2, %g1, %l1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4001261c: 83 2c 40 01 sll %l1, %g1, %g1
40012620: a4 10 20 01 mov 1, %l2
40012624: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
40012628: a2 02 00 11 add %o0, %l1, %l1
while ( (RC_OK == rc)
4001262c: 10 80 00 2a b 400126d4 <fat_cluster_set+0xe8>
40012630: 82 10 20 00 clr %g1
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
40012634: 82 20 80 1a sub %g2, %i2, %g1
40012638: 80 a0 40 1b cmp %g1, %i3
4001263c: 08 80 00 03 bleu 40012648 <fat_cluster_set+0x5c> <== ALWAYS TAKEN
40012640: ba 10 00 01 mov %g1, %i5
40012644: 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));
40012648: 80 a7 40 01 cmp %i5, %g1
4001264c: 08 80 00 03 bleu 40012658 <fat_cluster_set+0x6c> <== ALWAYS TAKEN
40012650: b2 10 00 1d mov %i5, %i1
40012654: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
40012658: 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)
4001265c: 80 a6 60 00 cmp %i1, 0
40012660: 02 80 00 27 be 400126fc <fat_cluster_set+0x110> <== NEVER TAKEN
40012664: 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);
40012668: 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);
4001266c: 90 10 00 18 mov %i0, %o0
40012670: 93 2c 40 09 sll %l1, %o1, %o1
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
40012674: 80 a6 40 02 cmp %i1, %g2
40012678: 02 80 00 03 be 40012684 <fat_cluster_set+0x98>
4001267c: 94 10 20 02 mov 2, %o2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
40012680: 94 10 20 01 mov 1, %o2
40012684: 7f ff ff 65 call 40012418 <fat_buf_access>
40012688: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
4001268c: 80 a2 20 00 cmp %o0, 0
40012690: 12 80 00 0a bne 400126b8 <fat_cluster_set+0xcc> <== NEVER TAKEN
40012694: 80 a7 40 08 cmp %i5, %o0
{
memset(blk_buf + offset, pattern, bytes_to_write);
40012698: d0 07 bf fc ld [ %fp + -4 ], %o0
4001269c: 92 10 00 1c mov %i4, %o1
400126a0: 90 02 00 1a add %o0, %i2, %o0
400126a4: 40 00 23 6c call 4001b454 <memset>
400126a8: 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;
400126ac: 10 80 00 14 b 400126fc <fat_cluster_set+0x110>
400126b0: e4 2e 20 88 stb %l2, [ %i0 + 0x88 ]
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
400126b4: 80 a7 40 08 cmp %i5, %o0
400126b8: 12 80 00 06 bne 400126d0 <fat_cluster_set+0xe4> <== NEVER TAKEN
400126bc: 82 10 3f ff mov -1, %g1
rc = -1;
else
{
bytes_to_write -= ret;
400126c0: b6 26 c0 1d sub %i3, %i5, %i3
bytes_written += ret;
400126c4: a0 04 00 1d add %l0, %i5, %l0
++cur_blk;
400126c8: a2 04 60 01 inc %l1
400126cc: 82 10 20 00 clr %g1
400126d0: b4 10 20 00 clr %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
400126d4: 80 a6 e0 00 cmp %i3, 0
400126d8: 02 80 00 04 be 400126e8 <fat_cluster_set+0xfc>
400126dc: 80 a0 60 00 cmp %g1, 0
400126e0: 22 bf ff d5 be,a 40012634 <fat_cluster_set+0x48> <== ALWAYS TAKEN
400126e4: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
400126e8: 80 a0 60 00 cmp %g1, 0
400126ec: 12 80 00 06 bne 40012704 <fat_cluster_set+0x118> <== NEVER TAKEN
400126f0: b0 10 3f ff mov -1, %i0
400126f4: 81 c7 e0 08 ret
400126f8: 91 e8 00 10 restore %g0, %l0, %o0
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
400126fc: 10 bf ff ee b 400126b4 <fat_cluster_set+0xc8>
40012700: 90 10 00 19 mov %i1, %o0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
40012704: 81 c7 e0 08 ret <== NOT EXECUTED
40012708: 81 e8 00 00 restore <== NOT EXECUTED
4001270c <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
4001270c: 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));
40012710: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40012714: 82 20 40 1a sub %g1, %i2, %g1
40012718: 80 a6 c0 01 cmp %i3, %g1
4001271c: 38 80 00 02 bgu,a 40012724 <fat_cluster_write+0x18> <== NEVER TAKEN
40012720: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
40012724: 90 10 00 18 mov %i0, %o0
40012728: 7f ff fe b1 call 400121ec <fat_cluster_num_to_block_num>
4001272c: 92 10 00 19 mov %i1, %o1
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
40012730: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
ssize_t bytes_written = 0;
40012734: a2 10 20 00 clr %l1
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
40012738: a5 36 80 01 srl %i2, %g1, %l2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4001273c: 83 2c 80 01 sll %l2, %g1, %g1
40012740: a6 10 20 01 mov 1, %l3
40012744: 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;
40012748: a4 02 00 12 add %o0, %l2, %l2
while ( (RC_OK == rc)
4001274c: 10 80 00 2d b 40012800 <fat_cluster_write+0xf4>
40012750: 82 10 20 00 clr %g1
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
40012754: 82 20 80 1a sub %g2, %i2, %g1
40012758: 80 a0 40 1b cmp %g1, %i3
4001275c: 08 80 00 03 bleu 40012768 <fat_cluster_write+0x5c>
40012760: b2 10 00 01 mov %g1, %i1
40012764: 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));
40012768: 80 a6 40 01 cmp %i1, %g1
4001276c: 08 80 00 03 bleu 40012778 <fat_cluster_write+0x6c> <== ALWAYS TAKEN
40012770: a0 10 00 19 mov %i1, %l0
40012774: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
40012778: 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)
4001277c: 80 a4 20 00 cmp %l0, 0
40012780: 02 80 00 2a be 40012828 <fat_cluster_write+0x11c> <== NEVER TAKEN
40012784: 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);
40012788: 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);
4001278c: 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
40012790: 80 a7 60 00 cmp %i5, 0
40012794: 12 80 00 05 bne 400127a8 <fat_cluster_write+0x9c>
40012798: 93 2c 80 09 sll %l2, %o1, %o1
|| (bytes_to_write == fs_info->vol.bytes_per_block))
4001279c: 80 a4 00 02 cmp %l0, %g2
400127a0: 12 80 00 04 bne 400127b0 <fat_cluster_write+0xa4>
400127a4: 94 10 20 01 mov 1, %o2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
400127a8: 10 80 00 02 b 400127b0 <fat_cluster_write+0xa4>
400127ac: 94 10 20 02 mov 2, %o2
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
400127b0: 7f ff ff 1a call 40012418 <fat_buf_access>
400127b4: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
400127b8: 80 a2 20 00 cmp %o0, 0
400127bc: 12 80 00 0a bne 400127e4 <fat_cluster_write+0xd8> <== NEVER TAKEN
400127c0: 80 a6 40 08 cmp %i1, %o0
{
memcpy(blk_buf + offset, buf, bytes_to_write);
400127c4: d0 07 bf fc ld [ %fp + -4 ], %o0
400127c8: 92 07 00 11 add %i4, %l1, %o1
400127cc: 90 02 00 1a add %o0, %i2, %o0
400127d0: 40 00 22 e4 call 4001b360 <memcpy>
400127d4: 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;
400127d8: 10 80 00 14 b 40012828 <fat_cluster_write+0x11c>
400127dc: e6 2e 20 88 stb %l3, [ %i0 + 0x88 ]
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
400127e0: 80 a6 40 08 cmp %i1, %o0
400127e4: 12 80 00 06 bne 400127fc <fat_cluster_write+0xf0> <== NEVER TAKEN
400127e8: 82 10 3f ff mov -1, %g1
rc = -1;
else
{
bytes_to_write -= ret;
400127ec: b6 26 c0 19 sub %i3, %i1, %i3
bytes_written += ret;
400127f0: a2 04 40 19 add %l1, %i1, %l1
++cur_blk;
400127f4: a4 04 a0 01 inc %l2
400127f8: 82 10 20 00 clr %g1
400127fc: b4 10 20 00 clr %i2
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
40012800: 80 a6 e0 00 cmp %i3, 0
40012804: 02 80 00 04 be 40012814 <fat_cluster_write+0x108>
40012808: 80 a0 60 00 cmp %g1, 0
4001280c: 22 bf ff d2 be,a 40012754 <fat_cluster_write+0x48> <== ALWAYS TAKEN
40012810: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
40012814: 80 a0 60 00 cmp %g1, 0
40012818: 12 80 00 06 bne 40012830 <fat_cluster_write+0x124> <== NEVER TAKEN
4001281c: b0 10 3f ff mov -1, %i0
40012820: 81 c7 e0 08 ret
40012824: 91 e8 00 11 restore %g0, %l1, %o0
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
40012828: 10 bf ff ee b 400127e0 <fat_cluster_write+0xd4>
4001282c: 90 10 00 10 mov %l0, %o0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
40012830: 81 c7 e0 08 ret <== NOT EXECUTED
40012834: 81 e8 00 00 restore <== NOT EXECUTED
40011ab4 <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40011ab4: 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)
40011ab8: c2 06 60 08 ld [ %i1 + 8 ], %g1
40011abc: 80 a0 60 01 cmp %g1, 1
40011ac0: 08 80 00 05 bleu 40011ad4 <fat_file_close+0x20>
40011ac4: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
40011ac8: 90 10 20 00 clr %o0
40011acc: 10 80 00 25 b 40011b60 <fat_file_close+0xac>
40011ad0: c2 26 60 08 st %g1, [ %i1 + 8 ]
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
40011ad4: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
40011ad8: 80 88 60 01 btst 1, %g1
40011adc: 02 80 00 14 be 40011b2c <fat_file_close+0x78>
40011ae0: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
40011ae4: 92 10 00 19 mov %i1, %o1
40011ae8: 7f ff ff ae call 400119a0 <fat_file_truncate>
40011aec: 94 10 20 00 clr %o2
if ( rc != RC_OK )
40011af0: 80 a2 20 00 cmp %o0, 0
40011af4: 12 80 00 1b bne 40011b60 <fat_file_close+0xac> <== NEVER TAKEN
40011af8: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40011afc: 40 00 0e 6d call 400154b0 <_Chain_Extract>
40011b00: 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) )
40011b04: d2 06 60 0c ld [ %i1 + 0xc ], %o1
40011b08: 40 00 06 01 call 4001330c <fat_ino_is_unique>
40011b0c: 90 10 00 18 mov %i0, %o0
40011b10: 80 8a 20 ff btst 0xff, %o0
40011b14: 02 80 00 0f be 40011b50 <fat_file_close+0x9c> <== ALWAYS TAKEN
40011b18: 01 00 00 00 nop
fat_free_unique_ino(fs_info, fat_fd->ino);
40011b1c: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
40011b20: 40 00 05 f0 call 400132e0 <fat_free_unique_ino> <== NOT EXECUTED
40011b24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011b28: 30 80 00 0a b,a 40011b50 <fat_file_close+0x9c> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
40011b2c: 40 00 05 f8 call 4001330c <fat_ino_is_unique>
40011b30: d2 06 60 0c ld [ %i1 + 0xc ], %o1
40011b34: 80 8a 20 ff btst 0xff, %o0
40011b38: 02 80 00 04 be 40011b48 <fat_file_close+0x94>
40011b3c: 01 00 00 00 nop
{
fat_fd->links_num = 0;
40011b40: 10 80 00 06 b 40011b58 <fat_file_close+0xa4>
40011b44: c0 26 60 08 clr [ %i1 + 8 ]
40011b48: 40 00 0e 5a call 400154b0 <_Chain_Extract>
40011b4c: 90 10 00 19 mov %i1, %o0
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
40011b50: 7f ff cb ec call 40004b00 <free>
40011b54: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
40011b58: 40 00 01 bc call 40012248 <fat_buf_release>
40011b5c: 81 e8 00 00 restore
return rc;
}
40011b60: 81 c7 e0 08 ret
40011b64: 91 e8 00 08 restore %g0, %o0, %o0
40011c38 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
40011c38: 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;
40011c3c: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
40011c40: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
40011c44: 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;
40011c48: 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)
40011c4c: 80 a6 c0 01 cmp %i3, %g1
40011c50: 18 80 00 04 bgu 40011c60 <fat_file_extend+0x28>
40011c54: ba 10 00 18 mov %i0, %i5
return RC_OK;
40011c58: 81 c7 e0 08 ret
40011c5c: 91 e8 20 00 restore %g0, 0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40011c60: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40011c64: 80 a0 a0 01 cmp %g2, 1
40011c68: 32 80 00 0b bne,a 40011c94 <fat_file_extend+0x5c>
40011c6c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
40011c70: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40011c74: 80 a0 a0 00 cmp %g2, 0
40011c78: 32 80 00 07 bne,a 40011c94 <fat_file_extend+0x5c> <== NEVER TAKEN
40011c7c: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40011c80: 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)) &&
40011c84: 80 88 a0 03 btst 3, %g2
40011c88: 22 80 00 03 be,a 40011c94 <fat_file_extend+0x5c> <== NEVER TAKEN
40011c8c: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
40011c90: 30 80 00 34 b,a 40011d60 <fat_file_extend+0x128>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
40011c94: 84 04 3f ff add %l0, -1, %g2
40011c98: 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 -
40011c9c: a0 24 00 12 sub %l0, %l2, %l0
40011ca0: 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;
40011ca4: 84 26 c0 01 sub %i3, %g1, %g2
if (bytes2add > bytes_remain)
40011ca8: 80 a0 80 10 cmp %g2, %l0
40011cac: 08 80 00 03 bleu 40011cb8 <fat_file_extend+0x80>
40011cb0: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
40011cb4: a2 20 80 10 sub %g2, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
40011cb8: 80 a4 20 00 cmp %l0, 0
40011cbc: 02 80 00 17 be 40011d18 <fat_file_extend+0xe0>
40011cc0: 80 a4 60 00 cmp %l1, 0
40011cc4: 80 a6 a0 00 cmp %i2, 0
40011cc8: 02 80 00 14 be 40011d18 <fat_file_extend+0xe0>
40011ccc: 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;
40011cd0: 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);
40011cd4: 90 10 00 1d mov %i5, %o0
40011cd8: 92 10 00 19 mov %i1, %o1
40011cdc: 95 30 40 0a srl %g1, %o2, %o2
40011ce0: 7f ff fe 39 call 400115c4 <fat_file_lseek>
40011ce4: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40011ce8: b0 92 60 00 orcc %o1, 0, %i0
40011cec: 12 80 00 21 bne 40011d70 <fat_file_extend+0x138> <== NEVER TAKEN
40011cf0: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
40011cf4: 90 10 00 1d mov %i5, %o0
40011cf8: 94 10 00 12 mov %l2, %o2
40011cfc: 96 10 00 10 mov %l0, %o3
40011d00: 98 10 20 00 clr %o4
40011d04: 40 00 02 3a call 400125ec <fat_cluster_set>
40011d08: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
40011d0c: 80 a4 00 08 cmp %l0, %o0
40011d10: 12 80 00 18 bne 40011d70 <fat_file_extend+0x138> <== NEVER TAKEN
40011d14: 80 a4 60 00 cmp %l1, 0
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
40011d18: 02 bf ff d0 be 40011c58 <fat_file_extend+0x20>
40011d1c: a4 04 7f ff add %l1, -1, %l2
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40011d20: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40011d24: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40011d28: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40011d2c: 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;
40011d30: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40011d34: 96 07 bf fc add %fp, -4, %o3
40011d38: 94 10 00 12 mov %l2, %o2
40011d3c: 98 07 bf f8 add %fp, -8, %o4
40011d40: 40 00 1c 38 call 40018e20 <fat_scan_fat_for_free_clusters>
40011d44: 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)
40011d48: b0 92 20 00 orcc %o0, 0, %i0
40011d4c: 12 80 00 09 bne 40011d70 <fat_file_extend+0x138> <== NEVER TAKEN
40011d50: 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))
40011d54: 80 94 00 01 orcc %l0, %g1, %g0
40011d58: 12 80 00 08 bne 40011d78 <fat_file_extend+0x140> <== ALWAYS TAKEN
40011d5c: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
40011d60: 40 00 22 db call 4001a8cc <__errno>
40011d64: b0 10 3f ff mov -1, %i0
40011d68: 82 10 20 1c mov 0x1c, %g1
40011d6c: c2 22 00 00 st %g1, [ %o0 ]
40011d70: 81 c7 e0 08 ret
40011d74: 81 e8 00 00 restore
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
40011d78: 02 80 00 09 be 40011d9c <fat_file_extend+0x164> <== ALWAYS TAKEN
40011d7c: 82 24 80 01 sub %l2, %g1, %g1
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
40011d80: c4 17 60 06 lduh [ %i5 + 6 ], %g2 <== NOT EXECUTED
40011d84: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
40011d88: a2 0c 40 02 and %l1, %g2, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40011d8c: 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);
40011d90: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40011d94: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
40011d98: b6 26 c0 01 sub %i3, %g1, %i3 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
40011d9c: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
40011da0: 80 a2 e0 00 cmp %o3, 0
40011da4: 32 80 00 07 bne,a 40011dc0 <fat_file_extend+0x188>
40011da8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
40011dac: c2 07 bf f0 ld [ %fp + -16 ], %g1
fat_fd->map.file_cln = 0;
40011db0: 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;
40011db4: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
40011db8: 10 80 00 1d b 40011e2c <fat_file_extend+0x1f4>
40011dbc: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
40011dc0: 80 a0 7f ff cmp %g1, -1
40011dc4: 22 80 00 04 be,a 40011dd4 <fat_file_extend+0x19c> <== NEVER TAKEN
40011dc8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
40011dcc: 10 80 00 0c b 40011dfc <fat_file_extend+0x1c4>
40011dd0: c2 27 bf f4 st %g1, [ %fp + -12 ]
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
40011dd4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40011dd8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40011ddc: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
40011de0: 7f ff ff 62 call 40011b68 <fat_file_ioctl> <== NOT EXECUTED
40011de4: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
40011de8: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
40011dec: 02 80 00 05 be 40011e00 <fat_file_extend+0x1c8> <== NOT EXECUTED
40011df0: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
40011df4: 10 80 00 1f b 40011e70 <fat_file_extend+0x238> <== NOT EXECUTED
40011df8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
40011dfc: d2 07 bf f4 ld [ %fp + -12 ], %o1
40011e00: d4 07 bf f0 ld [ %fp + -16 ], %o2
40011e04: 40 00 1b 37 call 40018ae0 <fat_set_fat_cluster>
40011e08: 90 10 00 1d mov %i5, %o0
40011e0c: b4 10 00 08 mov %o0, %i2
if ( rc != RC_OK )
40011e10: 80 a6 a0 00 cmp %i2, 0
40011e14: 02 80 00 04 be 40011e24 <fat_file_extend+0x1ec> <== ALWAYS TAKEN
40011e18: 90 10 00 1d mov %i5, %o0
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
40011e1c: 10 80 00 16 b 40011e74 <fat_file_extend+0x23c> <== NOT EXECUTED
40011e20: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
40011e24: 40 00 01 09 call 40012248 <fat_buf_release>
40011e28: 01 00 00 00 nop
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
40011e2c: c2 07 bf fc ld [ %fp + -4 ], %g1
40011e30: 80 a0 60 00 cmp %g1, 0
40011e34: 22 80 00 14 be,a 40011e84 <fat_file_extend+0x24c> <== NEVER TAKEN
40011e38: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
40011e3c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40011e40: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
40011e44: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40011e48: 80 a0 60 00 cmp %g1, 0
40011e4c: 32 80 00 0e bne,a 40011e84 <fat_file_extend+0x24c>
40011e50: f6 27 00 00 st %i3, [ %i4 ]
{
rc = fat_init_clusters_chain(fs_info, chain);
40011e54: d2 07 bf f0 ld [ %fp + -16 ], %o1
40011e58: 40 00 04 d4 call 400131a8 <fat_init_clusters_chain>
40011e5c: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40011e60: b4 92 20 00 orcc %o0, 0, %i2
40011e64: 22 80 00 08 be,a 40011e84 <fat_file_extend+0x24c> <== ALWAYS TAKEN
40011e68: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
40011e6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011e70: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
40011e74: 40 00 1b bc call 40018d64 <fat_free_fat_clusters_chain> <== NOT EXECUTED
40011e78: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
40011e7c: 81 c7 e0 08 ret <== NOT EXECUTED
40011e80: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
*a_length = new_length;
fat_fd->fat_file_size = new_length;
40011e84: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
40011e88: 81 c7 e0 08 ret
40011e8c: 81 e8 00 00 restore
40011b68 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
40011b68: 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);
40011b6c: 82 07 a0 50 add %fp, 0x50, %g1
40011b70: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40011b74: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40011b78: 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;
40011b7c: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
40011b80: 80 a6 a0 01 cmp %i2, 1
40011b84: 12 80 00 26 bne 40011c1c <fat_file_ioctl+0xb4> <== NEVER TAKEN
40011b88: c2 27 bf fc st %g1, [ %fp + -4 ]
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
40011b8c: 82 07 a0 58 add %fp, 0x58, %g1
40011b90: c2 27 bf fc st %g1, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
40011b94: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40011b98: 80 a6 c0 01 cmp %i3, %g1
40011b9c: 0a 80 00 06 bcs 40011bb4 <fat_file_ioctl+0x4c> <== ALWAYS TAKEN
40011ba0: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
40011ba4: 40 00 23 4a call 4001a8cc <__errno> <== NOT EXECUTED
40011ba8: 01 00 00 00 nop <== NOT EXECUTED
40011bac: 10 80 00 1f b 40011c28 <fat_file_ioctl+0xc0> <== NOT EXECUTED
40011bb0: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40011bb4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40011bb8: 80 a0 60 01 cmp %g1, 1
40011bbc: 32 80 00 0d bne,a 40011bf0 <fat_file_ioctl+0x88>
40011bc0: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
40011bc4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40011bc8: 80 a0 60 00 cmp %g1, 0
40011bcc: 32 80 00 09 bne,a 40011bf0 <fat_file_ioctl+0x88> <== NEVER TAKEN
40011bd0: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40011bd4: 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)) &&
40011bd8: 80 88 60 03 btst 3, %g1
40011bdc: 22 80 00 05 be,a 40011bf0 <fat_file_ioctl+0x88>
40011be0: 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;
40011be4: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
40011be8: 81 c7 e0 08 ret
40011bec: 91 e8 20 00 restore %g0, 0, %o0
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
40011bf0: 90 10 00 18 mov %i0, %o0
40011bf4: 92 10 00 19 mov %i1, %o1
40011bf8: 95 36 c0 0a srl %i3, %o2, %o2
40011bfc: 7f ff fe 72 call 400115c4 <fat_file_lseek>
40011c00: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
40011c04: b0 92 60 00 orcc %o1, 0, %i0
40011c08: 12 80 00 03 bne 40011c14 <fat_file_ioctl+0xac> <== NEVER TAKEN
40011c0c: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
40011c10: c2 27 40 00 st %g1, [ %i5 ]
break;
40011c14: 81 c7 e0 08 ret
40011c18: 81 e8 00 00 restore
default:
errno = EINVAL;
40011c1c: 40 00 23 2c call 4001a8cc <__errno> <== NOT EXECUTED
40011c20: 01 00 00 00 nop <== NOT EXECUTED
40011c24: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40011c28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
40011c2c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
40011c30: 81 c7 e0 08 ret <== NOT EXECUTED
40011c34: 81 e8 00 00 restore <== NOT EXECUTED
400115c4 <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
400115c4: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
400115c8: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
400115cc: 80 a6 80 01 cmp %i2, %g1
400115d0: 12 80 00 05 bne 400115e4 <fat_file_lseek+0x20>
400115d4: 01 00 00 00 nop
*disk_cln = fat_fd->map.disk_cln;
400115d8: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
400115dc: 10 80 00 1b b 40011648 <fat_file_lseek+0x84>
400115e0: c2 26 c0 00 st %g1, [ %i3 ]
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
400115e4: 28 80 00 06 bleu,a 400115fc <fat_file_lseek+0x38>
400115e8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
cur_cln = fat_fd->map.disk_cln;
400115ec: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
count = file_cln - fat_fd->map.file_cln;
400115f0: b8 26 80 01 sub %i2, %g1, %i4
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
400115f4: 10 80 00 04 b 40011604 <fat_file_lseek+0x40>
400115f8: c4 27 bf fc st %g2, [ %fp + -4 ]
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
400115fc: b8 10 00 1a mov %i2, %i4
40011600: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
40011604: 10 80 00 0b b 40011630 <fat_file_lseek+0x6c>
40011608: ba 10 20 00 clr %i5
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4001160c: 90 10 00 18 mov %i0, %o0
40011610: 40 00 1c c2 call 40018918 <fat_get_fat_cluster>
40011614: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40011618: 80 a2 20 00 cmp %o0, 0
4001161c: 22 80 00 05 be,a 40011630 <fat_file_lseek+0x6c> <== ALWAYS TAKEN
40011620: ba 07 60 01 inc %i5
return rc;
40011624: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
40011628: 10 80 00 0a b 40011650 <fat_file_lseek+0x8c> <== NOT EXECUTED
4001162c: 85 3a 20 1f sra %o0, 0x1f, %g2 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
40011630: 80 a7 40 1c cmp %i5, %i4
40011634: 12 bf ff f6 bne 4001160c <fat_file_lseek+0x48>
40011638: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
4001163c: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
40011640: d2 26 60 38 st %o1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
40011644: d2 26 c0 00 st %o1, [ %i3 ]
}
return RC_OK;
40011648: 84 10 20 00 clr %g2
4001164c: 86 10 20 00 clr %g3
}
40011650: b0 10 00 02 mov %g2, %i0
40011654: 81 c7 e0 08 ret
40011658: 93 e8 00 03 restore %g0, %g3, %o1
4001165c <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4001165c: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
40011660: 90 10 00 18 mov %i0, %o0
40011664: 7f ff ff c7 call 40011580 <fat_construct_key>
40011668: 92 10 00 19 mov %i1, %o1
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
4001166c: 82 0a 20 01 and %o0, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
40011670: 85 28 60 02 sll %g1, 2, %g2
40011674: b7 28 60 04 sll %g1, 4, %i3
40011678: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
4001167c: b6 26 c0 02 sub %i3, %g2, %i3
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
40011680: b8 10 00 08 mov %o0, %i4
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
40011684: a0 00 40 1b add %g1, %i3, %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40011688: fa 00 40 1b ld [ %g1 + %i3 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
4001168c: 10 80 00 0c b 400116bc <fat_file_open+0x60>
40011690: a0 04 20 04 add %l0, 4, %l0
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
40011694: 7f ff ff bb call 40011580 <fat_construct_key>
40011698: 92 07 60 20 add %i5, 0x20, %o1
if ( (key1) == ck)
4001169c: 80 a7 00 08 cmp %i4, %o0
400116a0: 32 80 00 07 bne,a 400116bc <fat_file_open+0x60>
400116a4: fa 07 40 00 ld [ %i5 ], %i5
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
lfat_fd->links_num++;
400116a8: c2 07 60 08 ld [ %i5 + 8 ], %g1
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
400116ac: fa 26 80 00 st %i5, [ %i2 ]
lfat_fd->links_num++;
400116b0: 82 00 60 01 inc %g1
400116b4: 10 80 00 42 b 400117bc <fat_file_open+0x160>
400116b8: c2 27 60 08 st %g1, [ %i5 + 8 ]
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
400116bc: 80 a7 40 10 cmp %i5, %l0
400116c0: 12 bf ff f5 bne 40011694 <fat_file_open+0x38>
400116c4: 90 10 00 18 mov %i0, %o0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
400116c8: 10 80 00 3f b 400117c4 <fat_file_open+0x168>
400116cc: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
400116d0: 7f ff ff ac call 40011580 <fat_construct_key> <== NOT EXECUTED
400116d4: 92 07 60 20 add %i5, 0x20, %o1 <== NOT EXECUTED
if ( (key1) == ck)
400116d8: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
400116dc: 32 80 00 0a bne,a 40011704 <fat_file_open+0xa8> <== NOT EXECUTED
400116e0: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
400116e4: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
400116e8: 22 80 00 0b be,a 40011714 <fat_file_open+0xb8> <== NOT EXECUTED
400116ec: a0 10 20 00 clr %l0 <== NOT EXECUTED
400116f0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
400116f4: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
400116f8: 22 80 00 07 be,a 40011714 <fat_file_open+0xb8> <== NOT EXECUTED
400116fc: a0 10 20 00 clr %l0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
40011700: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
40011704: 80 a7 40 10 cmp %i5, %l0
40011708: 12 bf ff f2 bne 400116d0 <fat_file_open+0x74> <== NEVER TAKEN
4001170c: 90 10 00 18 mov %i0, %o0
40011710: a0 10 3f ff mov -1, %l0
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
40011714: 7f ff ce 45 call 40005028 <malloc>
40011718: 90 10 20 44 mov 0x44, %o0
4001171c: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
40011720: 80 a2 20 00 cmp %o0, 0
40011724: 02 80 00 1c be 40011794 <fat_file_open+0x138> <== NEVER TAKEN
40011728: ba 10 00 08 mov %o0, %i5
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
4001172c: 92 10 20 00 clr %o1
40011730: 40 00 27 49 call 4001b454 <memset>
40011734: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
40011738: 82 10 20 01 mov 1, %g1
4001173c: c2 27 60 08 st %g1, [ %i5 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40011740: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
40011744: 90 07 60 20 add %i5, 0x20, %o0
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40011748: 82 08 7f fe and %g1, -2, %g1
4001174c: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
40011750: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
40011754: 92 10 00 19 mov %i1, %o1
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
40011758: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
4001175c: 40 00 27 01 call 4001b360 <memcpy>
40011760: 94 10 20 10 mov 0x10, %o2
if ( rc != RC_OK )
40011764: 80 a4 20 00 cmp %l0, 0
40011768: 02 80 00 04 be 40011778 <fat_file_open+0x11c> <== NEVER TAKEN
4001176c: 01 00 00 00 nop
lfat_fd->ino = key;
40011770: 10 80 00 0f b 400117ac <fat_file_open+0x150>
40011774: f8 27 60 0c st %i4, [ %i5 + 0xc ]
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
40011778: 40 00 06 aa call 40013220 <fat_get_unique_ino> <== NOT EXECUTED
4001177c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
40011780: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40011784: 12 80 00 0a bne 400117ac <fat_file_open+0x150> <== NOT EXECUTED
40011788: d0 27 60 0c st %o0, [ %i5 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
4001178c: 7f ff cc dd call 40004b00 <free> <== NOT EXECUTED
40011790: 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 );
40011794: 40 00 24 4e call 4001a8cc <__errno> <== NOT EXECUTED
40011798: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001179c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
400117a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400117a4: 81 c7 e0 08 ret <== NOT EXECUTED
400117a8: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
400117ac: 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 );
400117b0: 92 10 00 1d mov %i5, %o1
400117b4: 7f ff e0 a4 call 40009a44 <_Chain_Append>
400117b8: 90 02 00 1b add %o0, %i3, %o0
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
400117bc: 81 c7 e0 08 ret
400117c0: 91 e8 20 00 restore %g0, 0, %o0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
400117c4: a0 00 40 1b add %g1, %i3, %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
400117c8: fa 00 40 1b ld [ %g1 + %i3 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
400117cc: 10 bf ff ce b 40011704 <fat_file_open+0xa8>
400117d0: a0 04 20 04 add %l0, 4, %l0
400117e8 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
400117e8: 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;
400117ec: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
400117f0: 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)
400117f4: 80 a6 e0 00 cmp %i3, 0
400117f8: 02 80 00 68 be 40011998 <fat_file_read+0x1b0> <== NEVER TAKEN
400117fc: 90 10 20 00 clr %o0
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
40011800: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40011804: 80 a6 80 01 cmp %i2, %g1
40011808: 1a 80 00 64 bcc 40011998 <fat_file_read+0x1b0>
4001180c: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
40011810: 38 80 00 07 bgu,a 4001182c <fat_file_read+0x44> <== NEVER TAKEN
40011814: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
40011818: 84 20 40 1b sub %g1, %i3, %g2
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
4001181c: 80 a6 80 02 cmp %i2, %g2
40011820: 28 80 00 04 bleu,a 40011830 <fat_file_read+0x48>
40011824: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
40011828: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4001182c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40011830: 80 a0 60 01 cmp %g1, 1
40011834: 32 80 00 1c bne,a 400118a4 <fat_file_read+0xbc>
40011838: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
4001183c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40011840: 80 a0 60 00 cmp %g1, 0
40011844: 32 80 00 18 bne,a 400118a4 <fat_file_read+0xbc> <== NEVER TAKEN
40011848: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4001184c: 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)) &&
40011850: 80 88 60 03 btst 3, %g1
40011854: 22 80 00 14 be,a 400118a4 <fat_file_read+0xbc>
40011858: 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);
4001185c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
40011860: 7f ff ff 3a call 40011548 <fat_cluster_num_to_sector_num>
40011864: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
40011868: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
4001186c: 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);
40011870: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
40011874: 94 02 bf ff add %o2, -1, %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
40011878: 92 02 00 09 add %o0, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, count, buf);
4001187c: 94 0e 80 0a and %i2, %o2, %o2
40011880: 90 10 00 1d mov %i5, %o0
40011884: 96 10 00 1b mov %i3, %o3
40011888: 40 00 03 13 call 400124d4 <_fat_block_read>
4001188c: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
40011890: 80 a2 20 00 cmp %o0, 0
40011894: 16 80 00 41 bge 40011998 <fat_file_read+0x1b0> <== ALWAYS TAKEN
40011898: 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;
4001189c: 10 80 00 3f b 40011998 <fat_file_read+0x1b0> <== NOT EXECUTED
400118a0: 90 10 3f ff mov -1, %o0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
400118a4: f0 17 60 06 lduh [ %i5 + 6 ], %i0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
400118a8: 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);
400118ac: a6 07 bf fc add %fp, -4, %l3
400118b0: 90 10 00 1d mov %i5, %o0
400118b4: 92 10 00 19 mov %i1, %o1
400118b8: 94 10 00 12 mov %l2, %o2
400118bc: 7f ff ff 42 call 400115c4 <fat_file_lseek>
400118c0: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
400118c4: 90 92 60 00 orcc %o1, 0, %o0
400118c8: 12 80 00 34 bne 40011998 <fat_file_read+0x1b0> <== NEVER TAKEN
400118cc: a0 10 20 00 clr %l0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
400118d0: b1 2e 20 10 sll %i0, 0x10, %i0
400118d4: b1 36 20 10 srl %i0, 0x10, %i0
400118d8: b0 06 3f ff add %i0, -1, %i0
400118dc: b4 0e 80 18 and %i2, %i0, %i2
400118e0: b0 10 20 00 clr %i0
400118e4: 10 80 00 20 b 40011964 <fat_file_read+0x17c>
400118e8: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
400118ec: a0 24 00 11 sub %l0, %l1, %l0
400118f0: 80 a4 00 1b cmp %l0, %i3
400118f4: 38 80 00 02 bgu,a 400118fc <fat_file_read+0x114>
400118f8: a0 10 00 1b mov %i3, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
400118fc: d2 07 bf fc ld [ %fp + -4 ], %o1
40011900: 7f ff ff 12 call 40011548 <fat_cluster_num_to_sector_num>
40011904: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
40011908: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
4001190c: d4 17 40 00 lduh [ %i5 ], %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
40011910: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
40011914: 94 02 bf ff add %o2, -1, %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
40011918: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4001191c: 94 0c 40 0a and %l1, %o2, %o2
40011920: 90 10 00 1d mov %i5, %o0
40011924: 96 10 00 10 mov %l0, %o3
40011928: 40 00 02 eb call 400124d4 <_fat_block_read>
4001192c: 98 07 00 18 add %i4, %i0, %o4
if ( ret < 0 )
40011930: 80 a2 20 00 cmp %o0, 0
40011934: 06 80 00 18 bl 40011994 <fat_file_read+0x1ac> <== NEVER TAKEN
40011938: b6 26 c0 10 sub %i3, %l0, %i3
return -1;
count -= c;
cmpltd += c;
4001193c: b0 06 00 10 add %i0, %l0, %i0
save_cln = cur_cln;
40011940: e0 07 bf fc ld [ %fp + -4 ], %l0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40011944: 90 10 00 1d mov %i5, %o0
40011948: 92 10 00 10 mov %l0, %o1
4001194c: 94 10 00 13 mov %l3, %o2
40011950: 40 00 1b f2 call 40018918 <fat_get_fat_cluster>
40011954: a2 10 20 00 clr %l1
if ( rc != RC_OK )
40011958: 80 a2 20 00 cmp %o0, 0
4001195c: 12 80 00 0f bne 40011998 <fat_file_read+0x1b0> <== NEVER TAKEN
40011960: 01 00 00 00 nop
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
40011964: 80 a6 e0 00 cmp %i3, 0
40011968: 32 bf ff e1 bne,a 400118ec <fat_file_read+0x104>
4001196c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
40011970: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
40011974: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
40011978: e0 26 60 38 st %l0, [ %i1 + 0x38 ]
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4001197c: b4 06 80 18 add %i2, %i0, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
40011980: 90 10 00 18 mov %i0, %o0
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
40011984: b5 36 80 01 srl %i2, %g1, %i2
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
40011988: a4 06 80 12 add %i2, %l2, %l2
4001198c: 10 80 00 03 b 40011998 <fat_file_read+0x1b0>
40011990: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
40011994: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
40011998: 81 c7 e0 08 ret
4001199c: 91 e8 00 08 restore %g0, %o0, %o0
40012110 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40012110: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
40012114: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40012118: c2 27 bf fc st %g1, [ %fp + -4 ]
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4001211c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40012120: 80 a0 60 01 cmp %g1, 1
40012124: 12 80 00 0d bne 40012158 <fat_file_size+0x48>
40012128: ba 10 00 18 mov %i0, %i5
4001212c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40012130: 80 a0 60 00 cmp %g1, 0
40012134: 32 80 00 0a bne,a 4001215c <fat_file_size+0x4c> <== NEVER TAKEN
40012138: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4001213c: 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)) &&
40012140: 80 88 60 03 btst 3, %g1
40012144: 22 80 00 06 be,a 4001215c <fat_file_size+0x4c> <== ALWAYS TAKEN
40012148: c0 26 60 18 clr [ %i1 + 0x18 ]
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
4001214c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
40012150: 10 80 00 18 b 400121b0 <fat_file_size+0xa0> <== NOT EXECUTED
40012154: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
40012158: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4001215c: 10 80 00 0d b 40012190 <fat_file_size+0x80>
40012160: 82 10 20 00 clr %g1
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40012164: 92 10 00 1c mov %i4, %o1
40012168: 40 00 19 ec call 40018918 <fat_get_fat_cluster>
4001216c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40012170: b0 92 20 00 orcc %o0, 0, %i0
40012174: 12 80 00 10 bne 400121b4 <fat_file_size+0xa4> <== NEVER TAKEN
40012178: 01 00 00 00 nop
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
4001217c: c2 17 60 06 lduh [ %i5 + 6 ], %g1
40012180: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
40012184: 82 00 80 01 add %g2, %g1, %g1
40012188: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
4001218c: 82 10 00 1c mov %i4, %g1
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40012190: f8 07 bf fc ld [ %fp + -4 ], %i4
40012194: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
40012198: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001219c: 86 0f 00 03 and %i4, %g3, %g3
400121a0: 80 a0 c0 02 cmp %g3, %g2
400121a4: 0a bf ff f0 bcs 40012164 <fat_file_size+0x54>
400121a8: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
400121ac: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
400121b0: b0 10 20 00 clr %i0
return rc;
}
400121b4: 81 c7 e0 08 ret
400121b8: 81 e8 00 00 restore
400119a0 <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
400119a0: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
400119a4: 82 10 3f ff mov -1, %g1
400119a8: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
400119ac: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
400119b0: 80 a6 80 01 cmp %i2, %g1
400119b4: 0a 80 00 04 bcs 400119c4 <fat_file_truncate+0x24>
400119b8: c0 27 bf f8 clr [ %fp + -8 ]
return rc;
400119bc: 10 80 00 3b b 40011aa8 <fat_file_truncate+0x108>
400119c0: 92 10 20 00 clr %o1
assert(fat_fd->fat_file_size);
400119c4: 80 a0 60 00 cmp %g1, 0
400119c8: 32 80 00 0a bne,a 400119f0 <fat_file_truncate+0x50> <== ALWAYS TAKEN
400119cc: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
400119d0: 11 10 00 ac sethi %hi(0x4002b000), %o0 <== NOT EXECUTED
400119d4: 15 10 00 ac sethi %hi(0x4002b000), %o2 <== NOT EXECUTED
400119d8: 17 10 00 ac sethi %hi(0x4002b000), %o3 <== NOT EXECUTED
400119dc: 90 12 22 90 or %o0, 0x290, %o0 <== NOT EXECUTED
400119e0: 92 10 22 d1 mov 0x2d1, %o1 <== NOT EXECUTED
400119e4: 94 12 a2 f0 or %o2, 0x2f0, %o2 <== NOT EXECUTED
400119e8: 7f ff cb e0 call 40004968 <__assert_func> <== NOT EXECUTED
400119ec: 96 12 e2 d8 or %o3, 0x2d8, %o3 <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
400119f0: c6 16 20 06 lduh [ %i0 + 6 ], %g3
400119f4: 86 00 ff ff add %g3, -1, %g3
400119f8: b4 00 c0 1a add %g3, %i2, %i2
400119fc: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
40011a00: 85 2e 80 02 sll %i2, %g2, %g2
40011a04: 80 a0 80 01 cmp %g2, %g1
40011a08: 1a bf ff ed bcc 400119bc <fat_file_truncate+0x1c>
40011a0c: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
40011a10: 12 80 00 0b bne 40011a3c <fat_file_truncate+0x9c>
40011a14: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
40011a18: 92 10 00 19 mov %i1, %o1
40011a1c: 94 10 00 1a mov %i2, %o2
40011a20: 7f ff fe e9 call 400115c4 <fat_file_lseek>
40011a24: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
40011a28: 80 a2 60 00 cmp %o1, 0
40011a2c: 32 80 00 20 bne,a 40011aac <fat_file_truncate+0x10c> <== NEVER TAKEN
40011a30: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
40011a34: 10 80 00 0b b 40011a60 <fat_file_truncate+0xc0>
40011a38: d2 07 bf f8 ld [ %fp + -8 ], %o1
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
if (cl_start != 0)
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
40011a3c: 92 10 00 19 mov %i1, %o1
40011a40: 94 06 bf ff add %i2, -1, %o2
40011a44: 7f ff fe e0 call 400115c4 <fat_file_lseek>
40011a48: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40011a4c: 80 a2 60 00 cmp %o1, 0
40011a50: 02 bf ff f2 be 40011a18 <fat_file_truncate+0x78> <== ALWAYS TAKEN
40011a54: 90 10 00 18 mov %i0, %o0
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
40011a58: 81 c7 e0 08 ret <== NOT EXECUTED
40011a5c: 91 e8 00 09 restore %g0, %o1, %o0 <== NOT EXECUTED
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
40011a60: 40 00 1c c1 call 40018d64 <fat_free_fat_clusters_chain>
40011a64: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
40011a68: 92 92 20 00 orcc %o0, 0, %o1
40011a6c: 12 80 00 0f bne 40011aa8 <fat_file_truncate+0x108> <== NEVER TAKEN
40011a70: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
40011a74: 02 80 00 0d be 40011aa8 <fat_file_truncate+0x108>
40011a78: 92 10 20 00 clr %o1
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
40011a7c: d2 07 bf fc ld [ %fp + -4 ], %o1
40011a80: 90 10 00 18 mov %i0, %o0
40011a84: 40 00 1c 17 call 40018ae0 <fat_set_fat_cluster>
40011a88: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
40011a8c: 92 92 20 00 orcc %o0, 0, %o1
40011a90: 12 80 00 06 bne 40011aa8 <fat_file_truncate+0x108> <== NEVER TAKEN
40011a94: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
40011a98: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
40011a9c: 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;
40011aa0: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
40011aa4: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
}
return RC_OK;
}
40011aa8: b0 10 00 09 mov %o1, %i0
40011aac: 81 c7 e0 08 ret
40011ab0: 81 e8 00 00 restore
40011e90 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40011e90: 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;
40011e94: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40011e98: 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;
40011e9c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t file_cln_initial = fat_fd->map.file_cln;
40011ea0: e6 06 60 34 ld [ %i1 + 0x34 ], %l3
uint32_t cln;
if ( count == 0 )
40011ea4: 80 a6 e0 00 cmp %i3, 0
40011ea8: 02 80 00 84 be 400120b8 <fat_file_write+0x228> <== NEVER TAKEN
40011eac: 90 10 20 00 clr %o0
return cmpltd;
if (start >= fat_fd->size_limit)
40011eb0: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
40011eb4: 80 a6 80 1d cmp %i2, %i5
40011eb8: 2a 80 00 07 bcs,a 40011ed4 <fat_file_write+0x44> <== ALWAYS TAKEN
40011ebc: ba 27 40 1a sub %i5, %i2, %i5
rtems_set_errno_and_return_minus_one(EFBIG);
40011ec0: 40 00 22 83 call 4001a8cc <__errno> <== NOT EXECUTED
40011ec4: 01 00 00 00 nop <== NOT EXECUTED
40011ec8: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b> <== NOT EXECUTED
40011ecc: 10 80 00 30 b 40011f8c <fat_file_write+0xfc> <== NOT EXECUTED
40011ed0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40011ed4: 80 a7 40 1b cmp %i5, %i3
40011ed8: 38 80 00 02 bgu,a 40011ee0 <fat_file_write+0x50> <== ALWAYS TAKEN
40011edc: ba 10 00 1b mov %i3, %i5
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
40011ee0: 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);
40011ee4: b6 07 40 1a add %i5, %i2, %i3
40011ee8: 94 40 20 00 addx %g0, 0, %o2
40011eec: 90 10 00 10 mov %l0, %o0
40011ef0: 92 10 00 19 mov %i1, %o1
40011ef4: 96 10 00 1b mov %i3, %o3
40011ef8: 7f ff ff 50 call 40011c38 <fat_file_extend>
40011efc: 98 07 bf f8 add %fp, -8, %o4
if (RC_OK == rc)
40011f00: 80 a2 20 00 cmp %o0, 0
40011f04: 12 80 00 6d bne 400120b8 <fat_file_write+0x228>
40011f08: 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))
40011f0c: 80 a0 40 1b cmp %g1, %i3
40011f10: 32 80 00 02 bne,a 40011f18 <fat_file_write+0x88> <== NEVER TAKEN
40011f14: 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));
40011f18: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
*/
if (c != (start + count))
count = c - start;
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
40011f1c: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
40011f20: 80 a0 e0 01 cmp %g3, 1
40011f24: 12 80 00 09 bne 40011f48 <fat_file_write+0xb8>
40011f28: 82 10 20 00 clr %g1
40011f2c: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
40011f30: 80 a0 e0 00 cmp %g3, 0
40011f34: 12 80 00 06 bne 40011f4c <fat_file_write+0xbc> <== NEVER TAKEN
40011f38: 80 a0 60 00 cmp %g1, 0
40011f3c: 82 08 a0 03 and %g2, 3, %g1
40011f40: 80 a0 00 01 cmp %g0, %g1
40011f44: 82 40 20 00 addx %g0, 0, %g1
*/
if (c != (start + count))
count = c - start;
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
40011f48: 80 a0 60 00 cmp %g1, 0
40011f4c: 02 80 00 12 be 40011f94 <fat_file_write+0x104>
40011f50: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
{
cln = fat_fd->cln;
40011f54: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
cln += (start >> fs_info->vol.bpc_log2);
byte = start & (fs_info->vol.bpc -1);
40011f58: 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);
40011f5c: b7 36 80 1b srl %i2, %i3, %i3
byte = start & (fs_info->vol.bpc -1);
40011f60: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
40011f64: 90 10 00 10 mov %l0, %o0
40011f68: 92 06 c0 09 add %i3, %o1, %o1
40011f6c: 94 0e 80 0a and %i2, %o2, %o2
40011f70: 96 10 00 1d mov %i5, %o3
40011f74: 98 10 00 1c mov %i4, %o4
40011f78: 40 00 01 e5 call 4001270c <fat_cluster_write>
40011f7c: 9a 10 20 00 clr %o5
cln,
byte,
count,
buf,
false);
if (0 > ret)
40011f80: 80 a2 20 00 cmp %o0, 0
40011f84: 16 80 00 4d bge 400120b8 <fat_file_write+0x228> <== ALWAYS TAKEN
40011f88: 01 00 00 00 nop
rc = -1;
40011f8c: 10 80 00 4b b 400120b8 <fat_file_write+0x228> <== NOT EXECUTED
40011f90: 90 10 3f ff mov -1, %o0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
40011f94: 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;
40011f98: b6 0e e0 ff and %i3, 0xff, %i3
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
40011f9c: aa 07 bf fc add %fp, -4, %l5
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
40011fa0: a3 36 80 1b srl %i2, %i3, %l1
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
40011fa4: 90 10 00 10 mov %l0, %o0
40011fa8: 92 10 00 19 mov %i1, %o1
40011fac: 94 10 00 11 mov %l1, %o2
40011fb0: 7f ff fd 85 call 400115c4 <fat_file_lseek>
40011fb4: 96 10 00 15 mov %l5, %o3
if (RC_OK == rc)
40011fb8: 80 a2 60 00 cmp %o1, 0
40011fbc: 12 80 00 34 bne 4001208c <fat_file_write+0x1fc> <== NEVER TAKEN
40011fc0: b7 2c 40 1b sll %l1, %i3, %i3
{
file_cln_cnt = cur_cln - fat_fd->cln;
40011fc4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40011fc8: e4 07 bf fc ld [ %fp + -4 ], %l2
40011fcc: a4 24 80 01 sub %l2, %g1, %l2
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40011fd0: 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;
40011fd4: 90 10 20 00 clr %o0
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40011fd8: b0 10 00 1a mov %i2, %i0
uint32_t ofs_cln_save = ofs_cln;
uint32_t bytes_to_write = count;
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
40011fdc: a8 10 20 00 clr %l4
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
40011fe0: ac 10 20 00 clr %l6
const uint32_t count,
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
40011fe4: 10 80 00 1a b 4001204c <fat_file_write+0x1bc>
40011fe8: b6 10 20 00 clr %i3
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
40011fec: 96 22 c0 18 sub %o3, %i0, %o3
40011ff0: 80 a2 c0 1d cmp %o3, %i5
40011ff4: 38 80 00 02 bgu,a 40011ffc <fat_file_write+0x16c>
40011ff8: 96 10 00 1d mov %i5, %o3
if (file_cln_initial < file_cln_cnt)
40011ffc: 80 a4 c0 12 cmp %l3, %l2
40012000: 2a 80 00 02 bcs,a 40012008 <fat_file_write+0x178>
40012004: a8 10 20 01 mov 1, %l4
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
40012008: d2 07 bf fc ld [ %fp + -4 ], %o1
4001200c: 90 10 00 10 mov %l0, %o0
40012010: 94 10 00 18 mov %i0, %o2
40012014: 98 07 00 1b add %i4, %i3, %o4
40012018: 40 00 01 bd call 4001270c <fat_cluster_write>
4001201c: 9a 0d 20 01 and %l4, 1, %o5
40012020: 82 10 00 08 mov %o0, %g1
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
40012024: 80 a0 60 00 cmp %g1, 0
40012028: 16 80 00 1d bge 4001209c <fat_file_write+0x20c> <== ALWAYS TAKEN
4001202c: 90 10 3f ff mov -1, %o0
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
40012030: 10 80 00 08 b 40012050 <fat_file_write+0x1c0> <== NOT EXECUTED
40012034: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40012038: 90 10 00 10 mov %l0, %o0
4001203c: 92 10 00 16 mov %l6, %o1
40012040: 40 00 1a 36 call 40018918 <fat_get_fat_cluster>
40012044: 94 10 00 15 mov %l5, %o2
ofs_cln = 0;
40012048: 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)
4001204c: 80 a7 60 00 cmp %i5, 0
40012050: 02 80 00 04 be 40012060 <fat_file_write+0x1d0>
40012054: 80 a2 20 00 cmp %o0, 0
40012058: 22 bf ff e5 be,a 40011fec <fat_file_write+0x15c> <== ALWAYS TAKEN
4001205c: d6 14 20 06 lduh [ %l0 + 6 ], %o3
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
40012060: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
40012064: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
40012068: ec 26 60 38 st %l6, [ %i1 + 0x38 ]
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4001206c: b4 06 80 1b add %i2, %i3, %i2
40012070: b5 36 80 01 srl %i2, %g1, %i2
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
40012074: a2 06 80 11 add %i2, %l1, %l1
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
}
if (RC_OK != rc)
40012078: 92 92 20 00 orcc %o0, 0, %o1
4001207c: 12 80 00 03 bne 40012088 <fat_file_write+0x1f8> <== NEVER TAKEN
40012080: e2 26 60 34 st %l1, [ %i1 + 0x34 ]
return rc;
else
return cmpltd;
40012084: 92 10 00 1b mov %i3, %o1
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
40012088: 80 a2 60 00 cmp %o1, 0
4001208c: 16 80 00 0b bge 400120b8 <fat_file_write+0x228> <== ALWAYS TAKEN
40012090: 90 10 00 09 mov %o1, %o0
40012094: 10 80 00 09 b 400120b8 <fat_file_write+0x228> <== NOT EXECUTED
40012098: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
if (0 > ret)
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
4001209c: a4 04 a0 01 inc %l2
bytes_to_write -= ret;
cmpltd += ret;
400120a0: b6 06 c0 01 add %i3, %g1, %i3
save_cln = cur_cln;
if (0 < bytes_to_write)
400120a4: ba a7 40 01 subcc %i5, %g1, %i5
400120a8: 12 bf ff e4 bne 40012038 <fat_file_write+0x1a8>
400120ac: ec 07 bf fc ld [ %fp + -4 ], %l6
400120b0: 10 bf ff e6 b 40012048 <fat_file_write+0x1b8>
400120b4: 90 10 20 00 clr %o0
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
400120b8: 81 c7 e0 08 ret
400120bc: 91 e8 00 08 restore %g0, %o0, %o0
40018d64 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
40018d64: 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;
40018d68: b8 10 20 00 clr %i4
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
40018d6c: ba 10 00 18 mov %i0, %i5
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
40018d70: c0 27 bf fc clr [ %fp + -4 ]
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
40018d74: b6 10 00 19 mov %i1, %i3
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40018d78: 10 80 00 19 b 40018ddc <fat_free_fat_clusters_chain+0x78>
40018d7c: b4 10 20 00 clr %i2
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
40018d80: 92 10 00 1b mov %i3, %o1
40018d84: 7f ff fe e5 call 40018918 <fat_get_fat_cluster>
40018d88: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40018d8c: b0 92 20 00 orcc %o0, 0, %i0
40018d90: 02 80 00 0b be 40018dbc <fat_free_fat_clusters_chain+0x58><== ALWAYS TAKEN
40018d94: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
40018d98: c2 07 60 44 ld [ %i5 + 0x44 ], %g1 <== NOT EXECUTED
40018d9c: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
40018da0: 02 80 00 03 be 40018dac <fat_free_fat_clusters_chain+0x48><== NOT EXECUTED
40018da4: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
40018da8: f8 27 60 44 st %i4, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
40018dac: 7f ff e5 27 call 40012248 <fat_buf_release> <== NOT EXECUTED
40018db0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018db4: 81 c7 e0 08 ret <== NOT EXECUTED
40018db8: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
40018dbc: 92 10 00 1b mov %i3, %o1
40018dc0: 7f ff ff 48 call 40018ae0 <fat_set_fat_cluster>
40018dc4: 94 10 20 00 clr %o2
if ( rc != RC_OK )
40018dc8: 80 a2 20 00 cmp %o0, 0
40018dcc: 32 80 00 02 bne,a 40018dd4 <fat_free_fat_clusters_chain+0x70><== NEVER TAKEN
40018dd0: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
40018dd4: f6 07 bf fc ld [ %fp + -4 ], %i3
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
40018dd8: b8 07 20 01 inc %i4
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40018ddc: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
40018de0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40018de4: 84 0e c0 02 and %i3, %g2, %g2
40018de8: 80 a0 80 01 cmp %g2, %g1
40018dec: 0a bf ff e5 bcs 40018d80 <fat_free_fat_clusters_chain+0x1c>
40018df0: 90 10 00 1d mov %i5, %o0
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
40018df4: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
40018df8: 80 a0 7f ff cmp %g1, -1
40018dfc: 02 80 00 05 be 40018e10 <fat_free_fat_clusters_chain+0xac><== ALWAYS TAKEN
40018e00: f2 27 60 4c st %i1, [ %i5 + 0x4c ]
fs_info->vol.free_cls += freed_cls_cnt;
40018e04: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
40018e08: f8 27 60 44 st %i4, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
40018e0c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018e10: 7f ff e5 0e call 40012248 <fat_buf_release>
40018e14: b0 10 00 1a mov %i2, %i0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
40018e18: 81 c7 e0 08 ret
40018e1c: 81 e8 00 00 restore
400132e0 <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);
400132e0: c2 02 20 80 ld [ %o0 + 0x80 ], %g1 <== NOT EXECUTED
400132e4: c4 02 20 74 ld [ %o0 + 0x74 ], %g2 <== NOT EXECUTED
400132e8: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
400132ec: 92 22 40 01 sub %o1, %g1, %o1 <== NOT EXECUTED
400132f0: 83 32 60 03 srl %o1, 3, %g1 <== NOT EXECUTED
400132f4: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
400132f8: 93 28 c0 09 sll %g3, %o1, %o1 <== NOT EXECUTED
400132fc: c6 08 80 01 ldub [ %g2 + %g1 ], %g3 <== NOT EXECUTED
40013300: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
40013304: 81 c3 e0 08 retl <== NOT EXECUTED
40013308: d2 28 80 01 stb %o1, [ %g2 + %g1 ] <== NOT EXECUTED
40018918 <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
40018918: 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)) )
4001891c: 80 a6 60 01 cmp %i1, 1
40018920: 08 80 00 67 bleu 40018abc <fat_get_fat_cluster+0x1a4> <== NEVER TAKEN
40018924: ba 10 00 18 mov %i0, %i5
40018928: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001892c: 82 00 60 01 inc %g1
40018930: 80 a6 40 01 cmp %i1, %g1
40018934: 28 80 00 03 bleu,a 40018940 <fat_get_fat_cluster+0x28> <== ALWAYS TAKEN
40018938: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001893c: 30 80 00 60 b,a 40018abc <fat_get_fat_cluster+0x1a4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
40018940: 86 08 60 01 and %g1, 1, %g3
40018944: 80 88 e0 ff btst 0xff, %g3
40018948: 02 80 00 05 be 4001895c <fat_get_fat_cluster+0x44>
4001894c: 88 08 60 02 and %g1, 2, %g4
40018950: 85 36 60 01 srl %i1, 1, %g2
40018954: 10 80 00 06 b 4001896c <fat_get_fat_cluster+0x54>
40018958: 84 00 80 19 add %g2, %i1, %g2
4001895c: 80 89 20 ff btst 0xff, %g4
40018960: 02 80 00 03 be 4001896c <fat_get_fat_cluster+0x54>
40018964: 85 2e 60 02 sll %i1, 2, %g2
40018968: 85 2e 60 01 sll %i1, 1, %g2
4001896c: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
40018970: c8 07 60 58 ld [ %i5 + 0x58 ], %g4
40018974: 85 30 80 1b srl %g2, %i3, %g2
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
40018978: 80 88 e0 ff btst 0xff, %g3
4001897c: 02 80 00 05 be 40018990 <fat_get_fat_cluster+0x78>
40018980: b6 00 80 04 add %g2, %g4, %i3
40018984: b9 36 60 01 srl %i1, 1, %i4
40018988: 10 80 00 07 b 400189a4 <fat_get_fat_cluster+0x8c>
4001898c: b8 07 00 19 add %i4, %i1, %i4
40018990: 82 08 60 02 and %g1, 2, %g1
40018994: 80 88 60 ff btst 0xff, %g1
40018998: 02 80 00 03 be 400189a4 <fat_get_fat_cluster+0x8c>
4001899c: b9 2e 60 02 sll %i1, 2, %i4
400189a0: b9 2e 60 01 sll %i1, 1, %i4
400189a4: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
400189a8: 90 10 00 1d mov %i5, %o0
400189ac: 92 10 00 1b mov %i3, %o1
400189b0: 94 10 20 01 mov 1, %o2
400189b4: 7f ff e6 99 call 40012418 <fat_buf_access>
400189b8: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
400189bc: b0 92 20 00 orcc %o0, 0, %i0
400189c0: 12 80 00 37 bne 40018a9c <fat_get_fat_cluster+0x184> <== NEVER TAKEN
400189c4: 83 2c 20 10 sll %l0, 0x10, %g1
return rc;
switch ( fs_info->vol.type )
400189c8: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
400189cc: 80 a0 a0 02 cmp %g2, 2
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
400189d0: 83 30 60 10 srl %g1, 0x10, %g1
400189d4: 82 00 7f ff add %g1, -1, %g1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
400189d8: 02 80 00 27 be 40018a74 <fat_get_fat_cluster+0x15c>
400189dc: 82 0f 00 01 and %i4, %g1, %g1
400189e0: 80 a0 a0 04 cmp %g2, 4
400189e4: 02 80 00 30 be 40018aa4 <fat_get_fat_cluster+0x18c>
400189e8: 80 a0 a0 01 cmp %g2, 1
400189ec: 12 80 00 34 bne 40018abc <fat_get_fat_cluster+0x1a4> <== NEVER TAKEN
400189f0: c6 07 bf fc ld [ %fp + -4 ], %g3
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
400189f4: c8 17 40 00 lduh [ %i5 ], %g4
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
400189f8: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
if ( ofs == (fs_info->vol.bps - 1) )
400189fc: 88 01 3f ff add %g4, -1, %g4
40018a00: 80 a0 40 04 cmp %g1, %g4
40018a04: 12 80 00 10 bne 40018a44 <fat_get_fat_cluster+0x12c> <== ALWAYS TAKEN
40018a08: c4 26 80 00 st %g2, [ %i2 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
40018a0c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018a10: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
40018a14: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40018a18: 7f ff e6 80 call 40012418 <fat_buf_access> <== NOT EXECUTED
40018a1c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
40018a20: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40018a24: 12 80 00 2c bne 40018ad4 <fat_get_fat_cluster+0x1bc> <== NOT EXECUTED
40018a28: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
40018a2c: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
40018a30: c2 08 40 00 ldub [ %g1 ], %g1 <== NOT EXECUTED
40018a34: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
40018a38: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
40018a3c: 10 80 00 07 b 40018a58 <fat_get_fat_cluster+0x140> <== NOT EXECUTED
40018a40: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
40018a44: 82 00 c0 01 add %g3, %g1, %g1
40018a48: c2 08 60 01 ldub [ %g1 + 1 ], %g1
40018a4c: 83 28 60 08 sll %g1, 8, %g1
40018a50: 84 10 40 02 or %g1, %g2, %g2
40018a54: c4 26 80 00 st %g2, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
40018a58: 80 8e 60 01 btst 1, %i1
40018a5c: 02 80 00 04 be 40018a6c <fat_get_fat_cluster+0x154>
40018a60: c2 06 80 00 ld [ %i2 ], %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
40018a64: 10 80 00 0d b 40018a98 <fat_get_fat_cluster+0x180>
40018a68: 83 30 60 04 srl %g1, 4, %g1
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
40018a6c: 10 80 00 0b b 40018a98 <fat_get_fat_cluster+0x180>
40018a70: 82 08 6f ff and %g1, 0xfff, %g1
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
40018a74: c4 07 bf fc ld [ %fp + -4 ], %g2
*ret_val = CF_LE_W(*ret_val);
40018a78: 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));
40018a7c: c2 10 80 01 lduh [ %g2 + %g1 ], %g1
*ret_val = CF_LE_W(*ret_val);
40018a80: 86 10 e3 ff or %g3, 0x3ff, %g3
40018a84: 83 28 60 10 sll %g1, 0x10, %g1
40018a88: 85 30 60 18 srl %g1, 0x18, %g2
40018a8c: 83 30 60 08 srl %g1, 8, %g1
40018a90: 82 08 40 03 and %g1, %g3, %g1
40018a94: 82 10 80 01 or %g2, %g1, %g1
40018a98: c2 26 80 00 st %g1, [ %i2 ]
break;
40018a9c: 81 c7 e0 08 ret
40018aa0: 81 e8 00 00 restore
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
40018aa4: c4 07 bf fc ld [ %fp + -4 ], %g2
40018aa8: 7f ff ff 90 call 400188e8 <CPU_swap_u32>
40018aac: d0 00 80 01 ld [ %g2 + %g1 ], %o0
40018ab0: d0 26 80 00 st %o0, [ %i2 ]
break;
40018ab4: 81 c7 e0 08 ret
40018ab8: 81 e8 00 00 restore
default:
rtems_set_errno_and_return_minus_one(EIO);
40018abc: 40 00 07 84 call 4001a8cc <__errno> <== NOT EXECUTED
40018ac0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40018ac4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40018ac8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40018acc: 81 c7 e0 08 ret <== NOT EXECUTED
40018ad0: 81 e8 00 00 restore <== NOT EXECUTED
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
40018ad4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
40018ad8: 81 c7 e0 08 ret <== NOT EXECUTED
40018adc: 81 e8 00 00 restore <== NOT EXECUTED
40013220 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
40013220: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
40013224: 39 03 ff ff sethi %hi(0xffffc00), %i4 <== NOT EXECUTED
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
40013228: 10 80 00 2b b 400132d4 <fat_get_unique_ino+0xb4> <== NOT EXECUTED
4001322c: b8 17 23 ff or %i4, 0x3ff, %i4 ! fffffff <RAM_SIZE+0xfbfffff><== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
40013230: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
40013234: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
40013238: b6 00 c0 02 add %g3, %g2, %i3 <== NOT EXECUTED
4001323c: f4 08 c0 02 ldub [ %g3 + %g2 ], %i2 <== NOT EXECUTED
40013240: c4 48 c0 02 ldsb [ %g3 + %g2 ], %g2 <== NOT EXECUTED
40013244: ba 08 60 07 and %g1, 7, %i5 <== NOT EXECUTED
40013248: 85 38 80 1d sra %g2, %i5, %g2 <== NOT EXECUTED
4001324c: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
40013250: 12 80 00 0a bne 40013278 <fat_get_unique_ino+0x58> <== NOT EXECUTED
40013254: 82 00 60 01 inc %g1 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
40013258: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001325c: bb 28 40 1d sll %g1, %i5, %i5 <== NOT EXECUTED
40013260: ba 17 40 1a or %i5, %i2, %i5 <== NOT EXECUTED
40013264: fa 2e c0 00 stb %i5, [ %i3 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
40013268: c4 06 20 78 ld [ %i0 + 0x78 ], %g2 <== NOT EXECUTED
4001326c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40013270: 81 c7 e0 08 ret <== NOT EXECUTED
40013274: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
40013278: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
4001327c: 3a 80 00 03 bcc,a 40013288 <fat_get_unique_ino+0x68> <== NOT EXECUTED
40013280: c0 26 20 78 clr [ %i0 + 0x78 ] <== NOT EXECUTED
40013284: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
40013288: 92 02 60 01 inc %o1 <== NOT EXECUTED
4001328c: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
40013290: 32 bf ff e8 bne,a 40013230 <fat_get_unique_ino+0x10> <== NOT EXECUTED
40013294: c6 06 20 74 ld [ %i0 + 0x74 ], %g3 <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
40013298: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
4001329c: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
400132a0: 82 27 00 01 sub %i4, %g1, %g1 <== NOT EXECUTED
400132a4: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
400132a8: 2a 80 00 04 bcs,a 400132b8 <fat_get_unique_ino+0x98> <== NOT EXECUTED
400132ac: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
400132b0: 81 c7 e0 08 ret <== NOT EXECUTED
400132b4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
400132b8: 7f ff c9 fe call 40005ab0 <realloc> <== NOT EXECUTED
400132bc: d2 26 20 7c st %o1, [ %i0 + 0x7c ] <== NOT EXECUTED
if (fs_info->uino != NULL)
400132c0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400132c4: 02 bf ff fb be 400132b0 <fat_get_unique_ino+0x90> <== NOT EXECUTED
400132c8: d0 26 20 74 st %o0, [ %i0 + 0x74 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
400132cc: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED
400132d0: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
400132d4: c8 06 20 7c ld [ %i0 + 0x7c ], %g4 <== NOT EXECUTED
400132d8: 10 bf ff ed b 4001328c <fat_get_unique_ino+0x6c> <== NOT EXECUTED
400132dc: 92 10 20 00 clr %o1 <== NOT EXECUTED
400131a8 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
400131a8: 9d e3 bf 98 save %sp, -104, %sp
400131ac: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
400131b0: 10 80 00 10 b 400131f0 <fat_init_clusters_chain+0x48>
400131b4: f2 27 bf fc st %i1, [ %fp + -4 ]
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
400131b8: 90 10 00 1d mov %i5, %o0
400131bc: 94 10 20 00 clr %o2
400131c0: 7f ff fd 0b call 400125ec <fat_cluster_set>
400131c4: 98 10 20 00 clr %o4
if ( ret != fs_info->vol.bpc )
400131c8: c2 17 60 06 lduh [ %i5 + 6 ], %g1
400131cc: 80 a2 00 01 cmp %o0, %g1
400131d0: 12 80 00 11 bne 40013214 <fat_init_clusters_chain+0x6c> <== NEVER TAKEN
400131d4: d2 07 bf fc ld [ %fp + -4 ], %o1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
400131d8: 90 10 00 1d mov %i5, %o0
400131dc: 40 00 15 cf call 40018918 <fat_get_fat_cluster>
400131e0: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
400131e4: b0 92 20 00 orcc %o0, 0, %i0
400131e8: 12 80 00 0c bne 40013218 <fat_init_clusters_chain+0x70> <== NEVER TAKEN
400131ec: 01 00 00 00 nop
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
400131f0: d2 07 bf fc ld [ %fp + -4 ], %o1
400131f4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
400131f8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400131fc: 84 0a 40 02 and %o1, %g2, %g2
40013200: 80 a0 80 01 cmp %g2, %g1
40013204: 2a bf ff ed bcs,a 400131b8 <fat_init_clusters_chain+0x10>
40013208: d6 17 60 06 lduh [ %i5 + 6 ], %o3
return rc;
}
}
return rc;
4001320c: 81 c7 e0 08 ret
40013210: 91 e8 20 00 restore %g0, 0, %o0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
if ( ret != fs_info->vol.bpc )
{
return -1;
40013214: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
}
return rc;
}
40013218: 81 c7 e0 08 ret <== NOT EXECUTED
4001321c: 81 e8 00 00 restore <== NOT EXECUTED
40012838 <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)
{
40012838: 9d e3 bf 08 save %sp, -248, %sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
4001283c: 92 10 20 02 mov 2, %o1
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
40012840: b6 10 00 18 mov %i0, %i3
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
40012844: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
40012848: 7f ff cb ff call 40005844 <open>
4001284c: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
40012850: 80 a2 20 00 cmp %o0, 0
40012854: 06 80 00 17 bl 400128b0 <fat_init_volume_info+0x78> <== NEVER TAKEN
40012858: d0 26 e0 60 st %o0, [ %i3 + 0x60 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
4001285c: 7f ff c8 d3 call 40004ba8 <fstat>
40012860: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
40012864: 80 a2 20 00 cmp %o0, 0
40012868: 12 80 00 10 bne 400128a8 <fat_init_volume_info+0x70> <== NEVER TAKEN
4001286c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
40012870: c6 07 bf c4 ld [ %fp + -60 ], %g3
40012874: 05 00 00 3c sethi %hi(0xf000), %g2
40012878: 86 08 c0 02 and %g3, %g2, %g3
4001287c: 05 00 00 18 sethi %hi(0x6000), %g2
40012880: 80 a0 c0 02 cmp %g3, %g2
40012884: 12 80 00 09 bne 400128a8 <fat_init_volume_info+0x70> <== NEVER TAKEN
40012888: 13 10 01 10 sethi %hi(0x40044000), %o1
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4001288c: 94 06 20 64 add %i0, 0x64, %o2
40012890: 40 00 05 5e call 40013e08 <ioctl>
40012894: 92 12 62 09 or %o1, 0x209, %o1
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* check that device is registred as block device and lock it */
rc = rtems_disk_fd_get_disk_device(vol->fd, &vol->dd);
if (rc != 0) {
40012898: 80 a2 20 00 cmp %o0, 0
4001289c: 22 80 00 09 be,a 400128c0 <fat_init_volume_info+0x88> <== ALWAYS TAKEN
400128a0: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
close(vol->fd);
400128a4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
400128a8: 7f ff c8 75 call 40004a7c <close> <== NOT EXECUTED
400128ac: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
400128b0: 40 00 20 07 call 4001a8cc <__errno> <== NOT EXECUTED
400128b4: 01 00 00 00 nop <== NOT EXECUTED
400128b8: 10 80 01 af b 40012f74 <fat_init_volume_info+0x73c> <== NOT EXECUTED
400128bc: 82 10 20 06 mov 6, %g1 ! 6 <PROM_START+0x6> <== NOT EXECUTED
}
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
400128c0: 92 10 20 00 clr %o1
400128c4: 7f ff f6 9a call 4001032c <rtems_bdbuf_read>
400128c8: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
400128cc: 80 a2 20 00 cmp %o0, 0
400128d0: 22 80 00 03 be,a 400128dc <fat_init_volume_info+0xa4> <== ALWAYS TAKEN
400128d4: d0 07 bf a4 ld [ %fp + -92 ], %o0
400128d8: 30 80 00 32 b,a 400129a0 <fat_init_volume_info+0x168> <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
400128dc: c6 02 20 1c ld [ %o0 + 0x1c ], %g3
400128e0: c2 08 e0 20 ldub [ %g3 + 0x20 ], %g1
400128e4: c4 08 e0 0b ldub [ %g3 + 0xb ], %g2
400128e8: c2 2f bf 9a stb %g1, [ %fp + -102 ]
400128ec: c2 08 e0 22 ldub [ %g3 + 0x22 ], %g1
400128f0: d2 08 e0 0c ldub [ %g3 + 0xc ], %o1
400128f4: c2 2f bf 9b stb %g1, [ %fp + -101 ]
400128f8: c2 08 e0 23 ldub [ %g3 + 0x23 ], %g1
400128fc: d8 08 e0 0e ldub [ %g3 + 0xe ], %o4
40012900: c2 2f bf 8f stb %g1, [ %fp + -113 ]
40012904: c2 08 e0 2c ldub [ %g3 + 0x2c ], %g1
40012908: d6 08 e0 0f ldub [ %g3 + 0xf ], %o3
4001290c: c2 2f bf 9e stb %g1, [ %fp + -98 ]
40012910: c2 08 e0 2d ldub [ %g3 + 0x2d ], %g1
40012914: c8 08 e0 11 ldub [ %g3 + 0x11 ], %g4
40012918: c2 2f bf 9d stb %g1, [ %fp + -99 ]
4001291c: c2 08 e0 2e ldub [ %g3 + 0x2e ], %g1
40012920: da 08 e0 12 ldub [ %g3 + 0x12 ], %o5
40012924: c2 2f bf 9c stb %g1, [ %fp + -100 ]
40012928: c2 08 e0 2f ldub [ %g3 + 0x2f ], %g1
4001292c: fa 08 e0 0d ldub [ %g3 + 0xd ], %i5
40012930: f4 08 e0 10 ldub [ %g3 + 0x10 ], %i2
40012934: e2 08 e0 13 ldub [ %g3 + 0x13 ], %l1
40012938: e4 08 e0 14 ldub [ %g3 + 0x14 ], %l2
4001293c: ee 08 e0 16 ldub [ %g3 + 0x16 ], %l7
40012940: f0 08 e0 17 ldub [ %g3 + 0x17 ], %i0
40012944: e0 08 e0 21 ldub [ %g3 + 0x21 ], %l0
40012948: e8 08 e0 24 ldub [ %g3 + 0x24 ], %l4
4001294c: ec 08 e0 25 ldub [ %g3 + 0x25 ], %l6
40012950: ea 08 e0 26 ldub [ %g3 + 0x26 ], %l5
40012954: e6 08 e0 27 ldub [ %g3 + 0x27 ], %l3
40012958: f8 08 e0 28 ldub [ %g3 + 0x28 ], %i4
4001295c: c2 2f bf 97 stb %g1, [ %fp + -105 ]
40012960: c2 08 e0 30 ldub [ %g3 + 0x30 ], %g1
40012964: f2 08 e0 31 ldub [ %g3 + 0x31 ], %i1
40012968: c2 2f bf 9f stb %g1, [ %fp + -97 ]
sc = rtems_bdbuf_release( block);
4001296c: c4 27 bf 80 st %g2, [ %fp + -128 ]
40012970: c8 27 bf 7c st %g4, [ %fp + -132 ]
40012974: d2 27 bf 78 st %o1, [ %fp + -136 ]
40012978: d6 27 bf 74 st %o3, [ %fp + -140 ]
4001297c: 7f ff f6 e8 call 4001051c <rtems_bdbuf_release>
40012980: d8 3f bf 68 std %o4, [ %fp + -152 ]
if (sc != RTEMS_SUCCESSFUL)
40012984: c4 07 bf 80 ld [ %fp + -128 ], %g2
40012988: 80 a2 20 00 cmp %o0, 0
4001298c: c8 07 bf 7c ld [ %fp + -132 ], %g4
40012990: d2 07 bf 78 ld [ %fp + -136 ], %o1
40012994: d6 07 bf 74 ld [ %fp + -140 ], %o3
40012998: 02 80 00 08 be 400129b8 <fat_init_volume_info+0x180> <== ALWAYS TAKEN
4001299c: d8 1f bf 68 ldd [ %fp + -152 ], %o4
{
close(vol->fd);
400129a0: 7f ff c8 37 call 40004a7c <close> <== NOT EXECUTED
400129a4: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
400129a8: 40 00 1f c9 call 4001a8cc <__errno> <== NOT EXECUTED
400129ac: 01 00 00 00 nop <== NOT EXECUTED
400129b0: 10 80 01 71 b 40012f74 <fat_init_volume_info+0x73c> <== NOT EXECUTED
400129b4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
400129b8: 84 08 a0 ff and %g2, 0xff, %g2
400129bc: 92 0a 60 ff and %o1, 0xff, %o1
400129c0: 93 2a 60 08 sll %o1, 8, %o1
400129c4: 92 12 40 02 or %o1, %g2, %o1
400129c8: d2 36 c0 00 sth %o1, [ %i3 ]
if ( (vol->bps != 512) &&
400129cc: 85 2a 60 10 sll %o1, 0x10, %g2
400129d0: 85 30 a0 10 srl %g2, 0x10, %g2
400129d4: 80 a0 a4 00 cmp %g2, 0x400
400129d8: 02 80 00 0c be 40012a08 <fat_init_volume_info+0x1d0> <== NEVER TAKEN
400129dc: 86 10 00 09 mov %o1, %g3
400129e0: 80 a0 a2 00 cmp %g2, 0x200
400129e4: 22 80 00 0a be,a 40012a0c <fat_init_volume_info+0x1d4> <== ALWAYS TAKEN
400129e8: 85 2a 60 10 sll %o1, 0x10, %g2
(vol->bps != 1024) &&
400129ec: 80 a0 a8 00 cmp %g2, 0x800 <== NOT EXECUTED
400129f0: 02 80 00 06 be 40012a08 <fat_init_volume_info+0x1d0> <== NOT EXECUTED
400129f4: 1f 00 00 04 sethi %hi(0x1000), %o7 <== NOT EXECUTED
(vol->bps != 2048) &&
400129f8: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
400129fc: 02 80 00 04 be 40012a0c <fat_init_volume_info+0x1d4> <== NOT EXECUTED
40012a00: 85 2a 60 10 sll %o1, 0x10, %g2 <== NOT EXECUTED
40012a04: 30 80 00 d6 b,a 40012d5c <fat_init_volume_info+0x524> <== NOT EXECUTED
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40012a08: 85 2a 60 10 sll %o1, 0x10, %g2 <== NOT EXECUTED
40012a0c: c0 2e e0 03 clrb [ %i3 + 3 ]
40012a10: 10 80 00 05 b 40012a24 <fat_init_volume_info+0x1ec>
40012a14: 85 30 a0 19 srl %g2, 0x19, %g2
i >>= 1, vol->sec_mul++);
40012a18: 85 38 a0 01 sra %g2, 1, %g2 <== NOT EXECUTED
40012a1c: 9e 03 e0 01 inc %o7 <== NOT EXECUTED
40012a20: de 2e e0 03 stb %o7, [ %i3 + 3 ] <== NOT EXECUTED
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40012a24: 80 88 a0 01 btst 1, %g2
40012a28: 22 bf ff fc be,a 40012a18 <fat_init_volume_info+0x1e0> <== NEVER TAKEN
40012a2c: de 0e e0 03 ldub [ %i3 + 3 ], %o7 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
40012a30: 93 2a 60 10 sll %o1, 0x10, %o1
40012a34: c0 2e e0 02 clrb [ %i3 + 2 ]
40012a38: 93 32 60 10 srl %o1, 0x10, %o1
40012a3c: 10 80 00 05 b 40012a50 <fat_init_volume_info+0x218>
40012a40: 9e 10 00 09 mov %o1, %o7
i >>= 1, vol->sec_log2++);
40012a44: 84 00 a0 01 inc %g2
40012a48: 9f 3b e0 01 sra %o7, 1, %o7
40012a4c: c4 2e e0 02 stb %g2, [ %i3 + 2 ]
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
40012a50: 80 8b e0 01 btst 1, %o7
40012a54: 02 bf ff fc be 40012a44 <fat_init_volume_info+0x20c>
40012a58: c4 0e e0 02 ldub [ %i3 + 2 ], %g2
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
40012a5c: c6 36 e0 0a sth %g3, [ %i3 + 0xa ]
vol->bytes_per_block_log2 = vol->sec_log2;
40012a60: c4 2e e0 0c stb %g2, [ %i3 + 0xc ]
vol->sectors_per_block = 1;
40012a64: 86 10 20 01 mov 1, %g3
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
40012a68: fa 2e e0 04 stb %i5, [ %i3 + 4 ]
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
40012a6c: 9e 8f 60 ff andcc %i5, 0xff, %o7
40012a70: 02 80 00 bb be 40012d5c <fat_init_volume_info+0x524> <== NEVER TAKEN
40012a74: c6 2e e0 09 stb %g3, [ %i3 + 9 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
40012a78: 10 80 00 05 b 40012a8c <fat_init_volume_info+0x254>
40012a7c: c0 2e e0 05 clrb [ %i3 + 5 ]
i >>= 1, vol->spc_log2++);
40012a80: 86 00 e0 01 inc %g3
40012a84: 9f 3b e0 01 sra %o7, 1, %o7
40012a88: c6 2e e0 05 stb %g3, [ %i3 + 5 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
40012a8c: 80 8b e0 01 btst 1, %o7
40012a90: 02 bf ff fc be 40012a80 <fat_init_volume_info+0x248>
40012a94: c6 0e e0 05 ldub [ %i3 + 5 ], %g3
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
40012a98: 87 2a 40 03 sll %o1, %g3, %g3
40012a9c: 95 28 e0 10 sll %g3, 0x10, %o2
40012aa0: 1f 20 00 00 sethi %hi(0x80000000), %o7
40012aa4: 80 a2 80 0f cmp %o2, %o7
40012aa8: 18 80 00 ad bgu 40012d5c <fat_init_volume_info+0x524> <== NEVER TAKEN
40012aac: c6 36 e0 06 sth %g3, [ %i3 + 6 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
40012ab0: 1f 00 00 3f sethi %hi(0xfc00), %o7
40012ab4: c0 2e e0 08 clrb [ %i3 + 8 ]
40012ab8: 9e 13 e3 ff or %o7, 0x3ff, %o7
40012abc: 10 80 00 05 b 40012ad0 <fat_init_volume_info+0x298>
40012ac0: 86 08 c0 0f and %g3, %o7, %g3
i >>= 1, vol->bpc_log2++);
40012ac4: 87 38 e0 01 sra %g3, 1, %g3
40012ac8: 9e 03 e0 01 inc %o7
40012acc: de 2e e0 08 stb %o7, [ %i3 + 8 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
40012ad0: 80 88 e0 01 btst 1, %g3
40012ad4: 22 bf ff fc be,a 40012ac4 <fat_init_volume_info+0x28c>
40012ad8: de 0e e0 08 ldub [ %i3 + 8 ], %o7
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
40012adc: f4 2e e0 0d stb %i2, [ %i3 + 0xd ]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40012ae0: 86 02 7f ff add %o1, -1, %g3
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
40012ae4: 96 0a e0 ff and %o3, 0xff, %o3
40012ae8: 98 0b 20 ff and %o4, 0xff, %o4
40012aec: 97 2a e0 08 sll %o3, 8, %o3
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40012af0: 9a 0b 60 ff and %o5, 0xff, %o5
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
40012af4: 98 12 c0 0c or %o3, %o4, %o4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40012af8: 9b 2b 60 08 sll %o5, 8, %o5
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
40012afc: d8 36 e0 18 sth %o4, [ %i3 + 0x18 ]
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40012b00: 88 09 20 ff and %g4, 0xff, %g4
40012b04: 88 13 40 04 or %o5, %g4, %g4
40012b08: c8 36 e0 24 sth %g4, [ %i3 + 0x24 ]
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40012b0c: 89 29 20 10 sll %g4, 0x10, %g4
40012b10: c4 27 bf 80 st %g2, [ %fp + -128 ]
40012b14: 91 31 20 0b srl %g4, 0xb, %o0
40012b18: d8 27 bf 68 st %o4, [ %fp + -152 ]
40012b1c: 7f ff bf 09 call 40002740 <.div>
40012b20: 90 02 00 03 add %o0, %g3, %o0
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
40012b24: c4 07 bf 80 ld [ %fp + -128 ], %g2
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40012b28: d0 26 e0 28 st %o0, [ %i3 + 0x28 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
40012b2c: 85 2a 00 02 sll %o0, %g2, %g2
40012b30: c4 26 e0 2c st %g2, [ %i3 + 0x2c ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
40012b34: b0 0e 20 ff and %i0, 0xff, %i0
40012b38: ae 0d e0 ff and %l7, 0xff, %l7
40012b3c: b1 2e 20 08 sll %i0, 8, %i0
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40012b40: 86 10 00 08 mov %o0, %g3
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
40012b44: ae 16 00 17 or %i0, %l7, %l7
40012b48: af 2d e0 10 sll %l7, 0x10, %l7
40012b4c: 80 a5 e0 00 cmp %l7, 0
40012b50: 02 80 00 05 be 40012b64 <fat_init_volume_info+0x32c>
40012b54: d8 07 bf 68 ld [ %fp + -152 ], %o4
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
40012b58: af 35 e0 10 srl %l7, 0x10, %l7
40012b5c: 10 80 00 0c b 40012b8c <fat_init_volume_info+0x354>
40012b60: ee 26 e0 1c st %l7, [ %i3 + 0x1c ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
40012b64: ac 0d a0 ff and %l6, 0xff, %l6
40012b68: aa 0d 60 ff and %l5, 0xff, %l5
40012b6c: ad 2d a0 08 sll %l6, 8, %l6
40012b70: ab 2d 60 10 sll %l5, 0x10, %l5
40012b74: a8 0d 20 ff and %l4, 0xff, %l4
40012b78: aa 15 80 15 or %l6, %l5, %l5
40012b7c: a7 2c e0 18 sll %l3, 0x18, %l3
40012b80: a8 15 40 14 or %l5, %l4, %l4
40012b84: a6 15 00 13 or %l4, %l3, %l3
40012b88: e6 26 e0 1c st %l3, [ %i3 + 0x1c ]
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
40012b8c: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
40012b90: 99 2b 20 10 sll %o4, 0x10, %o4
40012b94: c6 27 bf 84 st %g3, [ %fp + -124 ]
40012b98: b1 33 20 10 srl %o4, 0x10, %i0
40012b9c: 7f ff be ad call 40002650 <.umul>
40012ba0: 90 0e a0 ff and %i2, 0xff, %o0
40012ba4: c6 07 bf 84 ld [ %fp + -124 ], %g3
40012ba8: 90 06 00 08 add %i0, %o0, %o0
40012bac: 86 00 c0 08 add %g3, %o0, %g3
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
40012bb0: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
40012bb4: a4 0c a0 ff and %l2, 0xff, %l2
40012bb8: a2 0c 60 ff and %l1, 0xff, %l1
40012bbc: a5 2c a0 08 sll %l2, 8, %l2
40012bc0: a2 14 80 11 or %l2, %l1, %l1
40012bc4: a3 2c 60 10 sll %l1, 0x10, %l1
40012bc8: 80 a4 60 00 cmp %l1, 0
40012bcc: 02 80 00 05 be 40012be0 <fat_init_volume_info+0x3a8>
40012bd0: c6 26 e0 34 st %g3, [ %i3 + 0x34 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
40012bd4: a3 34 60 10 srl %l1, 0x10, %l1
40012bd8: 10 80 00 0d b 40012c0c <fat_init_volume_info+0x3d4>
40012bdc: e2 26 e0 30 st %l1, [ %i3 + 0x30 ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
40012be0: c8 0f bf 9a ldub [ %fp + -102 ], %g4
40012be4: c4 0f bf 9b ldub [ %fp + -101 ], %g2
40012be8: c2 0f bf 8f ldub [ %fp + -113 ], %g1
40012bec: a0 0c 20 ff and %l0, 0xff, %l0
40012bf0: 85 28 a0 10 sll %g2, 0x10, %g2
40012bf4: a1 2c 20 08 sll %l0, 8, %l0
40012bf8: 84 14 00 02 or %l0, %g2, %g2
40012bfc: 84 10 80 04 or %g2, %g4, %g2
40012c00: 89 28 60 18 sll %g1, 0x18, %g4
40012c04: 84 10 80 04 or %g2, %g4, %g2
40012c08: c4 26 e0 30 st %g2, [ %i3 + 0x30 ]
data_secs = vol->tot_secs - vol->data_fsec;
40012c0c: d0 06 e0 30 ld [ %i3 + 0x30 ], %o0
vol->data_cls = data_secs / vol->spc;
40012c10: 92 0f 60 ff and %i5, 0xff, %o1
40012c14: 7f ff be c9 call 40002738 <.udiv>
40012c18: 90 22 00 03 sub %o0, %g3, %o0
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
40012c1c: 80 a2 2f f4 cmp %o0, 0xff4
40012c20: 18 80 00 08 bgu 40012c40 <fat_init_volume_info+0x408>
40012c24: d0 26 e0 38 st %o0, [ %i3 + 0x38 ]
{
vol->type = FAT_FAT12;
40012c28: 84 10 20 01 mov 1, %g2
40012c2c: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
vol->mask = FAT_FAT12_MASK;
40012c30: 84 10 2f ff mov 0xfff, %g2
40012c34: c4 26 e0 10 st %g2, [ %i3 + 0x10 ]
vol->eoc_val = FAT_FAT12_EOC;
40012c38: 10 80 00 0f b 40012c74 <fat_init_volume_info+0x43c>
40012c3c: 84 10 2f f8 mov 0xff8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
40012c40: 05 00 00 3f sethi %hi(0xfc00), %g2
40012c44: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4>
40012c48: 80 a2 00 03 cmp %o0, %g3
40012c4c: 38 80 00 05 bgu,a 40012c60 <fat_init_volume_info+0x428>
40012c50: 84 10 20 04 mov 4, %g2
{
vol->type = FAT_FAT16;
40012c54: 86 10 20 02 mov 2, %g3
40012c58: 10 80 00 04 b 40012c68 <fat_init_volume_info+0x430>
40012c5c: c6 2e e0 0e stb %g3, [ %i3 + 0xe ]
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
40012c60: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
vol->mask = FAT_FAT32_MASK;
40012c64: 05 03 ff ff sethi %hi(0xffffc00), %g2
40012c68: 86 10 a3 ff or %g2, 0x3ff, %g3 ! fffffff <RAM_SIZE+0xfbfffff>
vol->eoc_val = FAT_FAT32_EOC;
40012c6c: 84 10 a3 f8 or %g2, 0x3f8, %g2
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
40012c70: c6 26 e0 10 st %g3, [ %i3 + 0x10 ]
vol->eoc_val = FAT_FAT32_EOC;
40012c74: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
}
}
if (vol->type == FAT_FAT32)
40012c78: c4 0e e0 0e ldub [ %i3 + 0xe ], %g2
40012c7c: 80 a0 a0 04 cmp %g2, 4
40012c80: 12 80 00 63 bne 40012e0c <fat_init_volume_info+0x5d4>
40012c84: 82 10 3f ff mov -1, %g1
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40012c88: c6 0f bf 9d ldub [ %fp + -99 ], %g3
40012c8c: c4 0f bf 9c ldub [ %fp + -100 ], %g2
40012c90: 87 28 e0 08 sll %g3, 8, %g3
40012c94: 85 28 a0 10 sll %g2, 0x10, %g2
40012c98: c2 0f bf 97 ldub [ %fp + -105 ], %g1
40012c9c: 84 10 c0 02 or %g3, %g2, %g2
40012ca0: c6 0f bf 9e ldub [ %fp + -98 ], %g3
40012ca4: 84 10 80 03 or %g2, %g3, %g2
40012ca8: 87 28 60 18 sll %g1, 0x18, %g3
40012cac: 84 10 80 03 or %g2, %g3, %g2
40012cb0: c4 26 e0 3c st %g2, [ %i3 + 0x3c ]
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40012cb4: 84 0f 3f 80 and %i4, -128, %g2
if (vol->mirror)
40012cb8: 80 88 a0 80 btst 0x80, %g2
40012cbc: 02 80 00 05 be 40012cd0 <fat_init_volume_info+0x498> <== ALWAYS TAKEN
40012cc0: c4 2e e0 54 stb %g2, [ %i3 + 0x54 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
40012cc4: b8 0f 20 0f and %i4, 0xf, %i4 <== NOT EXECUTED
40012cc8: 10 80 00 03 b 40012cd4 <fat_init_volume_info+0x49c> <== NOT EXECUTED
40012ccc: f8 2e e0 5c stb %i4, [ %i3 + 0x5c ] <== NOT EXECUTED
else
vol->afat = 0;
40012cd0: c0 2e e0 5c clrb [ %i3 + 0x5c ]
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
40012cd4: f4 0f bf 9f ldub [ %fp + -97 ], %i2
40012cd8: b2 0e 60 ff and %i1, 0xff, %i1
40012cdc: b3 2e 60 08 sll %i1, 8, %i1
40012ce0: b4 16 40 1a or %i1, %i2, %i2
40012ce4: f4 36 e0 40 sth %i2, [ %i3 + 0x40 ]
if( vol->info_sec == 0 )
40012ce8: b5 2e a0 10 sll %i2, 0x10, %i2
40012cec: 93 36 a0 10 srl %i2, 0x10, %o1
40012cf0: 80 a2 60 00 cmp %o1, 0
40012cf4: 32 80 00 03 bne,a 40012d00 <fat_init_volume_info+0x4c8> <== ALWAYS TAKEN
40012cf8: 90 10 00 1b mov %i3, %o0
40012cfc: 30 80 00 18 b,a 40012d5c <fat_init_volume_info+0x524> <== NOT EXECUTED
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
40012d00: 94 10 20 00 clr %o2
40012d04: 96 10 20 04 mov 4, %o3
40012d08: 7f ff fd f3 call 400124d4 <_fat_block_read>
40012d0c: 98 07 bf a8 add %fp, -88, %o4
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
40012d10: 80 a2 20 00 cmp %o0, 0
40012d14: 06 80 00 22 bl 40012d9c <fat_init_volume_info+0x564> <== NEVER TAKEN
40012d18: c4 0f bf aa ldub [ %fp + -86 ], %g2
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
40012d1c: c6 0f bf a9 ldub [ %fp + -87 ], %g3
40012d20: 85 28 a0 10 sll %g2, 0x10, %g2
40012d24: 87 28 e0 08 sll %g3, 8, %g3
40012d28: 86 10 c0 02 or %g3, %g2, %g3
40012d2c: c4 0f bf a8 ldub [ %fp + -88 ], %g2
40012d30: 86 10 c0 02 or %g3, %g2, %g3
40012d34: c4 0f bf ab ldub [ %fp + -85 ], %g2
40012d38: 85 28 a0 18 sll %g2, 0x18, %g2
40012d3c: 86 10 c0 02 or %g3, %g2, %g3
40012d40: 05 10 58 54 sethi %hi(0x41615000), %g2
40012d44: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x1215252>
40012d48: 80 a0 c0 02 cmp %g3, %g2
40012d4c: 02 80 00 0a be 40012d74 <fat_init_volume_info+0x53c> <== ALWAYS TAKEN
40012d50: 90 10 00 1b mov %i3, %o0
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
40012d54: 7f ff fd 3d call 40012248 <fat_buf_release> <== NOT EXECUTED
40012d58: 01 00 00 00 nop <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
close(vol->fd);
40012d5c: 7f ff c7 48 call 40004a7c <close> <== NOT EXECUTED
40012d60: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40012d64: 40 00 1e da call 4001a8cc <__errno> <== NOT EXECUTED
40012d68: 01 00 00 00 nop <== NOT EXECUTED
40012d6c: 10 80 00 82 b 40012f74 <fat_init_volume_info+0x73c> <== NOT EXECUTED
40012d70: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
40012d74: d2 16 e0 40 lduh [ %i3 + 0x40 ], %o1
40012d78: 94 10 21 e4 mov 0x1e4, %o2
40012d7c: 96 10 20 0c mov 0xc, %o3
40012d80: 7f ff fd d5 call 400124d4 <_fat_block_read>
40012d84: 98 07 bf a8 add %fp, -88, %o4
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
40012d88: 80 a2 20 00 cmp %o0, 0
40012d8c: 16 80 00 08 bge 40012dac <fat_init_volume_info+0x574> <== ALWAYS TAKEN
40012d90: c6 0f bf ad ldub [ %fp + -83 ], %g3
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
40012d94: 7f ff fd 2d call 40012248 <fat_buf_release> <== NOT EXECUTED
40012d98: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(fs_info);
close(vol->fd);
40012d9c: 7f ff c7 38 call 40004a7c <close> <== NOT EXECUTED
40012da0: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
{
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
40012da4: 81 c7 e0 08 ret <== NOT EXECUTED
40012da8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
40012dac: c4 0f bf ae ldub [ %fp + -82 ], %g2
40012db0: 87 28 e0 08 sll %g3, 8, %g3
40012db4: 85 28 a0 10 sll %g2, 0x10, %g2
40012db8: 84 10 c0 02 or %g3, %g2, %g2
40012dbc: c6 0f bf ac ldub [ %fp + -84 ], %g3
40012dc0: 84 10 80 03 or %g2, %g3, %g2
40012dc4: c6 0f bf af ldub [ %fp + -81 ], %g3
40012dc8: 87 28 e0 18 sll %g3, 0x18, %g3
40012dcc: 84 10 80 03 or %g2, %g3, %g2
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40012dd0: c6 0f bf b1 ldub [ %fp + -79 ], %g3
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
40012dd4: c4 26 e0 48 st %g2, [ %i3 + 0x48 ]
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
40012dd8: c4 26 e0 44 st %g2, [ %i3 + 0x44 ]
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40012ddc: c4 0f bf b2 ldub [ %fp + -78 ], %g2
40012de0: 87 28 e0 08 sll %g3, 8, %g3
40012de4: 85 28 a0 10 sll %g2, 0x10, %g2
40012de8: 84 10 c0 02 or %g3, %g2, %g2
40012dec: c6 0f bf b0 ldub [ %fp + -80 ], %g3
40012df0: 84 10 80 03 or %g2, %g3, %g2
40012df4: c6 0f bf b3 ldub [ %fp + -77 ], %g3
40012df8: 87 28 e0 18 sll %g3, 0x18, %g3
40012dfc: 84 10 80 03 or %g2, %g3, %g2
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
40012e00: c4 26 e0 50 st %g2, [ %i3 + 0x50 ]
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
vol->next_cl = vol->next_cl_in_fs_info;
40012e04: 10 80 00 07 b 40012e20 <fat_init_volume_info+0x5e8>
40012e08: c4 26 e0 4c st %g2, [ %i3 + 0x4c ]
}
}
}
else
{
vol->rdir_cl = 0;
40012e0c: c0 26 e0 3c clr [ %i3 + 0x3c ]
vol->mirror = 0;
40012e10: c0 2e e0 54 clrb [ %i3 + 0x54 ]
vol->afat = 0;
40012e14: c0 2e e0 5c clrb [ %i3 + 0x5c ]
vol->free_cls = FAT_UNDEFINED_VALUE;
40012e18: c2 26 e0 44 st %g1, [ %i3 + 0x44 ]
vol->next_cl = FAT_UNDEFINED_VALUE;
40012e1c: c2 26 e0 4c st %g1, [ %i3 + 0x4c ]
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
40012e20: 7f ff fd 0a call 40012248 <fat_buf_release>
40012e24: 90 10 00 1b mov %i3, %o0
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
40012e28: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
40012e2c: 7f ff be 09 call 40002650 <.umul>
40012e30: d0 0e e0 5c ldub [ %i3 + 0x5c ], %o0
40012e34: c4 16 e0 18 lduh [ %i3 + 0x18 ], %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
40012e38: 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;
40012e3c: 90 02 00 02 add %o0, %g2, %o0
40012e40: d0 26 e0 58 st %o0, [ %i3 + 0x58 ]
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
40012e44: 7f ff c6 f7 call 40004a20 <calloc>
40012e48: 90 10 20 02 mov 2, %o0
if ( fs_info->vhash == NULL )
40012e4c: 80 a2 20 00 cmp %o0, 0
40012e50: 02 80 00 12 be 40012e98 <fat_init_volume_info+0x660> <== NEVER TAKEN
40012e54: d0 26 e0 6c st %o0, [ %i3 + 0x6c ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40012e58: 84 02 20 04 add %o0, 4, %g2
40012e5c: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
40012e60: c4 22 00 00 st %g2, [ %o0 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40012e64: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
40012e68: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40012e6c: 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;
40012e70: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
40012e74: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
40012e78: 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));
40012e7c: 92 10 20 0c mov 0xc, %o1
40012e80: 7f ff c6 e8 call 40004a20 <calloc>
40012e84: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
40012e88: 80 a2 20 00 cmp %o0, 0
40012e8c: 12 80 00 06 bne 40012ea4 <fat_init_volume_info+0x66c> <== ALWAYS TAKEN
40012e90: d0 26 e0 70 st %o0, [ %i3 + 0x70 ]
40012e94: 30 80 00 1c b,a 40012f04 <fat_init_volume_info+0x6cc> <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
close(vol->fd);
40012e98: 7f ff c6 f9 call 40004a7c <close> <== NOT EXECUTED
40012e9c: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
40012ea0: 30 80 00 32 b,a 40012f68 <fat_init_volume_info+0x730> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40012ea4: 84 02 20 04 add %o0, 4, %g2
head->next = tail;
40012ea8: c4 22 00 00 st %g2, [ %o0 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40012eac: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
40012eb0: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40012eb4: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
40012eb8: 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;
40012ebc: c0 22 20 10 clr [ %o0 + 0x10 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40012ec0: 86 02 20 10 add %o0, 0x10, %g3
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
40012ec4: 84 10 21 00 mov 0x100, %g2
head->next = tail;
40012ec8: c6 22 20 0c st %g3, [ %o0 + 0xc ]
40012ecc: c4 26 e0 7c st %g2, [ %i3 + 0x7c ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
40012ed0: c6 06 e0 30 ld [ %i3 + 0x30 ], %g3
40012ed4: c4 0e e0 03 ldub [ %i3 + 3 ], %g2
fs_info->index = 0;
40012ed8: c0 26 e0 78 clr [ %i3 + 0x78 ]
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
40012edc: 85 28 c0 02 sll %g3, %g2, %g2
40012ee0: 85 28 a0 04 sll %g2, 4, %g2
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
40012ee4: 90 10 21 00 mov 0x100, %o0
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
40012ee8: c4 26 e0 80 st %g2, [ %i3 + 0x80 ]
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
40012eec: 7f ff c6 cd call 40004a20 <calloc>
40012ef0: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
40012ef4: 80 a2 20 00 cmp %o0, 0
40012ef8: 12 80 00 0d bne 40012f2c <fat_init_volume_info+0x6f4> <== ALWAYS TAKEN
40012efc: d0 26 e0 74 st %o0, [ %i3 + 0x74 ]
40012f00: 30 80 00 05 b,a 40012f14 <fat_init_volume_info+0x6dc> <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
close(vol->fd);
40012f04: 7f ff c6 de call 40004a7c <close> <== NOT EXECUTED
40012f08: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40012f0c: 10 80 00 15 b 40012f60 <fat_init_volume_info+0x728> <== NOT EXECUTED
40012f10: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
close(vol->fd);
40012f14: 7f ff c6 da call 40004a7c <close> <== NOT EXECUTED
40012f18: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40012f1c: 7f ff c6 f9 call 40004b00 <free> <== NOT EXECUTED
40012f20: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40012f24: 10 80 00 0f b 40012f60 <fat_init_volume_info+0x728> <== NOT EXECUTED
40012f28: d0 06 e0 70 ld [ %i3 + 0x70 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
40012f2c: d0 16 c0 00 lduh [ %i3 ], %o0
40012f30: 7f ff c6 bc call 40004a20 <calloc>
40012f34: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
40012f38: 80 a2 20 00 cmp %o0, 0
40012f3c: 12 80 00 11 bne 40012f80 <fat_init_volume_info+0x748> <== ALWAYS TAKEN
40012f40: d0 26 e0 90 st %o0, [ %i3 + 0x90 ]
{
close(vol->fd);
40012f44: 7f ff c6 ce call 40004a7c <close> <== NOT EXECUTED
40012f48: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40012f4c: 7f ff c6 ed call 40004b00 <free> <== NOT EXECUTED
40012f50: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40012f54: 7f ff c6 eb call 40004b00 <free> <== NOT EXECUTED
40012f58: d0 06 e0 70 ld [ %i3 + 0x70 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
40012f5c: d0 06 e0 74 ld [ %i3 + 0x74 ], %o0 <== NOT EXECUTED
40012f60: 7f ff c6 e8 call 40004b00 <free> <== NOT EXECUTED
40012f64: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40012f68: 40 00 1e 59 call 4001a8cc <__errno> <== NOT EXECUTED
40012f6c: 01 00 00 00 nop <== NOT EXECUTED
40012f70: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
40012f74: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012f78: 81 c7 e0 08 ret <== NOT EXECUTED
40012f7c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
40012f80: c4 0e e0 04 ldub [ %i3 + 4 ], %g2
40012f84: c6 06 e0 34 ld [ %i3 + 0x34 ], %g3
40012f88: 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)
40012f8c: 80 88 80 03 btst %g2, %g3
40012f90: 22 80 00 04 be,a 40012fa0 <fat_init_volume_info+0x768> <== ALWAYS TAKEN
40012f94: c6 0e e0 0e ldub [ %i3 + 0xe ], %g3
vol->bytes_per_block_log2 = vol->bpc_log2;
vol->sectors_per_block = vol->spc;
}
}
return RC_OK;
40012f98: 81 c7 e0 08 ret <== NOT EXECUTED
40012f9c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40012fa0: 80 a0 e0 04 cmp %g3, 4
40012fa4: 22 80 00 07 be,a 40012fc0 <fat_init_volume_info+0x788>
40012fa8: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
40012fac: c6 06 e0 20 ld [ %i3 + 0x20 ], %g3
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40012fb0: 80 88 80 03 btst %g2, %g3
40012fb4: 12 80 00 0f bne 40012ff0 <fat_init_volume_info+0x7b8> <== NEVER TAKEN
40012fb8: b0 10 20 00 clr %i0
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
40012fbc: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
40012fc0: d2 16 e0 06 lduh [ %i3 + 6 ], %o1
40012fc4: 7f ff f6 78 call 400109a4 <rtems_bdbuf_set_block_size>
40012fc8: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
40012fcc: 80 a2 20 00 cmp %o0, 0
40012fd0: 12 80 00 08 bne 40012ff0 <fat_init_volume_info+0x7b8> <== NEVER TAKEN
40012fd4: b0 10 20 00 clr %i0
{
vol->bytes_per_block = vol->bpc;
40012fd8: c4 16 e0 06 lduh [ %i3 + 6 ], %g2
40012fdc: c4 36 e0 0a sth %g2, [ %i3 + 0xa ]
vol->bytes_per_block_log2 = vol->bpc_log2;
40012fe0: c4 0e e0 08 ldub [ %i3 + 8 ], %g2
40012fe4: c4 2e e0 0c stb %g2, [ %i3 + 0xc ]
vol->sectors_per_block = vol->spc;
40012fe8: c4 0e e0 04 ldub [ %i3 + 4 ], %g2
40012fec: c4 2e e0 09 stb %g2, [ %i3 + 9 ]
}
}
return RC_OK;
}
40012ff0: 81 c7 e0 08 ret
40012ff4: 81 e8 00 00 restore
40018e20 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
40018e20: 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;
40018e24: e8 06 20 38 ld [ %i0 + 0x38 ], %l4
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
40018e28: 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;
40018e2c: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
40018e30: 80 a6 a0 00 cmp %i2, 0
40018e34: 02 80 00 7e be 4001902c <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
40018e38: a2 10 20 00 clr %l1
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
40018e3c: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
40018e40: 80 a4 3f ff cmp %l0, -1
40018e44: 22 80 00 02 be,a 40018e4c <fat_scan_fat_for_free_clusters+0x2c>
40018e48: 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;
40018e4c: a8 05 20 02 add %l4, 2, %l4
40018e50: a6 10 20 02 mov 2, %l3
40018e54: 10 80 00 5a b 40018fbc <fat_scan_fat_for_free_clusters+0x19c>
40018e58: a4 10 20 00 clr %l2
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
40018e5c: 92 10 00 10 mov %l0, %o1
40018e60: 7f ff fe ae call 40018918 <fat_get_fat_cluster>
40018e64: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40018e68: a2 92 20 00 orcc %o0, 0, %l1
40018e6c: 02 80 00 0b be 40018e98 <fat_scan_fat_for_free_clusters+0x78><== ALWAYS TAKEN
40018e70: c2 07 bf fc ld [ %fp + -4 ], %g1
{
if (*cls_added != 0)
40018e74: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
40018e78: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40018e7c: 22 80 00 6d be,a 40019030 <fat_scan_fat_for_free_clusters+0x210><== NOT EXECUTED
40018e80: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
40018e84: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40018e88: 7f ff ff b7 call 40018d64 <fat_free_fat_clusters_chain> <== NOT EXECUTED
40018e8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
40018e90: 81 c7 e0 08 ret <== NOT EXECUTED
40018e94: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
if (*cls_added != 0)
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
40018e98: 80 a0 60 00 cmp %g1, 0
40018e9c: 32 80 00 44 bne,a 40018fac <fat_scan_fat_for_free_clusters+0x18c>
40018ea0: 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)
40018ea4: c2 06 c0 00 ld [ %i3 ], %g1
40018ea8: 80 a0 60 00 cmp %g1, 0
40018eac: 12 80 00 0e bne 40018ee4 <fat_scan_fat_for_free_clusters+0xc4>
40018eb0: 90 10 00 18 mov %i0, %o0
{
*chain = cl4find;
40018eb4: e0 26 40 00 st %l0, [ %i1 ]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
40018eb8: 92 10 00 10 mov %l0, %o1
40018ebc: 7f ff ff 09 call 40018ae0 <fat_set_fat_cluster>
40018ec0: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
40018ec4: 80 a2 20 00 cmp %o0, 0
40018ec8: 32 80 00 59 bne,a 4001902c <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
40018ecc: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
if ( rc != RC_OK )
goto cleanup;
}
if (zero_fill)
40018ed0: 80 a7 60 00 cmp %i5, 0
40018ed4: 22 80 00 18 be,a 40018f34 <fat_scan_fat_for_free_clusters+0x114>
40018ed8: c2 06 c0 00 ld [ %i3 ], %g1
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
40018edc: 10 80 00 1c b 40018f4c <fat_scan_fat_for_free_clusters+0x12c>
40018ee0: d6 16 20 06 lduh [ %i0 + 6 ], %o3
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
40018ee4: 92 10 00 10 mov %l0, %o1
40018ee8: 7f ff fe fe call 40018ae0 <fat_set_fat_cluster>
40018eec: 94 10 3f ff mov -1, %o2
40018ef0: aa 10 00 08 mov %o0, %l5
if ( rc != RC_OK )
40018ef4: 80 a5 60 00 cmp %l5, 0
40018ef8: 02 80 00 07 be 40018f14 <fat_scan_fat_for_free_clusters+0xf4><== ALWAYS TAKEN
40018efc: 90 10 00 18 mov %i0, %o0
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
40018f00: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40018f04: 7f ff ff 98 call 40018d64 <fat_free_fat_clusters_chain> <== NOT EXECUTED
40018f08: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
40018f0c: 81 c7 e0 08 ret <== NOT EXECUTED
40018f10: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
40018f14: 92 10 00 12 mov %l2, %o1
40018f18: 7f ff fe f2 call 40018ae0 <fat_set_fat_cluster>
40018f1c: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
40018f20: a4 92 20 00 orcc %o0, 0, %l2
40018f24: 02 bf ff ec be 40018ed4 <fat_scan_fat_for_free_clusters+0xb4><== ALWAYS TAKEN
40018f28: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
40018f2c: 10 80 00 35 b 40019000 <fat_scan_fat_for_free_clusters+0x1e0><== NOT EXECUTED
40018f30: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
40018f34: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
40018f38: 80 a0 40 1a cmp %g1, %i2
40018f3c: 02 80 00 0f be 40018f78 <fat_scan_fat_for_free_clusters+0x158>
40018f40: c2 26 c0 00 st %g1, [ %i3 ]
40018f44: 10 80 00 19 b 40018fa8 <fat_scan_fat_for_free_clusters+0x188>
40018f48: a4 10 00 10 mov %l0, %l2
goto cleanup;
}
if (zero_fill)
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
40018f4c: 90 10 00 18 mov %i0, %o0
40018f50: 92 10 00 10 mov %l0, %o1
40018f54: 94 10 20 00 clr %o2
40018f58: 7f ff e5 a5 call 400125ec <fat_cluster_set>
40018f5c: 98 10 20 00 clr %o4
if (fs_info->vol.bpc != bytes_written)
40018f60: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40018f64: 80 a0 40 08 cmp %g1, %o0
40018f68: 22 bf ff f3 be,a 40018f34 <fat_scan_fat_for_free_clusters+0x114><== ALWAYS TAKEN
40018f6c: c2 06 c0 00 ld [ %i3 ], %g1
{
rc = -1;
40018f70: 10 80 00 23 b 40018ffc <fat_scan_fat_for_free_clusters+0x1dc><== NOT EXECUTED
40018f74: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
40018f78: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
40018f7c: 80 a0 7f ff cmp %g1, -1
40018f80: 02 80 00 05 be 40018f94 <fat_scan_fat_for_free_clusters+0x174><== ALWAYS TAKEN
40018f84: e0 26 20 4c st %l0, [ %i0 + 0x4c ]
fs_info->vol.free_cls -= (*cls_added);
40018f88: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
40018f8c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40018f90: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
40018f94: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
40018f98: 7f ff e4 ac call 40012248 <fat_buf_release>
40018f9c: 90 10 00 18 mov %i0, %o0
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
40018fa0: 81 c7 e0 08 ret
40018fa4: 91 e8 00 11 restore %g0, %l1, %o0
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
40018fa8: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
40018fac: 80 a4 00 14 cmp %l0, %l4
40018fb0: 0a 80 00 03 bcs 40018fbc <fat_scan_fat_for_free_clusters+0x19c><== ALWAYS TAKEN
40018fb4: a6 04 e0 01 inc %l3
cl4find = 2;
40018fb8: 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)
40018fbc: 80 a4 c0 14 cmp %l3, %l4
40018fc0: 0a bf ff a7 bcs 40018e5c <fat_scan_fat_for_free_clusters+0x3c><== ALWAYS TAKEN
40018fc4: 90 10 00 18 mov %i0, %o0
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
40018fc8: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
40018fcc: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
40018fd0: 02 80 00 05 be 40018fe4 <fat_scan_fat_for_free_clusters+0x1c4><== NOT EXECUTED
40018fd4: e4 26 20 4c st %l2, [ %i0 + 0x4c ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
40018fd8: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
40018fdc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40018fe0: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
40018fe4: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
40018fe8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40018fec: 7f ff e4 97 call 40012248 <fat_buf_release> <== NOT EXECUTED
40018ff0: a2 10 20 00 clr %l1 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
40018ff4: 81 c7 e0 08 ret <== NOT EXECUTED
40018ff8: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
40018ffc: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40019000: 7f ff ff 59 call 40018d64 <fat_free_fat_clusters_chain> <== NOT EXECUTED
40019004: 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);
40019008: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001900c: 94 10 20 00 clr %o2 <== NOT EXECUTED
40019010: 7f ff fe b4 call 40018ae0 <fat_set_fat_cluster> <== NOT EXECUTED
40019014: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
40019018: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001901c: 7f ff e4 8b call 40012248 <fat_buf_release> <== NOT EXECUTED
40019020: a2 10 00 12 mov %l2, %l1 <== NOT EXECUTED
return rc;
}
40019024: 81 c7 e0 08 ret <== NOT EXECUTED
40019028: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
4001902c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
40019030: 81 c7 e0 08 ret <== NOT EXECUTED
40019034: 81 e8 00 00 restore <== NOT EXECUTED
40012554 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
40012554: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t cmpltd = 0;
40012558: a0 10 20 00 clr %l0
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
4001255c: 10 80 00 1b b 400125c8 <fat_sector_write+0x74>
40012560: a2 10 20 01 mov 1, %l1
{
c = MIN(count, (fs_info->vol.bps - ofs));
40012564: ba 27 40 1a sub %i5, %i2, %i5
40012568: 80 a7 40 1b cmp %i5, %i3
4001256c: 38 80 00 02 bgu,a 40012574 <fat_sector_write+0x20>
40012570: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
40012574: c2 16 20 0a lduh [ %i0 + 0xa ], %g1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
40012578: 90 10 00 18 mov %i0, %o0
4001257c: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
40012580: 80 a7 40 01 cmp %i5, %g1
40012584: 02 80 00 03 be 40012590 <fat_sector_write+0x3c> <== NEVER TAKEN
40012588: 94 10 20 02 mov 2, %o2
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
4001258c: 94 10 20 01 mov 1, %o2
40012590: 7f ff ff a2 call 40012418 <fat_buf_access>
40012594: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40012598: 80 a2 20 00 cmp %o0, 0
4001259c: 12 80 00 10 bne 400125dc <fat_sector_write+0x88> <== NEVER TAKEN
400125a0: d0 07 bf fc ld [ %fp + -4 ], %o0
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
400125a4: 92 07 00 10 add %i4, %l0, %o1
400125a8: 90 02 00 1a add %o0, %i2, %o0
400125ac: 94 10 00 1d mov %i5, %o2
400125b0: 40 00 23 6c call 4001b360 <memcpy>
400125b4: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
400125b8: a0 07 40 10 add %i5, %l0, %l0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
400125bc: e2 2e 20 88 stb %l1, [ %i0 + 0x88 ]
sec_num++;
400125c0: b2 06 60 01 inc %i1
ofs = 0;
400125c4: b4 10 20 00 clr %i2
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
400125c8: 80 a6 e0 00 cmp %i3, 0
400125cc: 32 bf ff e6 bne,a 40012564 <fat_sector_write+0x10>
400125d0: fa 16 00 00 lduh [ %i0 ], %i5
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
400125d4: 81 c7 e0 08 ret
400125d8: 91 e8 00 10 restore %g0, %l0, %o0
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
400125dc: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
400125e0: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
400125e4: 81 c7 e0 08 ret <== NOT EXECUTED
400125e8: 81 e8 00 00 restore <== NOT EXECUTED
40018ae0 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
40018ae0: 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;
40018ae4: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
40018ae8: 80 a6 60 01 cmp %i1, 1
40018aec: 08 80 00 98 bleu 40018d4c <fat_set_fat_cluster+0x26c> <== NEVER TAKEN
40018af0: ba 10 00 18 mov %i0, %i5
40018af4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
40018af8: 82 00 60 01 inc %g1
40018afc: 80 a6 40 01 cmp %i1, %g1
40018b00: 28 80 00 03 bleu,a 40018b0c <fat_set_fat_cluster+0x2c> <== ALWAYS TAKEN
40018b04: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
40018b08: 30 80 00 91 b,a 40018d4c <fat_set_fat_cluster+0x26c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
40018b0c: 84 08 60 01 and %g1, 1, %g2
40018b10: 80 88 a0 ff btst 0xff, %g2
40018b14: 02 80 00 05 be 40018b28 <fat_set_fat_cluster+0x48>
40018b18: 86 08 60 02 and %g1, 2, %g3
40018b1c: a1 36 60 01 srl %i1, 1, %l0
40018b20: 10 80 00 06 b 40018b38 <fat_set_fat_cluster+0x58>
40018b24: a0 04 00 19 add %l0, %i1, %l0
40018b28: 80 88 e0 ff btst 0xff, %g3
40018b2c: 02 80 00 03 be 40018b38 <fat_set_fat_cluster+0x58>
40018b30: a1 2e 60 02 sll %i1, 2, %l0
40018b34: a1 2e 60 01 sll %i1, 1, %l0
40018b38: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
40018b3c: 80 88 a0 ff btst 0xff, %g2
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
40018b40: a1 34 00 03 srl %l0, %g3, %l0
40018b44: c6 07 60 58 ld [ %i5 + 0x58 ], %g3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
40018b48: 02 80 00 05 be 40018b5c <fat_set_fat_cluster+0x7c>
40018b4c: a0 04 00 03 add %l0, %g3, %l0
40018b50: b7 36 60 01 srl %i1, 1, %i3
40018b54: 10 80 00 07 b 40018b70 <fat_set_fat_cluster+0x90>
40018b58: b6 06 c0 19 add %i3, %i1, %i3
40018b5c: 82 08 60 02 and %g1, 2, %g1
40018b60: 80 88 60 ff btst 0xff, %g1
40018b64: 02 80 00 03 be 40018b70 <fat_set_fat_cluster+0x90>
40018b68: b7 2e 60 02 sll %i1, 2, %i3
40018b6c: b7 2e 60 01 sll %i1, 1, %i3
40018b70: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
40018b74: 90 10 00 1d mov %i5, %o0
40018b78: 92 10 00 10 mov %l0, %o1
40018b7c: 94 10 20 01 mov 1, %o2
40018b80: 7f ff e6 26 call 40012418 <fat_buf_access>
40018b84: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40018b88: b0 92 20 00 orcc %o0, 0, %i0
40018b8c: 12 80 00 4c bne 40018cbc <fat_set_fat_cluster+0x1dc> <== NEVER TAKEN
40018b90: b9 2f 20 10 sll %i4, 0x10, %i4
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
40018b94: b9 37 20 10 srl %i4, 0x10, %i4
40018b98: b8 07 3f ff add %i4, -1, %i4
40018b9c: b8 0e c0 1c and %i3, %i4, %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
40018ba0: f6 0f 60 0e ldub [ %i5 + 0xe ], %i3
40018ba4: 80 a6 e0 02 cmp %i3, 2
40018ba8: 02 80 00 53 be 40018cf4 <fat_set_fat_cluster+0x214>
40018bac: 80 a6 e0 04 cmp %i3, 4
40018bb0: 02 80 00 5b be 40018d1c <fat_set_fat_cluster+0x23c>
40018bb4: 80 a6 e0 01 cmp %i3, 1
40018bb8: 12 80 00 65 bne 40018d4c <fat_set_fat_cluster+0x26c> <== NEVER TAKEN
40018bbc: 80 8e 60 01 btst 1, %i1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
40018bc0: 02 80 00 23 be 40018c4c <fat_set_fat_cluster+0x16c>
40018bc4: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
40018bc8: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
40018bcc: 84 08 a0 0f and %g2, 0xf, %g2
40018bd0: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
40018bd4: c2 07 bf fc ld [ %fp + -4 ], %g1
40018bd8: 85 2e a0 04 sll %i2, 4, %g2
40018bdc: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
40018be0: 84 10 c0 02 or %g3, %g2, %g2
40018be4: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
40018be8: c2 17 40 00 lduh [ %i5 ], %g1
40018bec: 82 00 7f ff add %g1, -1, %g1
40018bf0: 80 a7 00 01 cmp %i4, %g1
40018bf4: 12 80 00 0f bne 40018c30 <fat_set_fat_cluster+0x150> <== ALWAYS TAKEN
40018bf8: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
40018bfc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018c00: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
40018c04: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40018c08: 7f ff e6 04 call 40012418 <fat_buf_access> <== NOT EXECUTED
40018c0c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
40018c10: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40018c14: 12 80 00 2a bne 40018cbc <fat_set_fat_cluster+0x1dc> <== NOT EXECUTED
40018c18: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40018c1c: b5 2e a0 14 sll %i2, 0x14, %i2 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
return rc;
*sec_buf &= 0x00;
40018c20: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40018c24: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
40018c28: 10 80 00 21 b 40018cac <fat_set_fat_cluster+0x1cc> <== NOT EXECUTED
40018c2c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
40018c30: c2 07 bf fc ld [ %fp + -4 ], %g1
40018c34: b8 07 20 01 inc %i4
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
40018c38: b5 2e a0 14 sll %i2, 0x14, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
40018c3c: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
40018c40: b5 36 a0 18 srl %i2, 0x18, %i2
40018c44: 10 80 00 27 b 40018ce0 <fat_set_fat_cluster+0x200>
40018c48: c2 07 bf fc ld [ %fp + -4 ], %g1
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*(sec_buf + ofs) &= 0x00;
40018c4c: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
40018c50: c2 07 bf fc ld [ %fp + -4 ], %g1
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
40018c54: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) &= 0x00;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
40018c58: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
40018c5c: 84 10 80 1a or %g2, %i2, %g2
40018c60: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
40018c64: c2 17 40 00 lduh [ %i5 ], %g1
40018c68: 82 00 7f ff add %g1, -1, %g1
40018c6c: 80 a7 00 01 cmp %i4, %g1
40018c70: 12 80 00 15 bne 40018cc4 <fat_set_fat_cluster+0x1e4> <== ALWAYS TAKEN
40018c74: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
40018c78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018c7c: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
40018c80: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40018c84: 7f ff e5 e5 call 40012418 <fat_buf_access> <== NOT EXECUTED
40018c88: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
40018c8c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40018c90: 12 80 00 0b bne 40018cbc <fat_set_fat_cluster+0x1dc> <== NOT EXECUTED
40018c94: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40018c98: 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;
40018c9c: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
40018ca0: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
40018ca4: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40018ca8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
40018cac: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
40018cb0: b4 16 80 02 or %i2, %g2, %i2 <== NOT EXECUTED
40018cb4: f4 28 40 00 stb %i2, [ %g1 ] <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
40018cb8: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
40018cbc: 81 c7 e0 08 ret <== NOT EXECUTED
40018cc0: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
40018cc4: c2 07 bf fc ld [ %fp + -4 ], %g1
40018cc8: b8 07 20 01 inc %i4
40018ccc: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40018cd0: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
40018cd4: 84 08 bf f0 and %g2, -16, %g2
40018cd8: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40018cdc: c2 07 bf fc ld [ %fp + -4 ], %g1
40018ce0: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
40018ce4: b4 10 80 1a or %g2, %i2, %i2
40018ce8: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
40018cec: 81 c7 e0 08 ret
40018cf0: 81 e8 00 00 restore
break;
}
return RC_OK;
}
40018cf4: 03 00 00 3f sethi %hi(0xfc00), %g1
40018cf8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40018cfc: 82 0e 80 01 and %i2, %g1, %g1
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
40018d00: 83 28 60 08 sll %g1, 8, %g1
40018d04: b5 2e a0 10 sll %i2, 0x10, %i2
40018d08: b5 36 a0 18 srl %i2, 0x18, %i2
40018d0c: b4 10 40 1a or %g1, %i2, %i2
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
40018d10: c2 07 bf fc ld [ %fp + -4 ], %g1
40018d14: 10 80 00 0a b 40018d3c <fat_set_fat_cluster+0x25c>
40018d18: f4 30 40 1c sth %i2, [ %g1 + %i4 ]
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
40018d1c: 11 3c 00 00 sethi %hi(0xf0000000), %o0
40018d20: 7f ff fe f2 call 400188e8 <CPU_swap_u32>
40018d24: 90 2e 80 08 andn %i2, %o0, %o0
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
40018d28: c2 07 bf fc ld [ %fp + -4 ], %g1
40018d2c: c4 00 40 1c ld [ %g1 + %i4 ], %g2
40018d30: 84 08 a0 f0 and %g2, 0xf0, %g2
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
40018d34: 90 12 00 02 or %o0, %g2, %o0
40018d38: d0 20 40 1c st %o0, [ %g1 + %i4 ]
40018d3c: 82 10 20 01 mov 1, %g1
40018d40: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
40018d44: 81 c7 e0 08 ret
40018d48: 81 e8 00 00 restore
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
40018d4c: 40 00 06 e0 call 4001a8cc <__errno> <== NOT EXECUTED
40018d50: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40018d54: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40018d58: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
40018d5c: 81 c7 e0 08 ret <== NOT EXECUTED
40018d60: 81 e8 00 00 restore <== NOT EXECUTED
400130c8 <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)
{
400130c8: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
400130cc: 90 10 00 18 mov %i0, %o0
400130d0: 7f ff ff ca call 40012ff8 <fat_sync>
400130d4: ba 10 00 18 mov %i0, %i5
if ( rc != RC_OK )
400130d8: b0 92 20 00 orcc %o0, 0, %i0
400130dc: 32 80 00 02 bne,a 400130e4 <fat_shutdown_drive+0x1c> <== NEVER TAKEN
400130e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
400130e4: b8 10 20 00 clr %i4
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
400130e8: f6 07 60 6c ld [ %i5 + 0x6c ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
400130ec: 10 80 00 04 b 400130fc <fat_shutdown_drive+0x34>
400130f0: b6 06 c0 1c add %i3, %i4, %i3
free(node);
400130f4: 7f ff c6 83 call 40004b00 <free>
400130f8: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
400130fc: 7f ff da 5e call 40009a74 <_Chain_Get>
40013100: 90 10 00 1b mov %i3, %o0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
40013104: 80 a2 20 00 cmp %o0, 0
40013108: 12 bf ff fb bne 400130f4 <fat_shutdown_drive+0x2c>
4001310c: 01 00 00 00 nop
40013110: b8 07 20 0c add %i4, 0xc, %i4
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
40013114: 80 a7 20 18 cmp %i4, 0x18
40013118: 32 bf ff f5 bne,a 400130ec <fat_shutdown_drive+0x24>
4001311c: f6 07 60 6c ld [ %i5 + 0x6c ], %i3
40013120: b8 10 20 00 clr %i4
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
40013124: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
40013128: 10 80 00 04 b 40013138 <fat_shutdown_drive+0x70>
4001312c: b6 06 c0 1c add %i3, %i4, %i3
free(node);
40013130: 7f ff c6 74 call 40004b00 <free> <== NOT EXECUTED
40013134: 01 00 00 00 nop <== NOT EXECUTED
40013138: 7f ff da 4f call 40009a74 <_Chain_Get>
4001313c: 90 10 00 1b mov %i3, %o0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
40013140: 80 a2 20 00 cmp %o0, 0
40013144: 12 bf ff fb bne 40013130 <fat_shutdown_drive+0x68> <== NEVER TAKEN
40013148: 01 00 00 00 nop
4001314c: b8 07 20 0c add %i4, 0xc, %i4
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
40013150: 80 a7 20 18 cmp %i4, 0x18
40013154: 32 bf ff f5 bne,a 40013128 <fat_shutdown_drive+0x60>
40013158: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
4001315c: 7f ff c6 69 call 40004b00 <free>
40013160: d0 07 60 6c ld [ %i5 + 0x6c ], %o0
free(fs_info->rhash);
40013164: 7f ff c6 67 call 40004b00 <free>
40013168: d0 07 60 70 ld [ %i5 + 0x70 ], %o0
free(fs_info->uino);
4001316c: 7f ff c6 65 call 40004b00 <free>
40013170: d0 07 60 74 ld [ %i5 + 0x74 ], %o0
free(fs_info->sec_buf);
40013174: 7f ff c6 63 call 40004b00 <free>
40013178: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
close(fs_info->vol.fd);
4001317c: 7f ff c6 40 call 40004a7c <close>
40013180: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
if (rc)
40013184: 80 a6 20 00 cmp %i0, 0
40013188: 02 80 00 06 be 400131a0 <fat_shutdown_drive+0xd8> <== ALWAYS TAKEN
4001318c: 01 00 00 00 nop
errno = EIO;
40013190: 40 00 1d cf call 4001a8cc <__errno> <== NOT EXECUTED
40013194: 01 00 00 00 nop <== NOT EXECUTED
40013198: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
4001319c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
400131a0: 81 c7 e0 08 ret
400131a4: 81 e8 00 00 restore
40012ff8 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
40012ff8: 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)
40012ffc: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
40013000: ba 10 00 18 mov %i0, %i5
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
40013004: 90 10 20 00 clr %o0
if (fs_info->vol.type == FAT_FAT32)
40013008: 80 a0 a0 04 cmp %g2, 4
4001300c: 12 80 00 20 bne 4001308c <fat_sync+0x94>
40013010: b4 10 20 00 clr %i2
{
uint32_t free_count = fs_info->vol.free_cls;
40013014: f6 06 20 44 ld [ %i0 + 0x44 ], %i3
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
40013018: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4001301c: 80 a6 c0 01 cmp %i3, %g1
40013020: 02 80 00 0d be 40013054 <fat_sync+0x5c> <== ALWAYS TAKEN
40013024: f8 06 20 4c ld [ %i0 + 0x4c ], %i4
{
uint32_t le_free_count = CT_LE_L(free_count);
40013028: 7f ff fc 65 call 400121bc <CPU_swap_u32> <== NOT EXECUTED
4001302c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
ret1 = fat_sector_write(fs_info,
40013030: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
{
uint32_t le_free_count = CT_LE_L(free_count);
40013034: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
40013038: f6 26 20 48 st %i3, [ %i0 + 0x48 ] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
4001303c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013040: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
40013044: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
40013048: 7f ff fd 43 call 40012554 <fat_sector_write> <== NOT EXECUTED
4001304c: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
40013050: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
40013054: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
40013058: 80 a7 00 02 cmp %i4, %g2
4001305c: 02 80 00 0c be 4001308c <fat_sync+0x94> <== NEVER TAKEN
40013060: 90 10 20 00 clr %o0
{
uint32_t le_next_free = CT_LE_L(next_free);
40013064: 7f ff fc 56 call 400121bc <CPU_swap_u32>
40013068: 90 10 00 1c mov %i4, %o0
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
4001306c: d2 17 60 40 lduh [ %i5 + 0x40 ], %o1
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
40013070: d0 27 bf fc st %o0, [ %fp + -4 ]
fs_info->vol.next_cl_in_fs_info = next_free;
40013074: f8 27 60 50 st %i4, [ %i5 + 0x50 ]
ret2 = fat_sector_write(fs_info,
40013078: 90 10 00 1d mov %i5, %o0
4001307c: 94 10 21 ec mov 0x1ec, %o2
40013080: 96 10 20 04 mov 4, %o3
40013084: 7f ff fd 34 call 40012554 <fat_sector_write>
40013088: 98 07 bf fc add %fp, -4, %o4
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
4001308c: 80 a2 20 00 cmp %o0, 0
40013090: 06 80 00 04 bl 400130a0 <fat_sync+0xa8> <== NEVER TAKEN
40013094: 80 a6 a0 00 cmp %i2, 0
40013098: 16 80 00 03 bge 400130a4 <fat_sync+0xac> <== ALWAYS TAKEN
4001309c: b0 10 20 00 clr %i0
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
400130a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fat_buf_release(fs_info);
400130a4: 7f ff fc 69 call 40012248 <fat_buf_release>
400130a8: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
400130ac: 7f ff f5 bb call 40010798 <rtems_bdbuf_syncdev>
400130b0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
400130b4: 80 a2 20 00 cmp %o0, 0
400130b8: 32 80 00 02 bne,a 400130c0 <fat_sync+0xc8> <== NEVER TAKEN
400130bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
return rc;
}
400130c0: 81 c7 e0 08 ret
400130c4: 81 e8 00 00 restore
40031e84 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
40031e84: 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 );
40031e88: 03 10 01 7b sethi %hi(0x4005ec00), %g1 <== NOT EXECUTED
40031e8c: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 4005ef40 <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;
40031e90: c0 27 bf c4 clr [ %fp + -60 ] <== NOT EXECUTED
st.st_uid = 0;
40031e94: c0 37 bf ca clrh [ %fp + -54 ] <== NOT EXECUTED
st.st_gid = 0;
rtems_libio_check_fd( fd );
40031e98: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
40031e9c: 1a 80 00 0c bcc 40031ecc <fchdir+0x48> <== NOT EXECUTED
40031ea0: c0 37 bf cc clrh [ %fp + -52 ] <== NOT EXECUTED
iop = rtems_libio_iop( fd );
40031ea4: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
40031ea8: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
40031eac: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED
40031eb0: 03 10 01 8c sethi %hi(0x40063000), %g1 <== NOT EXECUTED
40031eb4: fa 00 60 2c ld [ %g1 + 0x2c ], %i5 ! 4006302c <rtems_libio_iops><== NOT EXECUTED
40031eb8: ba 07 40 18 add %i5, %i0, %i5 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
40031ebc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
40031ec0: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40031ec4: 32 80 00 08 bne,a 40031ee4 <fchdir+0x60> <== NOT EXECUTED
40031ec8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
40031ecc: 40 00 10 d5 call 40036220 <__errno> <== NOT EXECUTED
40031ed0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40031ed4: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
40031ed8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40031edc: 81 c7 e0 08 ret <== NOT EXECUTED
40031ee0: 81 e8 00 00 restore <== NOT EXECUTED
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 );
40031ee4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40031ee8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40031eec: 9f c0 40 00 call %g1 <== NOT EXECUTED
40031ef0: 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 );
40031ef4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40031ef8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40031efc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
40031f00: 9f c0 40 00 call %g1 <== NOT EXECUTED
40031f04: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if ( rv == 0 ) {
40031f08: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40031f0c: 32 80 00 13 bne,a 40031f58 <fchdir+0xd4> <== NOT EXECUTED
40031f10: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
bool access_ok = rtems_filesystem_check_access(
40031f14: d2 07 bf c4 ld [ %fp + -60 ], %o1 <== NOT EXECUTED
40031f18: d4 17 bf ca lduh [ %fp + -54 ], %o2 <== NOT EXECUTED
40031f1c: d6 17 bf cc lduh [ %fp + -52 ], %o3 <== NOT EXECUTED
40031f20: 7f ff 6d e9 call 4000d6c4 <rtems_filesystem_check_access> <== NOT EXECUTED
40031f24: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
40031f28: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40031f2c: 02 80 00 06 be 40031f44 <fchdir+0xc0> <== NOT EXECUTED
40031f30: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
40031f34: 7f ff 6c 50 call 4000d074 <rtems_filesystem_location_clone><== NOT EXECUTED
40031f38: 92 10 00 1c mov %i4, %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;
40031f3c: 10 80 00 07 b 40031f58 <fchdir+0xd4> <== NOT EXECUTED
40031f40: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
} else {
errno = EACCES;
40031f44: 40 00 10 b7 call 40036220 <__errno> <== NOT EXECUTED
40031f48: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40031f4c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
40031f50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40031f54: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40031f58: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40031f5c: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
40031f60: 9f c0 40 00 call %g1 <== NOT EXECUTED
40031f64: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
40031f68: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40031f6c: 12 80 00 05 bne 40031f80 <fchdir+0xfc> <== NOT EXECUTED
40031f70: 01 00 00 00 nop <== NOT EXECUTED
rv = rtems_filesystem_chdir( &loc );
40031f74: 7f ff c3 1d call 40022be8 <rtems_filesystem_chdir> <== NOT EXECUTED
40031f78: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
40031f7c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
return rv;
}
40031f80: 81 c7 e0 08 ret <== NOT EXECUTED
40031f84: 81 e8 00 00 restore <== NOT EXECUTED
40031f88: 40 03 20 30 call 400fa048 <__end+0x96118> <== NOT EXECUTED
40031f8c: 40 03 21 0c call 400fa3bc <__end+0x9648c> <== NOT EXECUTED
40031f90: 40 03 21 18 call 400fa3f0 <__end+0x964c0> <== NOT EXECUTED
40031f94: 40 03 21 30 call 400fa454 <__end+0x96524> <== NOT EXECUTED
40031f98: 40 03 21 40 call 400fa498 <__end+0x96568> <== NOT EXECUTED
40031f9c: 40 03 21 64 call 400fa52c <__end+0x965fc> <== NOT EXECUTED
40031fa0: 40 03 21 64 call 400fa530 <__end+0x96600> <== NOT EXECUTED
40031fa4: 40 03 21 64 call 400fa534 <__end+0x96604> <== NOT EXECUTED
40031fa8: 40 03 21 64 call 400fa538 <__end+0x96608> <== NOT EXECUTED
40031fac: 40 03 21 64 call 400fa53c <__end+0x9660c> <== NOT EXECUTED
40023140 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
40023140: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40023144: 03 10 01 7b sethi %hi(0x4005ec00), %g1
40023148: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 4005ef40 <rtems_libio_number_iops>
4002314c: 80 a6 00 01 cmp %i0, %g1
40023150: 2a 80 00 03 bcs,a 4002315c <fchmod+0x1c>
40023154: 83 2e 20 03 sll %i0, 3, %g1
40023158: 30 80 00 0a b,a 40023180 <fchmod+0x40>
iop = rtems_libio_iop( fd );
4002315c: b1 2e 20 06 sll %i0, 6, %i0
40023160: b0 26 00 01 sub %i0, %g1, %i0
40023164: 03 10 01 8c sethi %hi(0x40063000), %g1
40023168: fa 00 60 2c ld [ %g1 + 0x2c ], %i5 ! 4006302c <rtems_libio_iops>
4002316c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40023170: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40023174: 80 88 61 00 btst 0x100, %g1
40023178: 32 80 00 06 bne,a 40023190 <fchmod+0x50>
4002317c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
40023180: 40 00 4c 28 call 40036220 <__errno>
40023184: 01 00 00 00 nop
40023188: 10 80 00 1b b 400231f4 <fchmod+0xb4>
4002318c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
40023190: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
40023194: 80 a0 60 00 cmp %g1, 0
40023198: 02 80 00 14 be 400231e8 <fchmod+0xa8> <== NEVER TAKEN
4002319c: 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 );
400231a0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400231a4: c2 00 40 00 ld [ %g1 ], %g1
400231a8: 9f c0 40 00 call %g1
400231ac: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
400231b0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400231b4: 90 07 60 14 add %i5, 0x14, %o0
400231b8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400231bc: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
400231c0: 9f c0 40 00 call %g1
400231c4: 92 10 00 19 mov %i1, %o1
400231c8: 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;
400231cc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
400231d0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400231d4: c2 00 60 04 ld [ %g1 + 4 ], %g1
400231d8: 9f c0 40 00 call %g1
400231dc: 01 00 00 00 nop
400231e0: 81 c7 e0 08 ret
400231e4: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
400231e8: 40 00 4c 0e call 40036220 <__errno> <== NOT EXECUTED
400231ec: 01 00 00 00 nop <== NOT EXECUTED
400231f0: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
400231f4: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
400231f8: 81 c7 e0 08 ret
400231fc: 91 e8 3f ff restore %g0, -1, %o0
40023200 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
40023200: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40023204: 03 10 01 7b sethi %hi(0x4005ec00), %g1
40023208: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 4005ef40 <rtems_libio_number_iops>
4002320c: 80 a6 00 01 cmp %i0, %g1
40023210: 2a 80 00 03 bcs,a 4002321c <fchown+0x1c>
40023214: 83 2e 20 03 sll %i0, 3, %g1
40023218: 30 80 00 0a b,a 40023240 <fchown+0x40>
iop = rtems_libio_iop( fd );
4002321c: b1 2e 20 06 sll %i0, 6, %i0
40023220: b0 26 00 01 sub %i0, %g1, %i0
40023224: 03 10 01 8c sethi %hi(0x40063000), %g1
40023228: fa 00 60 2c ld [ %g1 + 0x2c ], %i5 ! 4006302c <rtems_libio_iops>
4002322c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40023230: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40023234: 80 88 61 00 btst 0x100, %g1
40023238: 32 80 00 06 bne,a 40023250 <fchown+0x50>
4002323c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
40023240: 40 00 4b f8 call 40036220 <__errno>
40023244: 01 00 00 00 nop
40023248: 10 80 00 1c b 400232b8 <fchown+0xb8>
4002324c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
40023250: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
40023254: 80 a0 60 00 cmp %g1, 0
40023258: 02 80 00 15 be 400232ac <fchown+0xac> <== NEVER TAKEN
4002325c: 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 );
40023260: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40023264: c2 00 40 00 ld [ %g1 ], %g1
40023268: 9f c0 40 00 call %g1
4002326c: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
40023270: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40023274: 90 07 60 14 add %i5, 0x14, %o0
40023278: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4002327c: 92 10 00 19 mov %i1, %o1
40023280: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40023284: 9f c0 40 00 call %g1
40023288: 94 10 00 1a mov %i2, %o2
4002328c: 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;
40023290: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40023294: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40023298: c2 00 60 04 ld [ %g1 + 4 ], %g1
4002329c: 9f c0 40 00 call %g1
400232a0: 01 00 00 00 nop
400232a4: 81 c7 e0 08 ret
400232a8: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
400232ac: 40 00 4b dd call 40036220 <__errno> <== NOT EXECUTED
400232b0: 01 00 00 00 nop <== NOT EXECUTED
400232b4: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
400232b8: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
400232bc: 81 c7 e0 08 ret
400232c0: 91 e8 3f ff restore %g0, -1, %o0
40030740 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
40030740: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
40030744: 05 10 00 da sethi %hi(0x40036800), %g2
40030748: c4 00 a1 6c ld [ %g2 + 0x16c ], %g2 ! 4003696c <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
4003074c: 82 07 a0 4c add %fp, 0x4c, %g1
40030750: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40030754: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40030758: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4003075c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
40030760: 80 a6 00 02 cmp %i0, %g2
40030764: 1a 80 00 0c bcc 40030794 <fcntl+0x54>
40030768: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
4003076c: 85 2e 20 03 sll %i0, 3, %g2
40030770: b1 2e 20 06 sll %i0, 6, %i0
40030774: b0 26 00 02 sub %i0, %g2, %i0
40030778: 05 10 01 1d sethi %hi(0x40047400), %g2
4003077c: fa 00 a0 50 ld [ %g2 + 0x50 ], %i5 ! 40047450 <rtems_libio_iops>
40030780: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40030784: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
40030788: 80 8a 21 00 btst 0x100, %o0
4003078c: 12 80 00 06 bne 400307a4 <fcntl+0x64>
40030790: 80 a6 60 09 cmp %i1, 9
40030794: 7f ff be 6c call 40020144 <__errno>
40030798: 01 00 00 00 nop
4003079c: 10 80 00 5d b 40030910 <fcntl+0x1d0>
400307a0: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
400307a4: 18 80 00 58 bgu 40030904 <fcntl+0x1c4>
400307a8: 85 2e 60 02 sll %i1, 2, %g2
400307ac: 07 10 00 c1 sethi %hi(0x40030400), %g3
400307b0: 86 10 e3 18 or %g3, 0x318, %g3 ! 40030718 <_calloc_r+0x14>
400307b4: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
400307b8: 81 c0 80 00 jmp %g2
400307bc: 01 00 00 00 nop
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
400307c0: 7f ff 5c d5 call 40007b14 <rtems_libio_allocate>
400307c4: 01 00 00 00 nop
if (diop != NULL) {
400307c8: b8 92 20 00 orcc %o0, 0, %i4
400307cc: 02 80 00 62 be 40030954 <fcntl+0x214>
400307d0: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
400307d4: 7f ff 5c ba call 40007abc <rtems_libio_to_fcntl_flags>
400307d8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
400307dc: f4 07 20 10 ld [ %i4 + 0x10 ], %i2
rtems_libio_t *diop = rtems_libio_allocate();
if (diop != NULL) {
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
oflag &= ~O_CREAT;
400307e0: b6 0a 3d ff and %o0, -513, %i3
diop->flags |= rtems_libio_fcntl_flags( oflag );
400307e4: 7f ff 5c a9 call 40007a88 <rtems_libio_fcntl_flags>
400307e8: 90 10 00 1b mov %i3, %o0
400307ec: 90 12 00 1a or %o0, %i2, %o0
400307f0: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400307f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
400307f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400307fc: c2 00 40 00 ld [ %g1 ], %g1
40030800: 9f c0 40 00 call %g1
40030804: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40030808: 92 07 60 14 add %i5, 0x14, %o1
4003080c: 7f ff 96 15 call 40016060 <rtems_filesystem_location_clone>
40030810: 90 07 20 14 add %i4, 0x14, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40030814: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40030818: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4003081c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40030820: 9f c0 40 00 call %g1
40030824: 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 );
40030828: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4003082c: 90 10 00 1c mov %i4, %o0
40030830: c2 00 40 00 ld [ %g1 ], %g1
40030834: 92 10 20 00 clr %o1
40030838: 94 10 00 1b mov %i3, %o2
4003083c: 9f c0 40 00 call %g1
40030840: 96 10 20 00 clr %o3
if ( rv == 0 ) {
40030844: b0 92 20 00 orcc %o0, 0, %i0
40030848: 12 80 00 11 bne 4003088c <fcntl+0x14c> <== NEVER TAKEN
4003084c: 03 10 01 1d sethi %hi(0x40047400), %g1
rv = diop - rtems_libio_iops;
40030850: f0 00 60 50 ld [ %g1 + 0x50 ], %i0 ! 40047450 <rtems_libio_iops>
40030854: b8 27 00 18 sub %i4, %i0, %i4
40030858: b9 3f 20 03 sra %i4, 3, %i4
4003085c: 85 2f 20 03 sll %i4, 3, %g2
40030860: 83 2f 20 06 sll %i4, 6, %g1
40030864: 82 00 80 01 add %g2, %g1, %g1
40030868: 85 28 60 06 sll %g1, 6, %g2
4003086c: 82 00 40 02 add %g1, %g2, %g1
40030870: 82 00 40 1c add %g1, %i4, %g1
40030874: b1 28 60 0f sll %g1, 0xf, %i0
40030878: 82 00 40 18 add %g1, %i0, %g1
4003087c: 83 28 60 03 sll %g1, 3, %g1
40030880: b8 00 40 1c add %g1, %i4, %i4
40030884: 10 80 00 25 b 40030918 <fcntl+0x1d8>
40030888: b0 20 00 1c neg %i4, %i0
} else {
rtems_libio_free( diop );
4003088c: 7f ff 5c b9 call 40007b70 <rtems_libio_free> <== NOT EXECUTED
40030890: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
40030894: 10 80 00 22 b 4003091c <fcntl+0x1dc> <== NOT EXECUTED
40030898: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
fd2 = va_arg( ap, int );
ret = duplicate_iop( iop, fd2 );
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
4003089c: b1 32 20 0b srl %o0, 0xb, %i0
400308a0: 10 80 00 21 b 40030924 <fcntl+0x1e4>
400308a4: b0 0e 20 01 and %i0, 1, %i0
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
400308a8: c2 00 40 00 ld [ %g1 ], %g1
400308ac: 80 a0 60 00 cmp %g1, 0
400308b0: 22 80 00 0e be,a 400308e8 <fcntl+0x1a8>
400308b4: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
400308b8: 10 80 00 0c b 400308e8 <fcntl+0x1a8>
400308bc: 90 12 28 00 or %o0, 0x800, %o0
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
400308c0: 7f ff 5c 7f call 40007abc <rtems_libio_to_fcntl_flags>
400308c4: 01 00 00 00 nop
400308c8: 10 80 00 14 b 40030918 <fcntl+0x1d8>
400308cc: b0 10 00 08 mov %o0, %i0
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
400308d0: 7f ff 5c 6e call 40007a88 <rtems_libio_fcntl_flags>
400308d4: d0 00 40 00 ld [ %g1 ], %o0
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
400308d8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400308dc: 90 0a 22 01 and %o0, 0x201, %o0
400308e0: 82 08 7d fe and %g1, -514, %g1
400308e4: 90 12 00 01 or %o0, %g1, %o0
400308e8: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
400308ec: 10 80 00 0e b 40030924 <fcntl+0x1e4>
400308f0: b0 10 20 00 clr %i0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
400308f4: 7f ff be 14 call 40020144 <__errno>
400308f8: 01 00 00 00 nop
400308fc: 10 80 00 05 b 40030910 <fcntl+0x1d0>
40030900: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
ret = -1;
break;
default:
errno = EINVAL;
40030904: 7f ff be 10 call 40020144 <__errno>
40030908: 01 00 00 00 nop
4003090c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40030910: 10 80 00 10 b 40030950 <fcntl+0x210>
40030914: c2 22 00 00 st %g1, [ %o0 ]
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
40030918: 80 a6 20 00 cmp %i0, 0
4003091c: 06 80 00 0e bl 40030954 <fcntl+0x214> <== NEVER TAKEN
40030920: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
40030924: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40030928: 90 10 00 1d mov %i5, %o0
4003092c: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
40030930: 9f c0 40 00 call %g1
40030934: 92 10 00 19 mov %i1, %o1
if (err) {
40030938: ba 92 20 00 orcc %o0, 0, %i5
4003093c: 02 80 00 06 be 40030954 <fcntl+0x214> <== ALWAYS TAKEN
40030940: 01 00 00 00 nop
errno = err;
40030944: 7f ff be 00 call 40020144 <__errno> <== NOT EXECUTED
40030948: 01 00 00 00 nop <== NOT EXECUTED
4003094c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
40030950: b0 10 3f ff mov -1, %i0
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
40030954: 81 c7 e0 08 ret
40030958: 81 e8 00 00 restore
40003934 <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
40003934: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40003938: 03 10 00 58 sethi %hi(0x40016000), %g1
4000393c: c2 00 61 e4 ld [ %g1 + 0x1e4 ], %g1 ! 400161e4 <rtems_libio_number_iops>
40003940: 80 a6 00 01 cmp %i0, %g1
40003944: 1a 80 00 0d bcc 40003978 <fdatasync+0x44>
40003948: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
4000394c: b1 2e 20 06 sll %i0, 6, %i0
40003950: b0 26 00 01 sub %i0, %g1, %i0
40003954: 03 10 00 5a sethi %hi(0x40016800), %g1
40003958: d0 00 63 3c ld [ %g1 + 0x33c ], %o0 ! 40016b3c <rtems_libio_iops>
4000395c: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open(iop);
40003960: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40003964: 80 88 61 00 btst 0x100, %g1
40003968: 02 80 00 04 be 40003978 <fdatasync+0x44> <== NEVER TAKEN
4000396c: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40003970: 32 80 00 08 bne,a 40003990 <fdatasync+0x5c>
40003974: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
40003978: 40 00 2f 37 call 4000f654 <__errno>
4000397c: b0 10 3f ff mov -1, %i0
40003980: 82 10 20 09 mov 9, %g1
40003984: c2 22 00 00 st %g1, [ %o0 ]
40003988: 81 c7 e0 08 ret
4000398c: 81 e8 00 00 restore
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
40003990: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40003994: 9f c0 40 00 call %g1
40003998: 01 00 00 00 nop
}
4000399c: 81 c7 e0 08 ret
400039a0: 91 e8 00 08 restore %g0, %o0, %o0
4000d030 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d030: 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) {
4000d034: 3b 10 00 8a sethi %hi(0x40022800), %i5
4000d038: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %g1 ! 400229c8 <pipe_semaphore>
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d03c: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4000d040: 80 a0 60 00 cmp %g1, 0
4000d044: 02 80 00 0c be 4000d074 <fifo_open+0x44>
4000d048: b8 17 61 c8 or %i5, 0x1c8, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000d04c: 03 10 00 8a sethi %hi(0x40022800), %g1
4000d050: d0 00 61 c8 ld [ %g1 + 0x1c8 ], %o0 ! 400229c8 <pipe_semaphore>
4000d054: 92 10 20 00 clr %o1
4000d058: 7f ff ed 2a call 40008500 <rtems_semaphore_obtain>
4000d05c: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
4000d060: 80 a2 20 00 cmp %o0, 0
4000d064: 22 80 01 00 be,a 4000d464 <fifo_open+0x434> <== ALWAYS TAKEN
4000d068: fa 06 c0 00 ld [ %i3 ], %i5
return 0;
} else {
return -ENOMEM;
4000d06c: 81 c7 e0 08 ret <== NOT EXECUTED
4000d070: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000d074: 03 10 00 8a sethi %hi(0x40022800), %g1
4000d078: d0 00 63 48 ld [ %g1 + 0x348 ], %o0 ! 40022b48 <rtems_libio_semaphore>
4000d07c: 92 10 20 00 clr %o1
4000d080: 7f ff ed 20 call 40008500 <rtems_semaphore_obtain>
4000d084: 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) {
4000d088: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %g1
4000d08c: 80 a0 60 00 cmp %g1, 0
4000d090: 12 80 00 0a bne 4000d0b8 <fifo_open+0x88> <== NEVER TAKEN
4000d094: ba 10 20 00 clr %i5
sc = rtems_semaphore_create(
4000d098: 11 14 12 54 sethi %hi(0x50495000), %o0
4000d09c: 92 10 20 01 mov 1, %o1
4000d0a0: 90 12 20 45 or %o0, 0x45, %o0
4000d0a4: 94 10 20 54 mov 0x54, %o2
4000d0a8: 96 10 20 00 clr %o3
4000d0ac: 7f ff ec 78 call 4000828c <rtems_semaphore_create>
4000d0b0: 98 10 00 1c mov %i4, %o4
4000d0b4: ba 10 00 08 mov %o0, %i5
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000d0b8: 03 10 00 8a sethi %hi(0x40022800), %g1
4000d0bc: 7f ff ed 5a call 40008624 <rtems_semaphore_release>
4000d0c0: d0 00 63 48 ld [ %g1 + 0x348 ], %o0 ! 40022b48 <rtems_libio_semaphore>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4000d0c4: 80 a7 60 00 cmp %i5, 0
4000d0c8: 02 bf ff e1 be 4000d04c <fifo_open+0x1c>
4000d0cc: b0 10 3f f4 mov -12, %i0
4000d0d0: 81 c7 e0 08 ret
4000d0d4: 81 e8 00 00 restore
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4000d0d8: 7f ff dc d7 call 40004434 <malloc>
4000d0dc: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
4000d0e0: ba 92 20 00 orcc %o0, 0, %i5
4000d0e4: 02 80 00 e4 be 4000d474 <fifo_open+0x444> <== NEVER TAKEN
4000d0e8: 92 10 20 00 clr %o1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4000d0ec: 40 00 12 05 call 40011900 <memset>
4000d0f0: 94 10 20 34 mov 0x34, %o2
pipe->Size = PIPE_BUF;
4000d0f4: 82 10 22 00 mov 0x200, %g1
pipe->Buffer = malloc(pipe->Size);
4000d0f8: 90 10 22 00 mov 0x200, %o0
4000d0fc: 7f ff dc ce call 40004434 <malloc>
4000d100: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (! pipe->Buffer)
4000d104: 80 a2 20 00 cmp %o0, 0
4000d108: 02 80 00 40 be 4000d208 <fifo_open+0x1d8> <== NEVER TAKEN
4000d10c: d0 27 40 00 st %o0, [ %i5 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
4000d110: 39 10 00 88 sethi %hi(0x40022000), %i4
4000d114: d0 4f 22 bc ldsb [ %i4 + 0x2bc ], %o0 ! 400222bc <c.7174>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4000d118: 35 14 12 5c sethi %hi(0x50497000), %i2
4000d11c: 82 16 a2 00 or %i2, 0x200, %g1 ! 50497200 <RAM_END+0x10097200>
4000d120: 92 10 20 00 clr %o1
4000d124: 90 12 00 01 or %o0, %g1, %o0
4000d128: 94 10 20 00 clr %o2
4000d12c: 40 00 05 c6 call 4000e844 <rtems_barrier_create>
4000d130: 96 07 60 2c add %i5, 0x2c, %o3
4000d134: 80 a2 20 00 cmp %o0, 0
4000d138: 12 80 00 32 bne 4000d200 <fifo_open+0x1d0>
4000d13c: d0 4f 22 bc ldsb [ %i4 + 0x2bc ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4000d140: 03 14 12 5d sethi %hi(0x50497400), %g1
4000d144: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000d148: 92 10 20 00 clr %o1
4000d14c: 90 12 00 01 or %o0, %g1, %o0
4000d150: 94 10 20 00 clr %o2
4000d154: 40 00 05 bc call 4000e844 <rtems_barrier_create>
4000d158: 96 07 60 30 add %i5, 0x30, %o3
4000d15c: 80 a2 20 00 cmp %o0, 0
4000d160: 12 80 00 26 bne 4000d1f8 <fifo_open+0x1c8>
4000d164: d0 4f 22 bc ldsb [ %i4 + 0x2bc ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4000d168: b4 16 a3 00 or %i2, 0x300, %i2
4000d16c: 92 10 20 01 mov 1, %o1
4000d170: 90 12 00 1a or %o0, %i2, %o0
4000d174: 94 10 20 10 mov 0x10, %o2
4000d178: 96 10 20 00 clr %o3
4000d17c: 7f ff ec 44 call 4000828c <rtems_semaphore_create>
4000d180: 98 07 60 28 add %i5, 0x28, %o4
4000d184: 80 a2 20 00 cmp %o0, 0
4000d188: 12 80 00 1a bne 4000d1f0 <fifo_open+0x1c0>
4000d18c: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
4000d190: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
4000d194: 31 10 00 8d sethi %hi(0x40023400), %i0
4000d198: 7f ff f3 6d call 40009f4c <_Objects_Get>
4000d19c: 90 16 21 e0 or %i0, 0x1e0, %o0 ! 400235e0 <_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;
4000d1a0: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000d1a4: 35 04 00 00 sethi %hi(0x10000000), %i2
4000d1a8: 82 10 40 1a or %g1, %i2, %g1
_Thread_Enable_dispatch();
4000d1ac: 7f ff f6 e9 call 4000ad50 <_Thread_Enable_dispatch>
4000d1b0: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
4000d1b4: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000d1b8: 94 07 bf fc add %fp, -4, %o2
4000d1bc: 7f ff f3 64 call 40009f4c <_Objects_Get>
4000d1c0: 90 16 21 e0 or %i0, 0x1e0, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4000d1c4: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000d1c8: b4 10 40 1a or %g1, %i2, %i2
_Thread_Enable_dispatch();
4000d1cc: 7f ff f6 e1 call 4000ad50 <_Thread_Enable_dispatch>
4000d1d0: f4 22 20 4c st %i2, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4000d1d4: c2 0f 22 bc ldub [ %i4 + 0x2bc ], %g1
4000d1d8: c4 4f 22 bc ldsb [ %i4 + 0x2bc ], %g2
4000d1dc: 80 a0 a0 7a cmp %g2, 0x7a
4000d1e0: 12 80 00 a7 bne 4000d47c <fifo_open+0x44c>
4000d1e4: 82 00 60 01 inc %g1
c = 'a';
4000d1e8: 10 80 00 a5 b 4000d47c <fifo_open+0x44c>
4000d1ec: 82 10 20 61 mov 0x61, %g1
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4000d1f0: 40 00 05 c4 call 4000e900 <rtems_barrier_delete>
4000d1f4: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
4000d1f8: 40 00 05 c2 call 4000e900 <rtems_barrier_delete>
4000d1fc: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
4000d200: 7f ff db 79 call 40003fe4 <free>
4000d204: d0 07 40 00 ld [ %i5 ], %o0
err_buf:
free(pipe);
4000d208: 7f ff db 77 call 40003fe4 <free>
4000d20c: 90 10 00 1d mov %i5, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000d210: 10 80 00 13 b 4000d25c <fifo_open+0x22c>
4000d214: b0 10 3f f4 mov -12, %i0
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4000d218: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000d21c: 92 10 20 00 clr %o1
4000d220: 7f ff ec b8 call 40008500 <rtems_semaphore_obtain>
4000d224: 94 10 20 00 clr %o2
err = -EINTR;
if (*pipep == NULL) {
4000d228: c2 06 c0 00 ld [ %i3 ], %g1
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4000d22c: 80 a0 00 08 cmp %g0, %o0
4000d230: b0 60 20 00 subx %g0, 0, %i0
err = -EINTR;
if (*pipep == NULL) {
4000d234: 80 a0 60 00 cmp %g1, 0
4000d238: 12 80 00 09 bne 4000d25c <fifo_open+0x22c>
4000d23c: b0 0e 3f fc and %i0, -4, %i0
if (err)
4000d240: 80 a6 20 00 cmp %i0, 0
4000d244: 22 80 00 06 be,a 4000d25c <fifo_open+0x22c> <== ALWAYS TAKEN
4000d248: fa 26 c0 00 st %i5, [ %i3 ]
pipe_free(pipe);
4000d24c: 7f ff ff 41 call 4000cf50 <pipe_free> <== NOT EXECUTED
4000d250: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000d254: 10 80 00 03 b 4000d260 <fifo_open+0x230> <== NOT EXECUTED
4000d258: 03 10 00 8a sethi %hi(0x40022800), %g1 <== NOT EXECUTED
4000d25c: 03 10 00 8a sethi %hi(0x40022800), %g1
4000d260: 7f ff ec f1 call 40008624 <rtems_semaphore_release>
4000d264: d0 00 61 c8 ld [ %g1 + 0x1c8 ], %o0 ! 400229c8 <pipe_semaphore>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
4000d268: 80 a6 20 00 cmp %i0, 0
4000d26c: 12 80 00 86 bne 4000d484 <fifo_open+0x454>
4000d270: 01 00 00 00 nop
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4000d274: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000d278: 82 08 60 06 and %g1, 6, %g1
4000d27c: 80 a0 60 04 cmp %g1, 4
4000d280: 02 80 00 2e be 4000d338 <fifo_open+0x308>
4000d284: fa 06 c0 00 ld [ %i3 ], %i5
4000d288: 80 a0 60 06 cmp %g1, 6
4000d28c: 02 80 00 56 be 4000d3e4 <fifo_open+0x3b4>
4000d290: 80 a0 60 02 cmp %g1, 2
4000d294: 12 80 00 6a bne 4000d43c <fifo_open+0x40c> <== NEVER TAKEN
4000d298: 01 00 00 00 nop
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4000d29c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d2a0: 82 00 60 01 inc %g1
4000d2a4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000d2a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d2ac: 84 00 60 01 add %g1, 1, %g2
4000d2b0: 80 a0 60 00 cmp %g1, 0
4000d2b4: 12 80 00 05 bne 4000d2c8 <fifo_open+0x298> <== NEVER TAKEN
4000d2b8: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
4000d2bc: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000d2c0: 40 00 05 b9 call 4000e9a4 <rtems_barrier_release>
4000d2c4: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
4000d2c8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000d2cc: 80 a0 60 00 cmp %g1, 0
4000d2d0: 12 80 00 5b bne 4000d43c <fifo_open+0x40c>
4000d2d4: 01 00 00 00 nop
/* Not an error */
if (LIBIO_NODELAY(iop))
4000d2d8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000d2dc: 80 88 60 01 btst 1, %g1
4000d2e0: 12 80 00 57 bne 4000d43c <fifo_open+0x40c>
4000d2e4: 01 00 00 00 nop
break;
prevCounter = pipe->writerCounter;
4000d2e8: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4000d2ec: 7f ff ec ce call 40008624 <rtems_semaphore_release>
4000d2f0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
4000d2f4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000d2f8: 40 00 05 c1 call 4000e9fc <rtems_barrier_wait>
4000d2fc: 92 10 20 00 clr %o1
4000d300: 80 a2 20 00 cmp %o0, 0
4000d304: 12 80 00 52 bne 4000d44c <fifo_open+0x41c> <== NEVER TAKEN
4000d308: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
4000d30c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000d310: 7f ff ec 7c call 40008500 <rtems_semaphore_obtain>
4000d314: 94 10 20 00 clr %o2
4000d318: 80 a2 20 00 cmp %o0, 0
4000d31c: 32 80 00 4d bne,a 4000d450 <fifo_open+0x420> <== NEVER TAKEN
4000d320: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
4000d324: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d328: 80 a7 00 01 cmp %i4, %g1
4000d32c: 02 bf ff f0 be 4000d2ec <fifo_open+0x2bc> <== NEVER TAKEN
4000d330: 01 00 00 00 nop
4000d334: 30 80 00 42 b,a 4000d43c <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4000d338: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d33c: 82 00 60 01 inc %g1
4000d340: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000d344: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000d348: 84 00 60 01 add %g1, 1, %g2
4000d34c: 80 a0 60 00 cmp %g1, 0
4000d350: 12 80 00 05 bne 4000d364 <fifo_open+0x334> <== NEVER TAKEN
4000d354: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
4000d358: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000d35c: 40 00 05 92 call 4000e9a4 <rtems_barrier_release>
4000d360: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000d364: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d368: 80 a0 60 00 cmp %g1, 0
4000d36c: 12 80 00 34 bne 4000d43c <fifo_open+0x40c>
4000d370: 01 00 00 00 nop
4000d374: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000d378: 80 88 60 01 btst 1, %g1
4000d37c: 22 80 00 07 be,a 4000d398 <fifo_open+0x368>
4000d380: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
PIPE_UNLOCK(pipe);
4000d384: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000d388: 7f ff ec a7 call 40008624 <rtems_semaphore_release>
4000d38c: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
4000d390: 10 80 00 31 b 4000d454 <fifo_open+0x424>
4000d394: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4000d398: 7f ff ec a3 call 40008624 <rtems_semaphore_release>
4000d39c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
4000d3a0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000d3a4: 40 00 05 96 call 4000e9fc <rtems_barrier_wait>
4000d3a8: 92 10 20 00 clr %o1
4000d3ac: 80 a2 20 00 cmp %o0, 0
4000d3b0: 12 80 00 27 bne 4000d44c <fifo_open+0x41c> <== NEVER TAKEN
4000d3b4: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
4000d3b8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000d3bc: 7f ff ec 51 call 40008500 <rtems_semaphore_obtain>
4000d3c0: 94 10 20 00 clr %o2
4000d3c4: 80 a2 20 00 cmp %o0, 0
4000d3c8: 32 80 00 22 bne,a 4000d450 <fifo_open+0x420> <== NEVER TAKEN
4000d3cc: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
4000d3d0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d3d4: 80 a7 00 01 cmp %i4, %g1
4000d3d8: 02 bf ff f0 be 4000d398 <fifo_open+0x368> <== NEVER TAKEN
4000d3dc: 01 00 00 00 nop
4000d3e0: 30 80 00 17 b,a 4000d43c <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4000d3e4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d3e8: 82 00 60 01 inc %g1
4000d3ec: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000d3f0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d3f4: 84 00 60 01 add %g1, 1, %g2
4000d3f8: 80 a0 60 00 cmp %g1, 0
4000d3fc: 12 80 00 05 bne 4000d410 <fifo_open+0x3e0> <== NEVER TAKEN
4000d400: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
4000d404: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000d408: 40 00 05 67 call 4000e9a4 <rtems_barrier_release>
4000d40c: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
4000d410: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d414: 82 00 60 01 inc %g1
4000d418: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000d41c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000d420: 84 00 60 01 add %g1, 1, %g2
4000d424: 80 a0 60 00 cmp %g1, 0
4000d428: 12 80 00 05 bne 4000d43c <fifo_open+0x40c> <== NEVER TAKEN
4000d42c: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
4000d430: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000d434: 40 00 05 5c call 4000e9a4 <rtems_barrier_release>
4000d438: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
4000d43c: 7f ff ec 7a call 40008624 <rtems_semaphore_release>
4000d440: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
return 0;
4000d444: 81 c7 e0 08 ret
4000d448: 81 e8 00 00 restore
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
4000d44c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4000d450: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000d454: 7f ff fe ca call 4000cf7c <pipe_release>
4000d458: 92 10 00 19 mov %i1, %o1
return err;
4000d45c: 81 c7 e0 08 ret
4000d460: 81 e8 00 00 restore
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
if (pipe == NULL) {
4000d464: 80 a7 60 00 cmp %i5, 0
4000d468: 32 bf ff 6d bne,a 4000d21c <fifo_open+0x1ec>
4000d46c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000d470: 30 bf ff 1a b,a 4000d0d8 <fifo_open+0xa8>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000d474: 10 bf ff 7a b 4000d25c <fifo_open+0x22c> <== NOT EXECUTED
4000d478: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4000d47c: 10 bf ff 67 b 4000d218 <fifo_open+0x1e8>
4000d480: c2 2f 22 bc stb %g1, [ %i4 + 0x2bc ]
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
4000d484: 81 c7 e0 08 ret
4000d488: 81 e8 00 00 restore
40009394 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
40009394: 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);
40009398: 03 10 00 51 sethi %hi(0x40014400), %g1
4000939c: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40014788 <rtems_libio_number_iops>
400093a0: 80 a6 00 01 cmp %i0, %g1
400093a4: 2a 80 00 03 bcs,a 400093b0 <fpathconf+0x1c>
400093a8: 83 2e 20 03 sll %i0, 3, %g1
400093ac: 30 80 00 0a b,a 400093d4 <fpathconf+0x40>
iop = rtems_libio_iop(fd);
400093b0: b1 2e 20 06 sll %i0, 6, %i0
400093b4: b0 26 00 01 sub %i0, %g1, %i0
400093b8: 03 10 00 54 sethi %hi(0x40015000), %g1
400093bc: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 ! 400150c0 <rtems_libio_iops>
400093c0: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_is_open(iop);
400093c4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
400093c8: 80 88 61 00 btst 0x100, %g1
400093cc: 32 80 00 06 bne,a 400093e4 <fpathconf+0x50> <== ALWAYS TAKEN
400093d0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
400093d4: 40 00 08 d4 call 4000b724 <__errno>
400093d8: 01 00 00 00 nop
400093dc: 10 80 00 32 b 400094a4 <fpathconf+0x110>
400093e0: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
400093e4: 80 a6 60 0b cmp %i1, 0xb
400093e8: 18 80 00 2c bgu 40009498 <fpathconf+0x104>
400093ec: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
400093f0: b3 2e 60 02 sll %i1, 2, %i1
400093f4: 05 10 00 24 sethi %hi(0x40009000), %g2
400093f8: 84 10 a3 64 or %g2, 0x364, %g2 ! 40009364 <_close_r+0x10>
400093fc: c4 00 80 19 ld [ %g2 + %i1 ], %g2
40009400: 81 c0 80 00 jmp %g2
40009404: 01 00 00 00 nop
case _PC_LINK_MAX:
return_value = the_limits->link_max;
40009408: f0 00 40 00 ld [ %g1 ], %i0
break;
4000940c: 81 c7 e0 08 ret
40009410: 81 e8 00 00 restore
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
40009414: f0 00 60 04 ld [ %g1 + 4 ], %i0
break;
40009418: 81 c7 e0 08 ret
4000941c: 81 e8 00 00 restore
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
40009420: f0 00 60 08 ld [ %g1 + 8 ], %i0
break;
40009424: 81 c7 e0 08 ret
40009428: 81 e8 00 00 restore
case _PC_NAME_MAX:
return_value = the_limits->name_max;
4000942c: f0 00 60 0c ld [ %g1 + 0xc ], %i0
break;
40009430: 81 c7 e0 08 ret
40009434: 81 e8 00 00 restore
case _PC_PATH_MAX:
return_value = the_limits->path_max;
40009438: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
break;
4000943c: 81 c7 e0 08 ret
40009440: 81 e8 00 00 restore
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
40009444: f0 00 60 14 ld [ %g1 + 0x14 ], %i0
break;
40009448: 81 c7 e0 08 ret
4000944c: 81 e8 00 00 restore
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
40009450: f0 00 60 1c ld [ %g1 + 0x1c ], %i0
break;
40009454: 81 c7 e0 08 ret
40009458: 81 e8 00 00 restore
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
4000945c: f0 00 60 20 ld [ %g1 + 0x20 ], %i0
break;
40009460: 81 c7 e0 08 ret
40009464: 81 e8 00 00 restore
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
40009468: f0 00 60 2c ld [ %g1 + 0x2c ], %i0
break;
4000946c: 81 c7 e0 08 ret
40009470: 81 e8 00 00 restore
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
40009474: f0 00 60 18 ld [ %g1 + 0x18 ], %i0
break;
40009478: 81 c7 e0 08 ret
4000947c: 81 e8 00 00 restore
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
40009480: f0 00 60 24 ld [ %g1 + 0x24 ], %i0
break;
40009484: 81 c7 e0 08 ret
40009488: 81 e8 00 00 restore
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
4000948c: f0 00 60 28 ld [ %g1 + 0x28 ], %i0
break;
40009490: 81 c7 e0 08 ret
40009494: 81 e8 00 00 restore
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40009498: 40 00 08 a3 call 4000b724 <__errno>
4000949c: 01 00 00 00 nop
400094a0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
400094a4: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
400094a8: 81 c7 e0 08 ret
400094ac: 91 e8 3f ff restore %g0, -1, %o0
40002fcc <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40002fcc: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
40002fd0: 03 10 00 78 sethi %hi(0x4001e000), %g1
40002fd4: 82 10 60 80 or %g1, 0x80, %g1 ! 4001e080 <rtems_malloc_statistics>
40002fd8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
40002fdc: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
40002fe0: 84 00 a0 01 inc %g2
if ( !ptr )
40002fe4: 80 a6 20 00 cmp %i0, 0
40002fe8: 02 80 00 21 be 4000306c <free+0xa0>
40002fec: 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()) &&
40002ff0: 03 10 00 79 sethi %hi(0x4001e400), %g1
40002ff4: c2 00 63 08 ld [ %g1 + 0x308 ], %g1 ! 4001e708 <_System_state_Current>
40002ff8: 80 a0 60 03 cmp %g1, 3
40002ffc: 12 80 00 09 bne 40003020 <free+0x54> <== NEVER TAKEN
40003000: 03 10 00 77 sethi %hi(0x4001dc00), %g1
!malloc_is_system_state_OK() ) {
40003004: 40 00 00 78 call 400031e4 <malloc_is_system_state_OK>
40003008: 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()) &&
4000300c: 80 8a 20 ff btst 0xff, %o0
40003010: 12 80 00 04 bne 40003020 <free+0x54>
40003014: 03 10 00 77 sethi %hi(0x4001dc00), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
40003018: 40 00 00 8c call 40003248 <malloc_deferred_free>
4000301c: 81 e8 00 00 restore
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40003020: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1
40003024: 80 a0 60 00 cmp %g1, 0
40003028: 02 80 00 06 be 40003040 <free+0x74>
4000302c: 3b 10 00 75 sethi %hi(0x4001d400), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
40003030: c2 00 60 08 ld [ %g1 + 8 ], %g1
40003034: 9f c0 40 00 call %g1
40003038: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
4000303c: 3b 10 00 75 sethi %hi(0x4001d400), %i5
40003040: d0 07 62 a0 ld [ %i5 + 0x2a0 ], %o0 ! 4001d6a0 <RTEMS_Malloc_Heap>
40003044: 40 00 17 16 call 40008c9c <_Protected_heap_Free>
40003048: 92 10 00 19 mov %i1, %o1
4000304c: 80 8a 20 ff btst 0xff, %o0
40003050: 12 80 00 07 bne 4000306c <free+0xa0>
40003054: c2 07 62 a0 ld [ %i5 + 0x2a0 ], %g1
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
40003058: 31 10 00 70 sethi %hi(0x4001c000), %i0
4000305c: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
40003060: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
40003064: 40 00 03 68 call 40003e04 <printk>
40003068: 91 ee 22 00 restore %i0, 0x200, %o0
4000306c: 81 c7 e0 08 ret
40003070: 81 e8 00 00 restore
4001a8fc <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
4001a8fc: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
4001a900: 80 a6 60 00 cmp %i1, 0
4001a904: 32 80 00 06 bne,a 4001a91c <fstat+0x20> <== ALWAYS TAKEN
4001a908: 03 10 00 75 sethi %hi(0x4001d400), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
4001a90c: 7f ff d0 58 call 4000ea6c <__errno> <== NOT EXECUTED
4001a910: 01 00 00 00 nop <== NOT EXECUTED
4001a914: 10 80 00 12 b 4001a95c <fstat+0x60> <== NOT EXECUTED
4001a918: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
4001a91c: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1
4001a920: 80 a6 00 01 cmp %i0, %g1
4001a924: 1a 80 00 0b bcc 4001a950 <fstat+0x54>
4001a928: 83 2e 20 03 sll %i0, 3, %g1
4001a92c: b1 2e 20 06 sll %i0, 6, %i0
4001a930: b0 26 00 01 sub %i0, %g1, %i0
4001a934: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001a938: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 4001e070 <rtems_libio_iops>
4001a93c: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
4001a940: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001a944: 80 88 61 00 btst 0x100, %g1
4001a948: 12 80 00 08 bne 4001a968 <fstat+0x6c>
4001a94c: 94 10 20 48 mov 0x48, %o2
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
4001a950: 7f ff d0 47 call 4000ea6c <__errno>
4001a954: 01 00 00 00 nop
4001a958: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4001a95c: c2 22 00 00 st %g1, [ %o0 ]
4001a960: 81 c7 e0 08 ret
4001a964: 91 e8 3f ff restore %g0, -1, %o0
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
4001a968: 90 10 00 19 mov %i1, %o0
4001a96c: 7f ff d2 ce call 4000f4a4 <memset>
4001a970: 92 10 20 00 clr %o1
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
4001a974: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001a978: 90 06 20 14 add %i0, 0x14, %o0
4001a97c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4001a980: 9f c0 40 00 call %g1
4001a984: 92 10 00 19 mov %i1, %o1
}
4001a988: 81 c7 e0 08 ret
4001a98c: 91 e8 00 08 restore %g0, %o0, %o0
40002f18 <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) {
40002f18: 03 10 00 67 sethi %hi(0x40019c00), %g1
40002f1c: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 40019e58 <disktab_size>
40002f20: 80 a2 00 01 cmp %o0, %g1
40002f24: 1a 80 00 1e bcc 40002f9c <get_disk_entry+0x84> <== NEVER TAKEN
40002f28: 03 10 00 67 sethi %hi(0x40019c00), %g1
40002f2c: c2 00 62 5c ld [ %g1 + 0x25c ], %g1 ! 40019e5c <disktab>
40002f30: 80 a0 60 00 cmp %g1, 0
40002f34: 22 80 00 1b be,a 40002fa0 <get_disk_entry+0x88> <== NEVER TAKEN
40002f38: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_disk_device_table *dtab = disktab + major;
40002f3c: 91 2a 20 03 sll %o0, 3, %o0
40002f40: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
40002f44: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40002f48: 80 a2 40 02 cmp %o1, %g2
40002f4c: 3a 80 00 15 bcc,a 40002fa0 <get_disk_entry+0x88> <== NEVER TAKEN
40002f50: 90 10 20 00 clr %o0 <== NOT EXECUTED
40002f54: c2 00 40 08 ld [ %g1 + %o0 ], %g1
40002f58: 80 a0 60 00 cmp %g1, 0
40002f5c: 02 80 00 10 be 40002f9c <get_disk_entry+0x84> <== NEVER TAKEN
40002f60: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
40002f64: 80 a2 a0 01 cmp %o2, 1
40002f68: 02 80 00 0e be 40002fa0 <get_disk_entry+0x88>
40002f6c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
40002f70: 80 a2 20 00 cmp %o0, 0
40002f74: 02 80 00 0b be 40002fa0 <get_disk_entry+0x88> <== NEVER TAKEN
40002f78: 01 00 00 00 nop
if (!dd->deleted) {
40002f7c: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
40002f80: 80 a0 60 00 cmp %g1, 0
40002f84: 32 80 00 07 bne,a 40002fa0 <get_disk_entry+0x88>
40002f88: 90 10 20 00 clr %o0
++dd->uses;
40002f8c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40002f90: 82 00 60 01 inc %g1
40002f94: 81 c3 e0 08 retl
40002f98: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
40002f9c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
40002fa0: 81 c3 e0 08 retl
40004280 <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,
40004280: 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);
40004284: 40 00 04 fd call 40005678 <malloc>
40004288: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
4000428c: 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)
40004290: 80 a2 20 00 cmp %o0, 0
40004294: 02 80 00 0f be 400042d0 <get_sector.part.0+0x50> <== NEVER TAKEN
40004298: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
4000429c: 90 10 00 18 mov %i0, %o0
400042a0: 92 07 60 04 add %i5, 4, %o1
400042a4: 40 00 07 97 call 40006100 <read>
400042a8: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
400042ac: 80 a2 22 00 cmp %o0, 0x200
400042b0: 22 80 00 06 be,a 400042c8 <get_sector.part.0+0x48> <== ALWAYS TAKEN
400042b4: f2 27 40 00 st %i1, [ %i5 ]
{
free(s);
400042b8: 40 00 03 5f call 40005034 <free> <== NOT EXECUTED
400042bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
400042c0: 10 80 00 04 b 400042d0 <get_sector.part.0+0x50> <== NOT EXECUTED
400042c4: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
}
s->sector_num = sector_num;
*sector = s;
400042c8: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
400042cc: 82 10 20 00 clr %g1
}
400042d0: 81 c7 e0 08 ret
400042d4: 91 e8 00 01 restore %g0, %g1, %o0
40030984 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
40030984: 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 );
40030988: 03 10 00 da sethi %hi(0x40036800), %g1
4003098c: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 4003696c <rtems_libio_number_iops>
40030990: 80 a6 00 01 cmp %i0, %g1
40030994: 1a 80 00 08 bcc 400309b4 <getdents+0x30> <== NEVER TAKEN
40030998: ba 10 20 00 clr %i5
4003099c: 83 2e 20 03 sll %i0, 3, %g1
400309a0: b1 2e 20 06 sll %i0, 6, %i0
400309a4: b0 26 00 01 sub %i0, %g1, %i0
400309a8: 03 10 01 1d sethi %hi(0x40047400), %g1
400309ac: fa 00 60 50 ld [ %g1 + 0x50 ], %i5 ! 40047450 <rtems_libio_iops>
400309b0: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
400309b4: 7f ff 63 10 call 400095f4 <rtems_filesystem_node_type>
400309b8: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
400309bc: 80 a2 20 00 cmp %o0, 0
400309c0: 22 80 00 08 be,a 400309e0 <getdents+0x5c>
400309c4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_set_errno_and_return_minus_one( ENOTDIR );
400309c8: 7f ff bd df call 40020144 <__errno>
400309cc: b0 10 3f ff mov -1, %i0
400309d0: 82 10 20 14 mov 0x14, %g1
400309d4: c2 22 00 00 st %g1, [ %o0 ]
400309d8: 81 c7 e0 08 ret
400309dc: 81 e8 00 00 restore
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
400309e0: 90 10 00 1d mov %i5, %o0
400309e4: c2 00 60 08 ld [ %g1 + 8 ], %g1
400309e8: 92 10 00 19 mov %i1, %o1
400309ec: 9f c0 40 00 call %g1
400309f0: 94 10 00 1a mov %i2, %o2
}
400309f4: 81 c7 e0 08 ret
400309f8: 91 e8 00 08 restore %g0, %o0, %o0
4002382c <init_etc_passwd_group>:
/**
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
4002382c: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
40023830: 03 10 01 8a sethi %hi(0x40062800), %g1
40023834: c4 48 62 38 ldsb [ %g1 + 0x238 ], %g2 ! 40062a38 <etc_passwd_initted.7068>
40023838: 80 a0 a0 00 cmp %g2, 0
4002383c: 12 80 00 2f bne 400238f8 <init_etc_passwd_group+0xcc>
40023840: 84 10 20 01 mov 1, %g2
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
40023844: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
40023848: c4 28 62 38 stb %g2, [ %g1 + 0x238 ]
mkdir("/etc", 0777);
4002384c: 11 10 01 68 sethi %hi(0x4005a000), %o0
40023850: 7f ff 7d b9 call 40002f34 <mkdir>
40023854: 90 12 20 b0 or %o0, 0xb0, %o0 ! 4005a0b0 <rtems_status_assoc+0x168>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
40023858: 3b 10 01 68 sethi %hi(0x4005a000), %i5
4002385c: 13 10 01 79 sethi %hi(0x4005e400), %o1
40023860: 90 17 60 b8 or %i5, 0xb8, %o0
40023864: 40 00 4d 1f call 40036ce0 <fopen>
40023868: 92 12 63 c0 or %o1, 0x3c0, %o1
4002386c: 80 a2 20 00 cmp %o0, 0
40023870: 22 80 00 03 be,a 4002387c <init_etc_passwd_group+0x50>
40023874: 90 17 60 b8 or %i5, 0xb8, %o0
40023878: 30 80 00 0b b,a 400238a4 <init_etc_passwd_group+0x78>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
4002387c: 13 10 01 5e sethi %hi(0x40057800), %o1
40023880: 40 00 4d 18 call 40036ce0 <fopen>
40023884: 92 12 63 80 or %o1, 0x380, %o1 ! 40057b80 <rtems_rtc_shell_usage+0x4e8>
40023888: ba 92 20 00 orcc %o0, 0, %i5
4002388c: 02 80 00 08 be 400238ac <init_etc_passwd_group+0x80> <== NEVER TAKEN
40023890: 11 10 01 68 sethi %hi(0x4005a000), %o0
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
40023894: 92 10 00 1d mov %i5, %o1
40023898: 40 00 4d 75 call 40036e6c <fputs>
4002389c: 90 12 20 c8 or %o0, 0xc8, %o0
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
400238a0: 90 10 00 1d mov %i5, %o0
400238a4: 40 00 4a b1 call 40036368 <fclose>
400238a8: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
400238ac: 3b 10 01 68 sethi %hi(0x4005a000), %i5
400238b0: 13 10 01 79 sethi %hi(0x4005e400), %o1
400238b4: 90 17 61 30 or %i5, 0x130, %o0
400238b8: 40 00 4d 0a call 40036ce0 <fopen>
400238bc: 92 12 63 c0 or %o1, 0x3c0, %o1
400238c0: b0 92 20 00 orcc %o0, 0, %i0
400238c4: 12 80 00 0b bne 400238f0 <init_etc_passwd_group+0xc4>
400238c8: 90 17 61 30 or %i5, 0x130, %o0
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
400238cc: 13 10 01 5e sethi %hi(0x40057800), %o1
400238d0: 40 00 4d 04 call 40036ce0 <fopen>
400238d4: 92 12 63 80 or %o1, 0x380, %o1 ! 40057b80 <rtems_rtc_shell_usage+0x4e8>
400238d8: b0 92 20 00 orcc %o0, 0, %i0
400238dc: 02 80 00 07 be 400238f8 <init_etc_passwd_group+0xcc> <== NEVER TAKEN
400238e0: 11 10 01 68 sethi %hi(0x4005a000), %o0
fprintf( fp, "root:x:0:root\n"
400238e4: 92 10 00 18 mov %i0, %o1
400238e8: 40 00 4d 61 call 40036e6c <fputs>
400238ec: 90 12 21 40 or %o0, 0x140, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
400238f0: 40 00 4a 9e call 40036368 <fclose>
400238f4: 81 e8 00 00 restore
400238f8: 81 c7 e0 08 ret
400238fc: 81 e8 00 00 restore
40005a34 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
40005a34: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
40005a38: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
40005a3c: 80 88 60 20 btst 0x20, %g1
40005a40: 32 80 00 02 bne,a 40005a48 <iproc+0x14> <== NEVER TAKEN
40005a44: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
40005a48: 80 88 62 00 btst 0x200, %g1
40005a4c: 02 80 00 0c be 40005a7c <iproc+0x48>
40005a50: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
40005a54: 05 10 00 76 sethi %hi(0x4001d800), %g2
40005a58: c4 00 a0 a0 ld [ %g2 + 0xa0 ], %g2 ! 4001d8a0 <__ctype_ptr__>
40005a5c: 84 00 80 18 add %g2, %i0, %g2
40005a60: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
40005a64: 84 08 a0 03 and %g2, 3, %g2
40005a68: 80 a0 a0 01 cmp %g2, 1
40005a6c: 22 80 00 02 be,a 40005a74 <iproc+0x40>
40005a70: b0 06 20 20 add %i0, 0x20, %i0
40005a74: b0 0e 20 ff and %i0, 0xff, %i0
if (c == '\r') {
40005a78: 80 a6 20 0d cmp %i0, 0xd
40005a7c: 12 80 00 0b bne 40005aa8 <iproc+0x74>
40005a80: 80 a6 20 0a cmp %i0, 0xa
if (tty->termios.c_iflag & IGNCR)
40005a84: 80 88 60 80 btst 0x80, %g1
40005a88: 02 80 00 04 be 40005a98 <iproc+0x64> <== ALWAYS TAKEN
40005a8c: 80 88 61 00 btst 0x100, %g1
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
40005a90: 81 c7 e0 08 ret <== NOT EXECUTED
40005a94: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
40005a98: 32 80 00 0d bne,a 40005acc <iproc+0x98> <== ALWAYS TAKEN
40005a9c: 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)) {
40005aa0: 10 80 00 0c b 40005ad0 <iproc+0x9c> <== NOT EXECUTED
40005aa4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
40005aa8: 12 80 00 07 bne 40005ac4 <iproc+0x90>
40005aac: 80 a6 20 00 cmp %i0, 0
40005ab0: 80 88 60 40 btst 0x40, %g1
40005ab4: 32 80 00 06 bne,a 40005acc <iproc+0x98> <== NEVER TAKEN
40005ab8: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40005abc: 10 80 00 05 b 40005ad0 <iproc+0x9c>
40005ac0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005ac4: 02 80 00 51 be 40005c08 <iproc+0x1d4> <== NEVER TAKEN
40005ac8: 03 10 00 75 sethi %hi(0x4001d400), %g1
40005acc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005ad0: 80 88 60 02 btst 2, %g1
40005ad4: 22 80 00 4d be,a 40005c08 <iproc+0x1d4>
40005ad8: 03 10 00 75 sethi %hi(0x4001d400), %g1
if (c == tty->termios.c_cc[VERASE]) {
40005adc: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
40005ae0: 80 a0 80 18 cmp %g2, %i0
40005ae4: 32 80 00 08 bne,a 40005b04 <iproc+0xd0>
40005ae8: c4 0e 60 44 ldub [ %i1 + 0x44 ], %g2
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
40005aec: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40005af0: 80 a0 60 00 cmp %g1, 0
40005af4: 02 80 00 57 be 40005c50 <iproc+0x21c>
40005af8: 90 10 00 19 mov %i1, %o0
40005afc: 10 80 00 1d b 40005b70 <iproc+0x13c>
40005b00: 92 10 20 00 clr %o1
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
40005b04: 80 a0 80 18 cmp %g2, %i0
40005b08: 32 80 00 1d bne,a 40005b7c <iproc+0x148>
40005b0c: c4 0e 60 45 ldub [ %i1 + 0x45 ], %g2
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
40005b10: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40005b14: 80 a0 a0 00 cmp %g2, 0
40005b18: 02 80 00 4e be 40005c50 <iproc+0x21c> <== NEVER TAKEN
40005b1c: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
40005b20: 12 80 00 04 bne 40005b30 <iproc+0xfc> <== ALWAYS TAKEN
40005b24: 90 10 00 19 mov %i1, %o0
tty->ccount = 0;
40005b28: 10 80 00 4a b 40005c50 <iproc+0x21c> <== NOT EXECUTED
40005b2c: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
40005b30: 80 88 60 10 btst 0x10, %g1
40005b34: 12 80 00 0f bne 40005b70 <iproc+0x13c> <== ALWAYS TAKEN
40005b38: 92 10 20 01 mov 1, %o1
tty->ccount = 0;
40005b3c: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
40005b40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005b44: 7f ff ff 2d call 400057f8 <echo> <== NOT EXECUTED
40005b48: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
40005b4c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
40005b50: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40005b54: 22 80 00 42 be,a 40005c5c <iproc+0x228> <== NOT EXECUTED
40005b58: b0 10 20 00 clr %i0 <== NOT EXECUTED
echo ('\n', tty);
40005b5c: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
40005b60: 7f ff ff 26 call 400057f8 <echo> <== NOT EXECUTED
40005b64: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
40005b68: 81 c7 e0 08 ret <== NOT EXECUTED
40005b6c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40005b70: 7f ff ff 43 call 4000587c <erase.part.2>
40005b74: b0 10 20 00 clr %i0
40005b78: 30 80 00 39 b,a 40005c5c <iproc+0x228>
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
40005b7c: 80 a0 80 18 cmp %g2, %i0
40005b80: 02 80 00 36 be 40005c58 <iproc+0x224> <== NEVER TAKEN
40005b84: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
40005b88: 32 80 00 0d bne,a 40005bbc <iproc+0x188>
40005b8c: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
if (tty->termios.c_lflag & (ECHO | ECHONL))
40005b90: 80 88 60 48 btst 0x48, %g1
40005b94: 22 80 00 06 be,a 40005bac <iproc+0x178> <== NEVER TAKEN
40005b98: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40005b9c: 90 10 20 0a mov 0xa, %o0
40005ba0: 7f ff ff 16 call 400057f8 <echo>
40005ba4: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
40005ba8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40005bac: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
40005bb0: 86 10 20 0a mov 0xa, %g3
40005bb4: 10 80 00 12 b 40005bfc <iproc+0x1c8>
40005bb8: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
40005bbc: 80 a0 80 18 cmp %g2, %i0
40005bc0: 02 80 00 07 be 40005bdc <iproc+0x1a8> <== NEVER TAKEN
40005bc4: 80 88 60 08 btst 8, %g1
40005bc8: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
40005bcc: 80 a0 80 18 cmp %g2, %i0
40005bd0: 32 80 00 0e bne,a 40005c08 <iproc+0x1d4> <== ALWAYS TAKEN
40005bd4: 03 10 00 75 sethi %hi(0x4001d400), %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
40005bd8: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40005bdc: 22 80 00 06 be,a 40005bf4 <iproc+0x1c0> <== NOT EXECUTED
40005be0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40005be4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005be8: 7f ff ff 04 call 400057f8 <echo> <== NOT EXECUTED
40005bec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
40005bf0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40005bf4: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
40005bf8: f0 28 80 01 stb %i0, [ %g2 + %g1 ] <== NOT EXECUTED
40005bfc: 82 00 60 01 inc %g1
40005c00: 10 80 00 16 b 40005c58 <iproc+0x224>
40005c04: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
40005c08: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40005c0c: c2 00 63 24 ld [ %g1 + 0x324 ], %g1
40005c10: 82 00 7f ff add %g1, -1, %g1
40005c14: 80 a0 80 01 cmp %g2, %g1
40005c18: 3a 80 00 11 bcc,a 40005c5c <iproc+0x228> <== NEVER TAKEN
40005c1c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
40005c20: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005c24: 80 88 60 08 btst 8, %g1
40005c28: 22 80 00 06 be,a 40005c40 <iproc+0x20c> <== NEVER TAKEN
40005c2c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40005c30: 90 10 00 18 mov %i0, %o0
40005c34: 7f ff fe f1 call 400057f8 <echo>
40005c38: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
40005c3c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40005c40: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
40005c44: f0 28 80 01 stb %i0, [ %g2 + %g1 ]
40005c48: 82 00 60 01 inc %g1
40005c4c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
return 0;
40005c50: 81 c7 e0 08 ret
40005c54: 91 e8 20 00 restore %g0, 0, %o0
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
40005c58: b0 10 20 01 mov 1, %i0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
40005c5c: 81 c7 e0 08 ret
40005c60: 81 e8 00 00 restore
4001ad34 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
4001ad34: 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() )
4001ad38: 7f ff ff 1b call 4001a9a4 <getpid>
4001ad3c: 01 00 00 00 nop
4001ad40: 80 a6 00 08 cmp %i0, %o0
4001ad44: 02 80 00 06 be 4001ad5c <killinfo+0x28>
4001ad48: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
4001ad4c: 7f ff cf 48 call 4000ea6c <__errno>
4001ad50: 01 00 00 00 nop
4001ad54: 10 80 00 a6 b 4001afec <killinfo+0x2b8>
4001ad58: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
/*
* Validate the signal passed.
*/
if ( !sig )
4001ad5c: 32 80 00 03 bne,a 4001ad68 <killinfo+0x34>
4001ad60: ba 06 7f ff add %i1, -1, %i5
4001ad64: 30 80 00 04 b,a 4001ad74 <killinfo+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001ad68: 80 a7 60 1f cmp %i5, 0x1f
4001ad6c: 28 80 00 06 bleu,a 4001ad84 <killinfo+0x50>
4001ad70: 83 2e 60 02 sll %i1, 2, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
4001ad74: 7f ff cf 3e call 4000ea6c <__errno>
4001ad78: 01 00 00 00 nop
4001ad7c: 10 80 00 9c b 4001afec <killinfo+0x2b8>
4001ad80: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
4001ad84: 85 2e 60 04 sll %i1, 4, %g2
4001ad88: 84 20 80 01 sub %g2, %g1, %g2
4001ad8c: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001ad90: 82 10 63 70 or %g1, 0x370, %g1 ! 4001e770 <_POSIX_signals_Vectors>
4001ad94: 82 00 40 02 add %g1, %g2, %g1
4001ad98: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001ad9c: 80 a0 60 01 cmp %g1, 1
4001ada0: 02 80 00 9f be 4001b01c <killinfo+0x2e8>
4001ada4: 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 ) )
4001ada8: 02 80 00 06 be 4001adc0 <killinfo+0x8c>
4001adac: 80 a6 60 08 cmp %i1, 8
4001adb0: 02 80 00 04 be 4001adc0 <killinfo+0x8c>
4001adb4: 80 a6 60 0b cmp %i1, 0xb
4001adb8: 12 80 00 08 bne 4001add8 <killinfo+0xa4>
4001adbc: 82 10 20 01 mov 1, %g1
return pthread_kill( pthread_self(), sig );
4001adc0: 40 00 01 33 call 4001b28c <pthread_self>
4001adc4: 01 00 00 00 nop
4001adc8: 40 00 00 f4 call 4001b198 <pthread_kill>
4001adcc: 92 10 00 19 mov %i1, %o1
4001add0: 81 c7 e0 08 ret
4001add4: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
4001add8: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
4001addc: c2 27 bf f8 st %g1, [ %fp + -8 ]
if ( !value ) {
4001ade0: 80 a6 a0 00 cmp %i2, 0
4001ade4: 12 80 00 04 bne 4001adf4 <killinfo+0xc0>
4001ade8: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_value.sival_int = 0;
4001adec: 10 80 00 04 b 4001adfc <killinfo+0xc8>
4001adf0: c0 27 bf fc clr [ %fp + -4 ]
} else {
siginfo->si_value = *value;
4001adf4: c2 06 80 00 ld [ %i2 ], %g1
4001adf8: 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;
4001adfc: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001ae00: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 4001e200 <_Thread_Dispatch_disable_level>
++level;
4001ae04: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4001ae08: c4 20 62 00 st %g2, [ %g1 + 0x200 ]
*/
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 );
4001ae0c: 11 10 00 75 sethi %hi(0x4001d400), %o0
4001ae10: 7f ff b2 bb call 400078fc <_API_extensions_Add_post_switch>
4001ae14: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 4001d7e8 <_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;
4001ae18: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001ae1c: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 4001e720 <_Per_CPU_Information+0x10>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
4001ae20: c4 02 21 50 ld [ %o0 + 0x150 ], %g2
4001ae24: c4 00 a0 d0 ld [ %g2 + 0xd0 ], %g2
4001ae28: 80 af 40 02 andncc %i5, %g2, %g0
4001ae2c: 12 80 00 52 bne 4001af74 <killinfo+0x240>
4001ae30: 03 10 00 7a sethi %hi(0x4001e800), %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 );
4001ae34: 05 10 00 7a sethi %hi(0x4001e800), %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001ae38: c2 00 60 fc ld [ %g1 + 0xfc ], %g1
4001ae3c: 10 80 00 0a b 4001ae64 <killinfo+0x130>
4001ae40: 84 10 a1 00 or %g2, 0x100, %g2
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
4001ae44: 80 8f 40 04 btst %i5, %g4
4001ae48: 12 80 00 4a bne 4001af70 <killinfo+0x23c>
4001ae4c: c6 00 61 50 ld [ %g1 + 0x150 ], %g3
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
4001ae50: c6 00 e0 d0 ld [ %g3 + 0xd0 ], %g3
4001ae54: 80 af 40 03 andncc %i5, %g3, %g0
4001ae58: 12 80 00 47 bne 4001af74 <killinfo+0x240>
4001ae5c: 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 ) {
4001ae60: 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 );
4001ae64: 80 a0 40 02 cmp %g1, %g2
4001ae68: 32 bf ff f7 bne,a 4001ae44 <killinfo+0x110>
4001ae6c: c8 00 60 30 ld [ %g1 + 0x30 ], %g4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001ae70: 03 10 00 75 sethi %hi(0x4001d400), %g1
4001ae74: c6 08 62 1c ldub [ %g1 + 0x21c ], %g3 ! 4001d61c <rtems_maximum_priority>
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4001ae78: b8 10 20 02 mov 2, %i4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001ae7c: 86 00 e0 01 inc %g3
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
4001ae80: 82 10 20 00 clr %g1
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
4001ae84: 1b 10 00 78 sethi %hi(0x4001e000), %o5
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
4001ae88: 35 04 00 00 sethi %hi(0x10000000), %i2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
4001ae8c: 85 2f 20 02 sll %i4, 2, %g2
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
4001ae90: 88 13 61 64 or %o5, 0x164, %g4
4001ae94: c4 01 00 02 ld [ %g4 + %g2 ], %g2
4001ae98: 80 a0 a0 00 cmp %g2, 0
4001ae9c: 22 80 00 2f be,a 4001af58 <killinfo+0x224> <== NEVER TAKEN
4001aea0: b8 07 20 01 inc %i4 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
4001aea4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001aea8: b6 10 20 01 mov 1, %i3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
4001aeac: d8 10 a0 10 lduh [ %g2 + 0x10 ], %o4
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001aeb0: 10 80 00 26 b 4001af48 <killinfo+0x214>
4001aeb4: d6 00 a0 1c ld [ %g2 + 0x1c ], %o3
the_thread = (Thread_Control *) object_table[ index ];
4001aeb8: c4 02 c0 02 ld [ %o3 + %g2 ], %g2
if ( !the_thread )
4001aebc: 80 a0 a0 00 cmp %g2, 0
4001aec0: 22 80 00 22 be,a 4001af48 <killinfo+0x214>
4001aec4: b6 06 e0 01 inc %i3
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
4001aec8: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
4001aecc: 80 a1 00 03 cmp %g4, %g3
4001aed0: 38 80 00 1e bgu,a 4001af48 <killinfo+0x214>
4001aed4: b6 06 e0 01 inc %i3
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
4001aed8: f0 00 a1 50 ld [ %g2 + 0x150 ], %i0
4001aedc: f0 06 20 d0 ld [ %i0 + 0xd0 ], %i0
4001aee0: 80 af 40 18 andncc %i5, %i0, %g0
4001aee4: 22 80 00 19 be,a 4001af48 <killinfo+0x214>
4001aee8: b6 06 e0 01 inc %i3
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
4001aeec: 80 a1 00 03 cmp %g4, %g3
4001aef0: 2a 80 00 14 bcs,a 4001af40 <killinfo+0x20c>
4001aef4: 86 10 00 04 mov %g4, %g3
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
4001aef8: 80 a0 60 00 cmp %g1, 0
4001aefc: 22 80 00 13 be,a 4001af48 <killinfo+0x214> <== NEVER TAKEN
4001af00: b6 06 e0 01 inc %i3 <== NOT EXECUTED
4001af04: de 00 60 10 ld [ %g1 + 0x10 ], %o7
4001af08: 80 a3 e0 00 cmp %o7, 0
4001af0c: 22 80 00 0f be,a 4001af48 <killinfo+0x214> <== NEVER TAKEN
4001af10: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
4001af14: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
4001af18: 80 a6 20 00 cmp %i0, 0
4001af1c: 22 80 00 09 be,a 4001af40 <killinfo+0x20c>
4001af20: 86 10 00 04 mov %g4, %g3
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
4001af24: 80 8b c0 1a btst %o7, %i2
4001af28: 32 80 00 08 bne,a 4001af48 <killinfo+0x214>
4001af2c: b6 06 e0 01 inc %i3
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4001af30: 80 8e 00 1a btst %i0, %i2
4001af34: 22 80 00 05 be,a 4001af48 <killinfo+0x214>
4001af38: b6 06 e0 01 inc %i3
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
4001af3c: 86 10 00 04 mov %g4, %g3
4001af40: 82 10 00 02 mov %g2, %g1
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001af44: b6 06 e0 01 inc %i3
4001af48: 80 a6 c0 0c cmp %i3, %o4
4001af4c: 08 bf ff db bleu 4001aeb8 <killinfo+0x184>
4001af50: 85 2e e0 02 sll %i3, 2, %g2
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4001af54: b8 07 20 01 inc %i4
4001af58: 80 a7 20 04 cmp %i4, 4
4001af5c: 12 bf ff cd bne 4001ae90 <killinfo+0x15c>
4001af60: 85 2f 20 02 sll %i4, 2, %g2
}
}
}
}
if ( interested ) {
4001af64: 80 a0 60 00 cmp %g1, 0
4001af68: 02 80 00 0c be 4001af98 <killinfo+0x264>
4001af6c: 01 00 00 00 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
4001af70: 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 ) ) {
4001af74: 92 10 00 19 mov %i1, %o1
4001af78: 40 00 00 36 call 4001b050 <_POSIX_signals_Unblock_thread>
4001af7c: 94 07 bf f4 add %fp, -12, %o2
4001af80: 80 8a 20 ff btst 0xff, %o0
4001af84: 02 80 00 05 be 4001af98 <killinfo+0x264>
4001af88: 01 00 00 00 nop
_Thread_Enable_dispatch();
4001af8c: 7f ff ba 25 call 40009820 <_Thread_Enable_dispatch>
4001af90: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4001af94: 30 80 00 23 b,a 4001b020 <killinfo+0x2ec>
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
4001af98: 40 00 00 24 call 4001b028 <_POSIX_signals_Set_process_signals>
4001af9c: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
4001afa0: 83 2e 60 02 sll %i1, 2, %g1
4001afa4: b3 2e 60 04 sll %i1, 4, %i1
4001afa8: b2 26 40 01 sub %i1, %g1, %i1
4001afac: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001afb0: 82 10 63 70 or %g1, 0x370, %g1 ! 4001e770 <_POSIX_signals_Vectors>
4001afb4: c2 00 40 19 ld [ %g1 + %i1 ], %g1
4001afb8: 80 a0 60 02 cmp %g1, 2
4001afbc: 12 bf ff f4 bne 4001af8c <killinfo+0x258>
4001afc0: 11 10 00 7a sethi %hi(0x4001e800), %o0
psiginfo = (POSIX_signals_Siginfo_node *)
4001afc4: 7f ff b2 b3 call 40007a90 <_Chain_Get>
4001afc8: 90 12 20 f0 or %o0, 0xf0, %o0 ! 4001e8f0 <_POSIX_signals_Inactive_siginfo>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
4001afcc: ba 92 20 00 orcc %o0, 0, %i5
4001afd0: 12 80 00 0a bne 4001aff8 <killinfo+0x2c4>
4001afd4: 92 07 bf f4 add %fp, -12, %o1
_Thread_Enable_dispatch();
4001afd8: 7f ff ba 12 call 40009820 <_Thread_Enable_dispatch>
4001afdc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
4001afe0: 7f ff ce a3 call 4000ea6c <__errno>
4001afe4: 01 00 00 00 nop
4001afe8: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
4001afec: c2 22 00 00 st %g1, [ %o0 ]
4001aff0: 81 c7 e0 08 ret
4001aff4: 91 e8 3f ff restore %g0, -1, %o0
}
psiginfo->Info = *siginfo;
4001aff8: 90 07 60 08 add %i5, 8, %o0
4001affc: 7f ff d0 ed call 4000f3b0 <memcpy>
4001b000: 94 10 20 0c mov 0xc, %o2
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001b004: 11 10 00 7a sethi %hi(0x4001e800), %o0
4001b008: 92 10 00 1d mov %i5, %o1
4001b00c: 90 12 21 68 or %o0, 0x168, %o0
4001b010: 7f ff b2 94 call 40007a60 <_Chain_Append>
4001b014: 90 02 00 19 add %o0, %i1, %o0
4001b018: 30 bf ff dd b,a 4001af8c <killinfo+0x258>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
4001b01c: b0 10 20 00 clr %i0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
4001b020: 81 c7 e0 08 ret
4001b024: 81 e8 00 00 restore
4000384c <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
4000384c: 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()))
40003850: 03 10 00 79 sethi %hi(0x4001e400), %g1
40003854: c2 00 63 08 ld [ %g1 + 0x308 ], %g1 ! 4001e708 <_System_state_Current>
40003858: 80 a0 60 03 cmp %g1, 3
4000385c: 12 80 00 16 bne 400038b4 <libc_wrapup+0x68> <== NEVER TAKEN
40003860: 03 10 00 72 sethi %hi(0x4001c800), %g1
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
40003864: 39 10 00 76 sethi %hi(0x4001d800), %i4
40003868: fa 00 63 f0 ld [ %g1 + 0x3f0 ], %i5
4000386c: c2 07 20 a8 ld [ %i4 + 0xa8 ], %g1
40003870: 80 a0 40 1d cmp %g1, %i5
40003874: 22 80 00 06 be,a 4000388c <libc_wrapup+0x40>
40003878: 3b 10 00 76 sethi %hi(0x4001d800), %i5
_wrapup_reent(_global_impure_ptr);
4000387c: 40 00 2f ab call 4000f728 <_wrapup_reent>
40003880: 90 10 00 1d mov %i5, %o0
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
40003884: fa 27 20 a8 st %i5, [ %i4 + 0xa8 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
40003888: 3b 10 00 76 sethi %hi(0x4001d800), %i5
4000388c: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1 ! 4001d8a8 <_impure_ptr>
40003890: 40 00 2c c9 call 4000ebb4 <fclose>
40003894: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
40003898: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
4000389c: 40 00 2c c6 call 4000ebb4 <fclose>
400038a0: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
400038a4: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
400038a8: f0 00 60 0c ld [ %g1 + 0xc ], %i0
400038ac: 40 00 2c c2 call 4000ebb4 <fclose>
400038b0: 81 e8 00 00 restore
400038b4: 81 c7 e0 08 ret <== NOT EXECUTED
400038b8: 81 e8 00 00 restore <== NOT EXECUTED
4000331c <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
4000331c: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
40003320: 03 10 00 78 sethi %hi(0x4001e000), %g1
40003324: 82 10 60 80 or %g1, 0x80, %g1 ! 4001e080 <rtems_malloc_statistics>
40003328: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000332c: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
40003330: 7f ff ff b9 call 40003214 <malloc_deferred_frees_process>
40003334: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
40003338: 80 a6 20 00 cmp %i0, 0
4000333c: 12 80 00 04 bne 4000334c <malloc+0x30>
40003340: 03 10 00 79 sethi %hi(0x4001e400), %g1
return (void *) 0;
40003344: 10 80 00 32 b 4000340c <malloc+0xf0>
40003348: ba 10 20 00 clr %i5
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4000334c: c2 00 63 08 ld [ %g1 + 0x308 ], %g1
40003350: 80 a0 60 03 cmp %g1, 3
40003354: 02 80 00 0c be 40003384 <malloc+0x68>
40003358: 39 10 00 75 sethi %hi(0x4001d400), %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 );
4000335c: d0 07 22 a0 ld [ %i4 + 0x2a0 ], %o0 ! 4001d6a0 <RTEMS_Malloc_Heap>
40003360: 92 10 00 18 mov %i0, %o1
40003364: 94 10 20 00 clr %o2
40003368: 40 00 16 3f call 40008c64 <_Protected_heap_Allocate_aligned_with_boundary>
4000336c: 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 ) {
40003370: ba 92 20 00 orcc %o0, 0, %i5
40003374: 12 80 00 18 bne 400033d4 <malloc+0xb8>
40003378: 03 10 00 77 sethi %hi(0x4001dc00), %g1
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
4000337c: 10 80 00 09 b 400033a0 <malloc+0x84>
40003380: d0 07 22 a0 ld [ %i4 + 0x2a0 ], %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() )
40003384: 7f ff ff 98 call 400031e4 <malloc_is_system_state_OK>
40003388: 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()) &&
4000338c: 80 8a 20 ff btst 0xff, %o0
40003390: 12 bf ff f3 bne 4000335c <malloc+0x40> <== ALWAYS TAKEN
40003394: 01 00 00 00 nop
40003398: 10 80 00 1d b 4000340c <malloc+0xf0> <== NOT EXECUTED
4000339c: ba 10 20 00 clr %i5 ! 0 <PROM_START> <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
400033a0: 03 10 00 6d sethi %hi(0x4001b400), %g1
400033a4: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 ! 4001b7a0 <rtems_malloc_extend_handler>
400033a8: 9f c0 40 00 call %g1
400033ac: 92 10 00 18 mov %i0, %o1
if ( !return_this ) {
400033b0: ba 92 20 00 orcc %o0, 0, %i5
400033b4: 12 80 00 08 bne 400033d4 <malloc+0xb8> <== NEVER TAKEN
400033b8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
errno = ENOMEM;
400033bc: 40 00 2d ac call 4000ea6c <__errno>
400033c0: b0 10 00 1d mov %i5, %i0
400033c4: 82 10 20 0c mov 0xc, %g1
400033c8: c2 22 00 00 st %g1, [ %o0 ]
400033cc: 81 c7 e0 08 ret
400033d0: 81 e8 00 00 restore
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
400033d4: c2 00 61 cc ld [ %g1 + 0x1cc ], %g1
400033d8: 80 a0 60 00 cmp %g1, 0
400033dc: 02 80 00 04 be 400033ec <malloc+0xd0>
400033e0: 90 10 00 1d mov %i5, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
400033e4: 9f c0 40 00 call %g1
400033e8: 92 10 00 18 mov %i0, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
400033ec: 03 10 00 77 sethi %hi(0x4001dc00), %g1
400033f0: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001ddd0 <rtems_malloc_statistics_helpers>
400033f4: 80 a0 60 00 cmp %g1, 0
400033f8: 22 80 00 06 be,a 40003410 <malloc+0xf4>
400033fc: b0 10 00 1d mov %i5, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
40003400: c2 00 60 04 ld [ %g1 + 4 ], %g1
40003404: 9f c0 40 00 call %g1
40003408: 90 10 00 1d mov %i5, %o0
return return_this;
}
4000340c: b0 10 00 1d mov %i5, %i0
40003410: 81 c7 e0 08 ret
40003414: 81 e8 00 00 restore
4000d130 <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
4000d130: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
4000d134: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d138: d2 00 61 e0 ld [ %g1 + 0x1e0 ], %o1 ! 4001dde0 <imfs_memfile_bytes_per_block>
4000d13c: 7f ff d6 f1 call 40002d00 <calloc>
4000d140: 90 10 20 01 mov 1, %o0
if ( memory )
4000d144: b0 92 20 00 orcc %o0, 0, %i0
4000d148: 02 80 00 05 be 4000d15c <memfile_alloc_block+0x2c> <== NEVER TAKEN
4000d14c: 03 10 00 77 sethi %hi(0x4001dc00), %g1
memfile_blocks_allocated++;
4000d150: c4 00 62 f4 ld [ %g1 + 0x2f4 ], %g2 ! 4001def4 <memfile_blocks_allocated>
4000d154: 84 00 a0 01 inc %g2
4000d158: c4 20 62 f4 st %g2, [ %g1 + 0x2f4 ]
return memory;
}
4000d15c: 81 c7 e0 08 ret
4000d160: 81 e8 00 00 restore
4000dc58 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
4000dc58: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4000dc5c: 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 )
4000dc60: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
4000dc64: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
4000dc68: 06 80 00 09 bl 4000dc8c <memfile_ftruncate+0x34> <== NOT EXECUTED
4000dc6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000dc70: 32 80 00 0d bne,a 4000dca4 <memfile_ftruncate+0x4c> <== NOT EXECUTED
4000dc74: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
4000dc78: c2 07 60 54 ld [ %i5 + 0x54 ], %g1 <== NOT EXECUTED
4000dc7c: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
4000dc80: 3a 80 00 09 bcc,a 4000dca4 <memfile_ftruncate+0x4c> <== NOT EXECUTED
4000dc84: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
return IMFS_memfile_extend( the_jnode, true, length );
4000dc88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000dc8c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000dc90: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000dc94: 7f ff fe df call 4000d810 <IMFS_memfile_extend> <== NOT EXECUTED
4000dc98: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4000dc9c: 81 c7 e0 08 ret <== NOT EXECUTED
4000dca0: 91 e8 00 08 restore %g0, %o0, %o0 <== 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;
4000dca4: f4 27 60 54 st %i2, [ %i5 + 0x54 ] <== NOT EXECUTED
IMFS_update_atime( the_jnode );
4000dca8: 90 07 bf f8 add %fp, -8, %o0 <== NOT EXECUTED
4000dcac: 7f ff d4 f2 call 40003074 <gettimeofday> <== NOT EXECUTED
4000dcb0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000dcb4: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
4000dcb8: c2 27 60 40 st %g1, [ %i5 + 0x40 ] <== NOT EXECUTED
return 0;
}
4000dcbc: 81 c7 e0 08 ret <== NOT EXECUTED
4000dcc0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000dbdc <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
4000dbdc: 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)
4000dbe0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000dbe4: 80 88 60 04 btst 4, %g1
4000dbe8: 12 80 00 04 bne 4000dbf8 <memfile_open+0x1c>
4000dbec: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
4000dbf0: 81 c7 e0 08 ret
4000dbf4: 91 e8 20 00 restore %g0, 0, %o0
4000dbf8: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
4000dbfc: c2 00 40 00 ld [ %g1 ], %g1
4000dc00: 80 a0 60 05 cmp %g1, 5
4000dc04: 12 bf ff fb bne 4000dbf0 <memfile_open+0x14> <== ALWAYS TAKEN
4000dc08: 03 10 00 71 sethi %hi(0x4001c400), %g1
uint32_t count = the_jnode->info.linearfile.size;
4000dc0c: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
4000dc10: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
4000dc14: 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;
4000dc18: 82 10 62 1c or %g1, 0x21c, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
4000dc1c: c0 22 20 54 clr [ %o0 + 0x54 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
4000dc20: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
4000dc24: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
4000dc28: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
4000dc2c: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
4000dc30: 02 bf ff f0 be 4000dbf0 <memfile_open+0x14> <== NOT EXECUTED
4000dc34: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4000dc38: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000dc3c: 7f ff ff 5d call 4000d9b0 <IMFS_memfile_write> <== NOT EXECUTED
4000dc40: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
4000dc44: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
4000dc48: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000dc4c: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
4000dc50: 81 c7 e0 08 ret <== NOT EXECUTED
4000dc54: 81 e8 00 00 restore <== NOT EXECUTED
40003538 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40003538: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
4000353c: 80 a6 e0 01 cmp %i3, 1
40003540: 18 80 00 b4 bgu 40003810 <mount+0x2d8>
40003544: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
40003548: 40 00 20 a4 call 4000b7d8 <rtems_filesystem_get_mount_handler>
4000354c: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
40003550: a6 92 20 00 orcc %o0, 0, %l3
40003554: 02 80 00 af be 40003810 <mount+0x2d8>
40003558: a2 96 60 00 orcc %i1, 0, %l1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
4000355c: 12 80 00 04 bne 4000356c <mount+0x34>
40003560: 01 00 00 00 nop
40003564: 23 10 00 70 sethi %hi(0x4001c000), %l1
40003568: a2 14 62 38 or %l1, 0x238, %l1 ! 4001c238 <rtems_status_assoc+0x1a0>
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
4000356c: 40 00 32 c7 call 40010088 <strlen>
40003570: 90 10 00 1a mov %i2, %o0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
40003574: 80 a6 20 00 cmp %i0, 0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40003578: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
4000357c: 02 80 00 06 be 40003594 <mount+0x5c>
40003580: ac 02 20 01 add %o0, 1, %l6
40003584: 40 00 32 c1 call 40010088 <strlen>
40003588: 90 10 00 18 mov %i0, %o0
4000358c: 10 80 00 03 b 40003598 <mount+0x60>
40003590: a0 02 20 01 add %o0, 1, %l0
40003594: a0 10 20 00 clr %l0
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
40003598: ba 07 60 65 add %i5, 0x65, %i5
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
4000359c: 40 00 32 bb call 40010088 <strlen>
400035a0: 90 10 00 11 mov %l1, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
400035a4: 92 07 40 10 add %i5, %l0, %o1
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
400035a8: aa 02 20 01 add %o0, 1, %l5
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
400035ac: 90 10 20 01 mov 1, %o0
400035b0: 7f ff fd d4 call 40002d00 <calloc>
400035b4: 92 02 40 15 add %o1, %l5, %o1
if ( mt_entry != NULL ) {
400035b8: ba 92 20 00 orcc %o0, 0, %i5
400035bc: 02 80 00 9d be 40003830 <mount+0x2f8> <== NEVER TAKEN
400035c0: a4 07 60 64 add %i5, 0x64, %l2
rtems_filesystem_global_location_t *mt_fs_root =
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
400035c4: 92 10 00 1a mov %i2, %o1
400035c8: 90 10 00 12 mov %l2, %o0
400035cc: 40 00 2f 79 call 4000f3b0 <memcpy>
400035d0: 94 10 00 16 mov %l6, %o2
mt_entry->type = str;
400035d4: e4 27 60 34 st %l2, [ %i5 + 0x34 ]
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
rtems_filesystem_global_location_t *mt_fs_root =
400035d8: a8 07 60 40 add %i5, 0x40, %l4
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
400035dc: 80 a6 20 00 cmp %i0, 0
400035e0: 02 80 00 08 be 40003600 <mount+0xc8>
400035e4: b4 04 80 16 add %l2, %l6, %i2
memcpy( str, source_or_null, source_size );
400035e8: 90 10 00 1a mov %i2, %o0
400035ec: 92 10 00 18 mov %i0, %o1
400035f0: 40 00 2f 70 call 4000f3b0 <memcpy>
400035f4: 94 10 00 10 mov %l0, %o2
mt_entry->dev = str;
400035f8: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
400035fc: b4 06 80 10 add %i2, %l0, %i2
}
memcpy( str, target, target_size );
40003600: 92 10 00 11 mov %l1, %o1
40003604: 94 10 00 15 mov %l5, %o2
40003608: 40 00 2f 6a call 4000f3b0 <memcpy>
4000360c: 90 10 00 1a mov %i2, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
40003610: 82 10 20 01 mov 1, %g1
40003614: 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;
40003618: 03 10 00 70 sethi %hi(0x4001c000), %g1
4000361c: 82 10 62 3c or %g1, 0x23c, %g1 ! 4001c23c <rtems_filesystem_default_pathconf>
40003620: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
40003624: 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 );
40003628: 90 07 60 14 add %i5, 0x14, %o0
4000362c: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
40003630: 92 10 00 14 mov %l4, %o1
40003634: 94 10 20 01 mov 1, %o2
40003638: 96 10 20 24 mov 0x24, %o3
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
4000363c: f4 27 60 30 st %i2, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
40003640: e8 27 60 24 st %l4, [ %i5 + 0x24 ]
40003644: 40 00 11 22 call 40007acc <_Chain_Initialize>
40003648: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
4000364c: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
40003650: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40003654: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
40003658: 9f c4 c0 00 call %l3
4000365c: 92 10 00 1c mov %i4, %o1
if ( rv == 0 ) {
40003660: b0 92 20 00 orcc %o0, 0, %i0
40003664: 12 80 00 6f bne 40003820 <mount+0x2e8>
40003668: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
4000366c: 02 80 00 38 be 4000374c <mount+0x214>
40003670: 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 =
40003674: 94 10 20 1f mov 0x1f, %o2
40003678: 40 00 02 b0 call 40004138 <rtems_filesystem_eval_path_start>
4000367c: 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;
40003680: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
40003684: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40003688: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
4000368c: 9f c0 80 00 call %g2
40003690: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
40003694: 80 8a 20 ff btst 0xff, %o0
40003698: 12 80 00 22 bne 40003720 <mount+0x1e8>
4000369c: 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(
400036a0: 40 00 03 a0 call 40004520 <rtems_filesystem_location_copy_and_detach>
400036a4: 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 );
400036a8: 40 00 04 16 call 40004700 <rtems_filesystem_location_transform_to_global>
400036ac: 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 );
400036b0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
mt_entry->mt_point_node = mt_point_node;
400036b4: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
400036b8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
400036bc: 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 );
400036c0: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
400036c4: 9f c0 40 00 call %g1
400036c8: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
400036cc: b0 92 20 00 orcc %o0, 0, %i0
400036d0: 12 80 00 11 bne 40003714 <mount+0x1dc>
400036d4: 92 10 20 00 clr %o1
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
400036d8: 39 10 00 78 sethi %hi(0x4001e000), %i4
400036dc: d0 07 20 78 ld [ %i4 + 0x78 ], %o0 ! 4001e078 <rtems_libio_semaphore>
400036e0: 40 00 0e 24 call 40006f70 <rtems_semaphore_obtain>
400036e4: 94 10 20 00 clr %o2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
400036e8: 03 10 00 75 sethi %hi(0x4001d400), %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
400036ec: d0 07 20 78 ld [ %i4 + 0x78 ], %o0
400036f0: 82 10 63 0c or %g1, 0x30c, %g1
400036f4: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
400036f8: 86 00 60 04 add %g1, 4, %g3
400036fc: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
40003700: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40003704: fa 20 80 00 st %i5, [ %g2 ]
40003708: 40 00 0e 63 call 40007094 <rtems_semaphore_release>
4000370c: c4 27 60 04 st %g2, [ %i5 + 4 ]
40003710: 30 80 00 08 b,a 40003730 <mount+0x1f8>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
40003714: 40 00 03 a8 call 400045b4 <rtems_filesystem_global_location_release>
40003718: 90 10 00 1c mov %i4, %o0
4000371c: 30 80 00 05 b,a 40003730 <mount+0x1f8>
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40003720: 90 07 bf c8 add %fp, -56, %o0
40003724: 92 10 20 10 mov 0x10, %o1
40003728: 40 00 01 ee call 40003ee0 <rtems_filesystem_eval_path_error>
4000372c: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40003730: 40 00 02 be call 40004228 <rtems_filesystem_eval_path_cleanup>
40003734: 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 ) {
40003738: 80 a6 20 00 cmp %i0, 0
4000373c: 02 80 00 42 be 40003844 <mount+0x30c>
40003740: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40003744: 10 80 00 2f b 40003800 <mount+0x2c8>
40003748: c2 07 60 0c ld [ %i5 + 0xc ], %g1
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000374c: 03 10 00 78 sethi %hi(0x4001e000), %g1
40003750: d0 00 60 78 ld [ %g1 + 0x78 ], %o0 ! 4001e078 <rtems_libio_semaphore>
40003754: 92 10 20 00 clr %o1
40003758: 40 00 0e 06 call 40006f70 <rtems_semaphore_obtain>
4000375c: 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;
40003760: 05 10 00 75 sethi %hi(0x4001d400), %g2
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40003764: c6 00 a3 0c ld [ %g2 + 0x30c ], %g3 ! 4001d70c <rtems_filesystem_mount_table>
40003768: 82 10 a3 0c or %g2, 0x30c, %g1
4000376c: 84 00 60 04 add %g1, 4, %g2
40003770: 80 a0 c0 02 cmp %g3, %g2
40003774: 12 80 00 08 bne 40003794 <mount+0x25c> <== NEVER TAKEN
40003778: 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;
4000377c: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
40003780: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
40003784: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40003788: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
4000378c: 10 80 00 06 b 400037a4 <mount+0x26c>
40003790: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
40003794: 40 00 2c b6 call 4000ea6c <__errno> <== NOT EXECUTED
40003798: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000379c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
400037a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
400037a4: 03 10 00 78 sethi %hi(0x4001e000), %g1
400037a8: 40 00 0e 3b call 40007094 <rtems_semaphore_release>
400037ac: d0 00 60 78 ld [ %g1 + 0x78 ], %o0 ! 4001e078 <rtems_libio_semaphore>
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
400037b0: 80 a6 20 00 cmp %i0, 0
400037b4: 32 80 00 13 bne,a 40003800 <mount+0x2c8> <== NEVER TAKEN
400037b8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
400037bc: 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 =
400037c0: 40 00 03 9e call 40004638 <rtems_filesystem_global_location_obtain>
400037c4: 90 10 00 1d mov %i5, %o0
400037c8: 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 =
400037cc: 40 00 03 9b call 40004638 <rtems_filesystem_global_location_obtain>
400037d0: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
400037d4: 3b 10 00 75 sethi %hi(0x4001d400), %i5
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
400037d8: b8 10 00 08 mov %o0, %i4
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
400037dc: d0 07 63 2c ld [ %i5 + 0x32c ], %o0
400037e0: 92 10 00 1b mov %i3, %o1
400037e4: 40 00 03 8c call 40004614 <rtems_filesystem_global_location_assign>
400037e8: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
400037ec: d0 07 63 2c ld [ %i5 + 0x32c ], %o0
400037f0: 40 00 03 89 call 40004614 <rtems_filesystem_global_location_assign>
400037f4: 92 10 00 1c mov %i4, %o1
400037f8: 81 c7 e0 08 ret
400037fc: 81 e8 00 00 restore
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40003800: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40003804: 9f c0 40 00 call %g1
40003808: 90 10 00 1d mov %i5, %o0
4000380c: 30 80 00 05 b,a 40003820 <mount+0x2e8>
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
40003810: 40 00 2c 97 call 4000ea6c <__errno>
40003814: 01 00 00 00 nop
40003818: 10 80 00 09 b 4000383c <mount+0x304>
4000381c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
}
}
if ( rv != 0 ) {
free( mt_entry );
40003820: 7f ff fd eb call 40002fcc <free>
40003824: 90 10 00 1d mov %i5, %o0
40003828: 81 c7 e0 08 ret
4000382c: 81 e8 00 00 restore
}
} else {
errno = ENOMEM;
40003830: 40 00 2c 8f call 4000ea6c <__errno> <== NOT EXECUTED
40003834: 01 00 00 00 nop <== NOT EXECUTED
40003838: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
4000383c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
40003840: b0 10 3f ff mov -1, %i0
errno = EINVAL;
rv = -1;
}
return rv;
}
40003844: 81 c7 e0 08 ret
40003848: 81 e8 00 00 restore
40007fa4 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40007fa4: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
40007fa8: 90 96 60 00 orcc %i1, 0, %o0
40007fac: 02 80 00 09 be 40007fd0 <mount_and_make_target_path+0x2c>
40007fb0: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
40007fb4: 40 00 02 cd call 40008ae8 <rtems_mkdir>
40007fb8: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
40007fbc: 80 a2 20 00 cmp %o0, 0
40007fc0: 12 80 00 09 bne 40007fe4 <mount_and_make_target_path+0x40><== NEVER TAKEN
40007fc4: 01 00 00 00 nop
rv = mount(
40007fc8: 40 00 00 09 call 40007fec <mount>
40007fcc: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
40007fd0: 40 00 60 5d call 40020144 <__errno>
40007fd4: 01 00 00 00 nop
40007fd8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40007fdc: c2 22 00 00 st %g1, [ %o0 ]
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
40007fe0: 90 10 3f ff mov -1, %o0
} else {
errno = EINVAL;
}
return rv;
}
40007fe4: 81 c7 e0 08 ret
40007fe8: 91 e8 00 08 restore %g0, %o0, %o0
40016a9c <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
40016a9c: 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;
40016aa0: 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);
40016aa4: 92 10 20 00 clr %o1
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40016aa8: f8 00 60 08 ld [ %g1 + 8 ], %i4
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40016aac: 82 10 3f ff mov -1, %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40016ab0: 94 10 20 20 mov 0x20, %o2
40016ab4: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40016ab8: c2 27 bf 7c st %g1, [ %fp + -132 ]
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
40016abc: e0 06 20 08 ld [ %i0 + 8 ], %l0
fat_file_fd_t *fat_fd = NULL;
40016ac0: c0 27 bf 6c clr [ %fp + -148 ]
time_t time_ret = 0;
uint16_t time_val = 0;
40016ac4: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
40016ac8: 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;
40016acc: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
40016ad0: c0 27 bf 74 clr [ %fp + -140 ]
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40016ad4: 40 00 12 60 call 4001b454 <memset>
40016ad8: 90 07 bf 80 add %fp, -128, %o0
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
40016adc: 90 07 bf c0 add %fp, -64, %o0
40016ae0: 92 10 20 00 clr %o1
40016ae4: 40 00 12 5c call 4001b454 <memset>
40016ae8: 94 10 20 40 mov 0x40, %o2
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
40016aec: 80 a6 e1 04 cmp %i3, 0x104
40016af0: 24 80 00 06 ble,a 40016b08 <msdos_creat_node+0x6c> <== ALWAYS TAKEN
40016af4: 90 10 00 1a mov %i2, %o0
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
40016af8: 40 00 0f 75 call 4001a8cc <__errno> <== NOT EXECUTED
40016afc: 01 00 00 00 nop <== NOT EXECUTED
40016b00: 10 80 00 0c b 40016b30 <msdos_creat_node+0x94> <== NOT EXECUTED
40016b04: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
40016b08: 92 10 00 1b mov %i3, %o1
40016b0c: 94 07 bf 80 add %fp, -128, %o2
40016b10: 40 00 01 45 call 40017024 <msdos_long_to_short>
40016b14: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
40016b18: a4 92 20 00 orcc %o0, 0, %l2
40016b1c: 32 80 00 08 bne,a 40016b3c <msdos_creat_node+0xa0> <== ALWAYS TAKEN
40016b20: c0 2f bf 8c clrb [ %fp + -116 ]
rtems_set_errno_and_return_minus_one(EINVAL);
40016b24: 40 00 0f 6a call 4001a8cc <__errno> <== NOT EXECUTED
40016b28: 01 00 00 00 nop <== NOT EXECUTED
40016b2c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40016b30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40016b34: 10 80 00 ce b 40016e6c <msdos_creat_node+0x3d0> <== NOT EXECUTED
40016b38: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
40016b3c: 40 00 21 09 call 4001ef60 <time>
40016b40: 90 10 20 00 clr %o0
if ( time_ret == -1 )
40016b44: 80 a2 3f ff cmp %o0, -1
40016b48: 12 80 00 04 bne 40016b58 <msdos_creat_node+0xbc> <== ALWAYS TAKEN
40016b4c: 92 07 bf 6a add %fp, -150, %o1
40016b50: 10 80 00 c7 b 40016e6c <msdos_creat_node+0x3d0> <== NOT EXECUTED
40016b54: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
40016b58: 40 00 0b a0 call 400199d8 <msdos_date_unix2dos>
40016b5c: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40016b60: c2 17 bf 68 lduh [ %fp + -152 ], %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40016b64: 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);
40016b68: 83 28 60 10 sll %g1, 0x10, %g1
40016b6c: 85 30 60 08 srl %g1, 8, %g2
40016b70: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40016b74: 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);
40016b78: 84 10 80 01 or %g2, %g1, %g2
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
40016b7c: c0 27 bf 9c clr [ %fp + -100 ]
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40016b80: 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);
40016b84: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40016b88: 87 30 e0 18 srl %g3, 0x18, %g3
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
40016b8c: 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);
40016b90: 82 10 40 03 or %g1, %g3, %g1
40016b94: 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);
40016b98: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
40016b9c: 80 a6 60 00 cmp %i1, 0
40016ba0: 12 80 00 05 bne 40016bb4 <msdos_creat_node+0x118>
40016ba4: c2 37 bf 92 sth %g1, [ %fp + -110 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
40016ba8: c2 0f bf 8b ldub [ %fp + -117 ], %g1
40016bac: 10 80 00 2f b 40016c68 <msdos_creat_node+0x1cc>
40016bb0: 82 10 60 10 or %g1, 0x10, %g1
}
else if (type == MSDOS_HARD_LINK) {
40016bb4: 80 a6 60 02 cmp %i1, 2
40016bb8: 12 80 00 2b bne 40016c64 <msdos_creat_node+0x1c8> <== ALWAYS TAKEN
40016bbc: c2 0f bf 8b ldub [ %fp + -117 ], %g1
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
40016bc0: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40016bc4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40016bc8: 32 80 00 08 bne,a 40016be8 <msdos_creat_node+0x14c> <== NOT EXECUTED
40016bcc: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
40016bd0: c2 0f 20 0e ldub [ %i4 + 0xe ], %g1 <== NOT EXECUTED
40016bd4: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40016bd8: 22 80 00 04 be,a 40016be8 <msdos_creat_node+0x14c> <== NOT EXECUTED
40016bdc: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40016be0: 10 80 00 06 b 40016bf8 <msdos_creat_node+0x15c> <== NOT EXECUTED
40016be4: c4 07 20 20 ld [ %i4 + 0x20 ], %g2 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40016be8: 84 00 bf fe add %g2, -2, %g2 <== NOT EXECUTED
40016bec: 85 28 80 01 sll %g2, %g1, %g2 <== NOT EXECUTED
40016bf0: c2 07 20 34 ld [ %i4 + 0x34 ], %g1 <== NOT EXECUTED
40016bf4: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40016bf8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40016bfc: d2 0f 20 02 ldub [ %i4 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40016c00: d4 17 00 00 lduh [ %i4 ], %o2 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40016c04: 93 30 40 09 srl %g1, %o1, %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40016c08: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
40016c0c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40016c10: 92 00 80 09 add %g2, %o1, %o1 <== NOT EXECUTED
40016c14: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
40016c18: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
40016c1c: 7f ff ee 2e call 400124d4 <_fat_block_read> <== NOT EXECUTED
40016c20: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
40016c24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40016c28: 06 bf ff c3 bl 40016b34 <msdos_creat_node+0x98> <== NOT EXECUTED
40016c2c: c2 0f bf ad ldub [ %fp + -83 ], %g1 <== NOT EXECUTED
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40016c30: c2 2f bf 8d stb %g1, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40016c34: c2 17 bf ae lduh [ %fp + -82 ], %g1 <== NOT EXECUTED
40016c38: c2 37 bf 8e sth %g1, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
40016c3c: c2 17 bf b0 lduh [ %fp + -80 ], %g1 <== NOT EXECUTED
40016c40: c2 37 bf 90 sth %g1, [ %fp + -112 ] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
40016c44: c2 07 bf bc ld [ %fp + -68 ], %g1 <== NOT EXECUTED
40016c48: c2 27 bf 9c st %g1, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
40016c4c: c2 17 bf ba lduh [ %fp + -70 ], %g1 <== NOT EXECUTED
40016c50: c2 37 bf 9a sth %g1, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
40016c54: c2 17 bf b4 lduh [ %fp + -76 ], %g1 <== NOT EXECUTED
40016c58: c2 37 bf 94 sth %g1, [ %fp + -108 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40016c5c: 10 80 00 02 b 40016c64 <msdos_creat_node+0x1c8> <== NOT EXECUTED
40016c60: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40016c64: 82 10 60 20 or %g1, 0x20, %g1
40016c68: c2 2f bf 8b stb %g1, [ %fp + -117 ]
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
name_type, &dir_pos, short_node);
40016c6c: a2 07 bf 80 add %fp, -128, %l1
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
40016c70: 90 10 00 18 mov %i0, %o0
40016c74: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
40016c78: 92 10 20 01 mov 1, %o1
40016c7c: 94 10 00 1a mov %i2, %o2
40016c80: 96 10 00 1b mov %i3, %o3
40016c84: 98 10 00 12 mov %l2, %o4
40016c88: 40 00 05 fc call 40018478 <msdos_get_name_node>
40016c8c: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
40016c90: ba 92 20 00 orcc %o0, 0, %i5
40016c94: 12 80 00 76 bne 40016e6c <msdos_creat_node+0x3d0>
40016c98: 80 a6 60 00 cmp %i1, 0
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
40016c9c: 32 80 00 75 bne,a 40016e70 <msdos_creat_node+0x3d4>
40016ca0: b0 10 00 1d mov %i5, %i0
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
40016ca4: 90 10 00 1c mov %i4, %o0
40016ca8: 92 07 bf 70 add %fp, -144, %o1
40016cac: 7f ff ea 6c call 4001165c <fat_file_open>
40016cb0: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
40016cb4: ba 92 20 00 orcc %o0, 0, %i5
40016cb8: 32 80 00 6a bne,a 40016e60 <msdos_creat_node+0x3c4> <== NEVER TAKEN
40016cbc: 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;
40016cc0: fa 07 bf 6c ld [ %fp + -148 ], %i5
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40016cc4: 03 00 08 00 sethi %hi(0x200000), %g1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40016cc8: 92 10 00 11 mov %l1, %o1
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40016ccc: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40016cd0: 94 10 20 20 mov 0x20, %o2
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
40016cd4: c0 27 60 18 clr [ %i5 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
40016cd8: c0 27 60 10 clr [ %i5 + 0x10 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40016cdc: 40 00 11 a1 call 4001b360 <memcpy>
40016ce0: 90 07 bf c0 add %fp, -64, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40016ce4: 92 10 00 11 mov %l1, %o1
40016ce8: 94 10 20 20 mov 0x20, %o2
40016cec: 40 00 11 9d call 4001b360 <memcpy>
40016cf0: 90 07 bf e0 add %fp, -32, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40016cf4: 03 10 00 ad sethi %hi(0x4002b400), %g1
40016cf8: d2 00 63 84 ld [ %g1 + 0x384 ], %o1 ! 4002b784 <MSDOS_DOT_NAME>
40016cfc: 94 10 20 0b mov 0xb, %o2
40016d00: 40 00 11 98 call 4001b360 <memcpy>
40016d04: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40016d08: 03 10 00 ad sethi %hi(0x4002b400), %g1
40016d0c: d2 00 63 80 ld [ %g1 + 0x380 ], %o1 ! 4002b780 <MSDOS_DOTDOT_NAME>
40016d10: 90 07 bf e0 add %fp, -32, %o0
40016d14: 40 00 11 93 call 4001b360 <memcpy>
40016d18: 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)) &&
40016d1c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
40016d20: 80 a0 60 01 cmp %g1, 1
40016d24: 32 80 00 0e bne,a 40016d5c <msdos_creat_node+0x2c0>
40016d28: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40016d2c: c2 04 20 24 ld [ %l0 + 0x24 ], %g1
40016d30: 80 a0 60 00 cmp %g1, 0
40016d34: 32 80 00 0a bne,a 40016d5c <msdos_creat_node+0x2c0> <== NEVER TAKEN
40016d38: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
40016d3c: c2 0f 20 0e ldub [ %i4 + 0xe ], %g1
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
40016d40: 82 08 60 04 and %g1, 4, %g1
40016d44: 80 88 60 ff btst 0xff, %g1
40016d48: 22 80 00 05 be,a 40016d5c <msdos_creat_node+0x2c0> <== ALWAYS TAKEN
40016d4c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40016d50: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40016d54: 10 80 00 10 b 40016d94 <msdos_creat_node+0x2f8> <== NOT EXECUTED
40016d58: c0 37 bf f4 clrh [ %fp + -12 ] <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016d5c: 05 00 00 3f sethi %hi(0xfc00), %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
40016d60: 87 28 60 10 sll %g1, 0x10, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016d64: 84 10 a3 ff or %g2, 0x3ff, %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
40016d68: 87 30 e0 18 srl %g3, 0x18, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016d6c: 88 08 40 02 and %g1, %g2, %g4
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
40016d70: 83 30 60 10 srl %g1, 0x10, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
40016d74: 89 29 20 08 sll %g4, 8, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016d78: 84 08 40 02 and %g1, %g2, %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
40016d7c: 86 11 00 03 or %g4, %g3, %g3
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
40016d80: 85 28 a0 08 sll %g2, 8, %g2
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
40016d84: 83 30 60 08 srl %g1, 8, %g1
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
40016d88: c6 37 bf fa sth %g3, [ %fp + -6 ]
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
40016d8c: 82 10 80 01 or %g2, %g1, %g1
40016d90: c2 37 bf f4 sth %g1, [ %fp + -12 ]
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
40016d94: 90 10 00 1c mov %i4, %o0
40016d98: 92 10 00 1d mov %i5, %o1
40016d9c: 94 10 20 00 clr %o2
40016da0: 96 10 20 40 mov 0x40, %o3
40016da4: 7f ff ec 3b call 40011e90 <fat_file_write>
40016da8: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
40016dac: 80 a2 20 00 cmp %o0, 0
40016db0: 06 80 00 27 bl 40016e4c <msdos_creat_node+0x3b0> <== NEVER TAKEN
40016db4: 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;
40016db8: c2 17 20 06 lduh [ %i4 + 6 ], %g1
40016dbc: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
40016dc0: 90 10 00 1c mov %i4, %o0
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
40016dc4: 82 00 80 01 add %g2, %g1, %g1
40016dc8: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
40016dcc: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016dd0: 05 00 00 3f sethi %hi(0xfc00), %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40016dd4: 87 28 60 10 sll %g1, 0x10, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016dd8: 84 10 a3 ff or %g2, 0x3ff, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40016ddc: 87 30 e0 18 srl %g3, 0x18, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016de0: 88 08 40 02 and %g1, %g2, %g4
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
40016de4: 83 30 60 10 srl %g1, 0x10, %g1
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
40016de8: 89 29 20 08 sll %g4, 8, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016dec: 84 08 40 02 and %g1, %g2, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40016df0: 86 11 00 03 or %g4, %g3, %g3
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
40016df4: 85 28 a0 08 sll %g2, 8, %g2
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
40016df8: 83 30 60 08 srl %g1, 8, %g1
40016dfc: 82 10 80 01 or %g2, %g1, %g1
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40016e00: c6 37 bf da sth %g3, [ %fp + -38 ]
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
40016e04: c2 37 bf d4 sth %g1, [ %fp + -44 ]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
40016e08: 94 10 20 00 clr %o2
40016e0c: 96 10 20 20 mov 0x20, %o3
40016e10: 7f ff ec 20 call 40011e90 <fat_file_write>
40016e14: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
40016e18: 80 a2 20 00 cmp %o0, 0
40016e1c: 06 80 00 0d bl 40016e50 <msdos_creat_node+0x3b4> <== NEVER TAKEN
40016e20: 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);
40016e24: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40016e28: 40 00 01 45 call 4001733c <msdos_set_first_cluster_num>
40016e2c: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
40016e30: ba 92 20 00 orcc %o0, 0, %i5
40016e34: 12 80 00 08 bne 40016e54 <msdos_creat_node+0x3b8> <== NEVER TAKEN
40016e38: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
40016e3c: 7f ff eb 1e call 40011ab4 <fat_file_close>
40016e40: 90 10 00 1c mov %i4, %o0
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40016e44: 81 c7 e0 08 ret
40016e48: 91 e8 00 1d restore %g0, %i5, %o0
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
{
rc = -1;
40016e4c: 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);
40016e50: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
40016e54: 7f ff eb 18 call 40011ab4 <fat_file_close> <== NOT EXECUTED
40016e58: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
40016e5c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
40016e60: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
40016e64: 40 00 01 81 call 40017468 <msdos_set_first_char4file_name><== NOT EXECUTED
40016e68: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
return rc;
}
40016e6c: b0 10 00 1d mov %i5, %i0
40016e70: 81 c7 e0 08 ret
40016e74: 81 e8 00 00 restore
40019b24 <msdos_date_dos2unix>:
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40019b24: 85 32 60 0b srl %o1, 0xb, %g2
40019b28: 84 08 a0 1f and %g2, 0x1f, %g2
40019b2c: 87 28 a0 03 sll %g2, 3, %g3
40019b30: 83 28 a0 07 sll %g2, 7, %g1
40019b34: 82 20 40 03 sub %g1, %g3, %g1
40019b38: 85 28 60 04 sll %g1, 4, %g2
40019b3c: 84 20 80 01 sub %g2, %g1, %g2
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
40019b40: 82 0a 67 e0 and %o1, 0x7e0, %g1
40019b44: 87 30 60 04 srl %g1, 4, %g3
40019b48: 82 20 40 03 sub %g1, %g3, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40019b4c: 82 00 80 01 add %g2, %g1, %g1
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
40019b50: 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;
40019b54: 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) {
40019b58: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40019b5c: c4 10 60 22 lduh [ %g1 + 0x22 ], %g2 ! 4002c822 <lastdosdate>
40019b60: 80 a0 80 08 cmp %g2, %o0
40019b64: 02 80 00 34 be 40019c34 <msdos_date_dos2unix+0x110>
40019b68: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
40019b6c: d0 30 60 22 sth %o0, [ %g1 + 0x22 ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
40019b70: 89 32 20 09 srl %o0, 9, %g4
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
40019b74: 82 10 20 00 clr %g1
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
40019b78: 88 09 20 7f and %g4, 0x7f, %g4
for (y = 0; y < year; y++)
40019b7c: 10 80 00 07 b 40019b98 <msdos_date_dos2unix+0x74>
40019b80: 84 10 20 00 clr %g2
days += y & 0x03 ? 365 : 366;
40019b84: 80 a0 00 03 cmp %g0, %g3
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
40019b88: 84 00 a0 01 inc %g2
days += y & 0x03 ? 365 : 366;
40019b8c: 86 60 3f ff subx %g0, -1, %g3
40019b90: 86 00 e1 6d add %g3, 0x16d, %g3
40019b94: 82 00 40 03 add %g1, %g3, %g1
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
40019b98: 80 a0 80 04 cmp %g2, %g4
40019b9c: 12 bf ff fa bne 40019b84 <msdos_date_dos2unix+0x60>
40019ba0: 86 08 a0 03 and %g2, 3, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
40019ba4: 80 a0 e0 00 cmp %g3, 0
40019ba8: 22 80 00 05 be,a 40019bbc <msdos_date_dos2unix+0x98> <== ALWAYS TAKEN
40019bac: 09 10 00 b0 sethi %hi(0x4002c000), %g4
40019bb0: 09 10 00 b0 sethi %hi(0x4002c000), %g4 <== NOT EXECUTED
40019bb4: 10 80 00 03 b 40019bc0 <msdos_date_dos2unix+0x9c> <== NOT EXECUTED
40019bb8: 88 11 20 e4 or %g4, 0xe4, %g4 ! 4002c0e4 <regyear> <== NOT EXECUTED
40019bbc: 88 11 20 fc or %g4, 0xfc, %g4
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
40019bc0: 86 0a 21 e0 and %o0, 0x1e0, %g3
40019bc4: 87 30 e0 05 srl %g3, 5, %g3
if (month == 0) {
40019bc8: 80 a0 e0 00 cmp %g3, 0
40019bcc: 22 80 00 02 be,a 40019bd4 <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
40019bd0: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
40019bd4: 84 10 20 00 clr %g2
40019bd8: 10 80 00 05 b 40019bec <msdos_date_dos2unix+0xc8>
40019bdc: 86 00 ff ff add %g3, -1, %g3
days += months[m];
40019be0: da 11 00 0d lduh [ %g4 + %o5 ], %o5 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
40019be4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
days += months[m];
40019be8: 82 00 40 0d add %g1, %o5, %g1 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
40019bec: 80 a0 80 03 cmp %g2, %g3
40019bf0: 0a bf ff fc bcs 40019be0 <msdos_date_dos2unix+0xbc> <== NEVER TAKEN
40019bf4: 9b 28 a0 01 sll %g2, 1, %o5
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
40019bf8: 90 0a 20 1f and %o0, 0x1f, %o0
40019bfc: 90 02 3f ff add %o0, -1, %o0
40019c00: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
40019c04: 85 28 60 07 sll %g1, 7, %g2
40019c08: 83 28 60 09 sll %g1, 9, %g1
40019c0c: 82 20 40 02 sub %g1, %g2, %g1
40019c10: 85 28 60 04 sll %g1, 4, %g2
40019c14: 82 20 80 01 sub %g2, %g1, %g1
40019c18: 85 28 60 04 sll %g1, 4, %g2
40019c1c: 82 20 80 01 sub %g2, %g1, %g1
40019c20: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
40019c24: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_SIZE+0x128ea600>
40019c28: 82 00 40 02 add %g1, %g2, %g1
40019c2c: 05 10 00 b2 sethi %hi(0x4002c800), %g2
40019c30: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] ! 4002c824 <lastseconds>
}
return seconds + lastseconds;
40019c34: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40019c38: d0 00 60 24 ld [ %g1 + 0x24 ], %o0 ! 4002c824 <lastseconds>
}
40019c3c: 81 c3 e0 08 retl
40019c40: 90 02 40 08 add %o1, %o0, %o0
400199d8 <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)
{
400199d8: 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) {
400199dc: 03 10 00 b2 sethi %hi(0x4002c800), %g1
400199e0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 ! 4002c814 <lasttime>
400199e4: 80 a0 80 18 cmp %g2, %i0
400199e8: 02 80 00 47 be 40019b04 <msdos_date_unix2dos+0x12c>
400199ec: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
400199f0: f0 20 60 14 st %i0, [ %g1 + 0x14 ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
400199f4: 7f ff a3 51 call 40002738 <.udiv>
400199f8: 90 10 00 18 mov %i0, %o0
400199fc: 40 00 38 30 call 40027abc <.urem>
40019a00: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40019a04: 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)
40019a08: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40019a0c: 7f ff a3 4b call 40002738 <.udiv>
40019a10: 90 10 00 18 mov %i0, %o0
40019a14: 40 00 38 2a call 40027abc <.urem>
40019a18: 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)
40019a1c: 91 2a 20 0b sll %o0, 0xb, %o0
40019a20: 92 10 20 3c mov 0x3c, %o1
40019a24: ba 07 40 08 add %i5, %o0, %i5
40019a28: 40 00 38 25 call 40027abc <.urem>
40019a2c: 90 10 00 18 mov %i0, %o0
40019a30: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40019a34: 91 32 20 01 srl %o0, 1, %o0
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
40019a38: 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)
40019a3c: ba 07 40 08 add %i5, %o0, %i5
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
40019a40: 92 12 61 80 or %o1, 0x180, %o1
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
40019a44: fa 30 60 18 sth %i5, [ %g1 + 0x18 ]
/*
* 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);
40019a48: 7f ff a3 3c call 40002738 <.udiv>
40019a4c: 90 10 00 18 mov %i0, %o0
if (days != lastday) {
40019a50: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40019a54: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 ! 4002c81c <lastday>
40019a58: 80 a2 00 02 cmp %o0, %g2
40019a5c: 22 80 00 2b be,a 40019b08 <msdos_date_unix2dos+0x130>
40019a60: 03 10 00 b2 sethi %hi(0x4002c800), %g1
lastday = days;
40019a64: d0 20 60 1c st %o0, [ %g1 + 0x1c ] ! 4002c81c <lastday>
for (year = 1970;; year++) {
40019a68: 82 10 27 b2 mov 0x7b2, %g1
inc = year & 0x03 ? 365 : 366;
40019a6c: 84 08 60 03 and %g1, 3, %g2
40019a70: 80 a0 00 02 cmp %g0, %g2
40019a74: 86 60 3f ff subx %g0, -1, %g3
40019a78: 86 00 e1 6d add %g3, 0x16d, %g3
if (days < inc)
40019a7c: 80 a2 00 03 cmp %o0, %g3
40019a80: 0a 80 00 05 bcs 40019a94 <msdos_date_unix2dos+0xbc>
40019a84: 80 a0 a0 00 cmp %g2, 0
break;
days -= inc;
40019a88: 90 22 00 03 sub %o0, %g3, %o0
}
40019a8c: 10 bf ff f8 b 40019a6c <msdos_date_unix2dos+0x94>
40019a90: 82 00 60 01 inc %g1
months = year & 0x03 ? regyear : leapyear;
40019a94: 22 80 00 05 be,a 40019aa8 <msdos_date_unix2dos+0xd0> <== ALWAYS TAKEN
40019a98: 09 10 00 b0 sethi %hi(0x4002c000), %g4
40019a9c: 09 10 00 b0 sethi %hi(0x4002c000), %g4 <== NOT EXECUTED
40019aa0: 10 80 00 03 b 40019aac <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
40019aa4: 88 11 20 e4 or %g4, 0xe4, %g4 ! 4002c0e4 <regyear> <== NOT EXECUTED
40019aa8: 88 11 20 fc or %g4, 0xfc, %g4
for (month = 0; month < 12; month++) {
40019aac: 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,
40019ab0: 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])
40019ab4: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
40019ab8: 80 a2 00 03 cmp %o0, %g3
40019abc: 2a 80 00 07 bcs,a 40019ad8 <msdos_date_unix2dos+0x100> <== ALWAYS TAKEN
40019ac0: 90 02 20 01 inc %o0
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
40019ac4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40019ac8: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
40019acc: 12 bf ff f9 bne 40019ab0 <msdos_date_unix2dos+0xd8> <== NOT EXECUTED
40019ad0: 90 22 00 03 sub %o0, %g3, %o0 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
40019ad4: 90 02 20 01 inc %o0 <== NOT EXECUTED
40019ad8: 84 00 a0 01 inc %g2
40019adc: 07 10 00 b2 sethi %hi(0x4002c800), %g3
40019ae0: 85 28 a0 05 sll %g2, 5, %g2
40019ae4: 90 02 00 02 add %o0, %g2, %o0
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
40019ae8: 80 a0 67 bc cmp %g1, 0x7bc
40019aec: 08 80 00 06 bleu 40019b04 <msdos_date_unix2dos+0x12c> <== NEVER TAKEN
40019af0: d0 30 e0 20 sth %o0, [ %g3 + 0x20 ]
lastddate += (year - 1980) <<
40019af4: 82 00 78 44 add %g1, -1980, %g1
40019af8: 83 28 60 09 sll %g1, 9, %g1
40019afc: 90 02 00 01 add %o0, %g1, %o0
40019b00: d0 30 e0 20 sth %o0, [ %g3 + 0x20 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
40019b04: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40019b08: c2 10 60 18 lduh [ %g1 + 0x18 ], %g1 ! 4002c818 <lastdtime>
40019b0c: c2 36 80 00 sth %g1, [ %i2 ]
*ddp = lastddate;
40019b10: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40019b14: c2 10 60 20 lduh [ %g1 + 0x20 ], %g1 ! 4002c820 <lastddate>
40019b18: c2 36 40 00 sth %g1, [ %i1 ]
40019b1c: 81 c7 e0 08 ret
40019b20: 81 e8 00 00 restore
4001759c <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
)
{
4001759c: 9d e3 bf a0 save %sp, -96, %sp
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
400175a0: 23 10 00 ad sethi %hi(0x4002b400), %l1
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
400175a4: fa 06 20 08 ld [ %i0 + 8 ], %i5
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
400175a8: 25 10 00 ad sethi %hi(0x4002b400), %l2
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
400175ac: 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;
400175b0: b6 10 20 00 clr %i3
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
400175b4: a2 14 63 40 or %l1, 0x340, %l1
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
400175b8: 10 80 00 33 b 40017684 <msdos_dir_is_empty+0xe8>
400175bc: a4 14 a3 50 or %l2, 0x350, %l2
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400175c0: 04 80 00 2a ble 40017668 <msdos_dir_is_empty+0xcc> <== NEVER TAKEN
400175c4: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
400175c8: c2 17 40 00 lduh [ %i5 ], %g1
400175cc: 80 a2 00 01 cmp %o0, %g1
400175d0: 02 80 00 28 be 40017670 <msdos_dir_is_empty+0xd4> <== ALWAYS TAKEN
400175d4: b8 10 20 00 clr %i4
400175d8: 11 10 00 ad sethi %hi(0x4002b400), %o0 <== NOT EXECUTED
400175dc: 15 10 00 ad sethi %hi(0x4002b400), %o2 <== NOT EXECUTED
400175e0: 17 10 00 ad sethi %hi(0x4002b400), %o3 <== NOT EXECUTED
400175e4: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
400175e8: 92 10 23 65 mov 0x365, %o1 <== NOT EXECUTED
400175ec: 94 12 a3 88 or %o2, 0x388, %o2 <== NOT EXECUTED
400175f0: 7f ff b4 de call 40004968 <__assert_func> <== NOT EXECUTED
400175f4: 96 12 e3 20 or %o3, 0x320, %o3 <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
400175f8: e0 08 40 1c ldub [ %g1 + %i4 ], %l0
400175fc: 80 a4 20 e5 cmp %l0, 0xe5
40017600: 02 80 00 14 be 40017650 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
40017604: b0 00 40 1c add %g1, %i4, %i0
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40017608: c2 0e 20 0b ldub [ %i0 + 0xb ], %g1
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
4001760c: 82 08 60 3f and %g1, 0x3f, %g1
40017610: 80 a0 60 0f cmp %g1, 0xf
40017614: 02 80 00 0f be 40017650 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
40017618: 90 10 00 18 mov %i0, %o0
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
4001761c: 92 10 00 11 mov %l1, %o1
40017620: 40 00 13 c2 call 4001c528 <strncmp>
40017624: 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) ||
40017628: 80 a2 20 00 cmp %o0, 0
4001762c: 22 80 00 12 be,a 40017674 <msdos_dir_is_empty+0xd8>
40017630: 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)),
40017634: 90 10 00 18 mov %i0, %o0
40017638: 92 10 00 12 mov %l2, %o1
4001763c: 40 00 13 bb call 4001c528 <strncmp>
40017640: 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) ||
40017644: 80 a2 20 00 cmp %o0, 0
40017648: 12 80 00 04 bne 40017658 <msdos_dir_is_empty+0xbc>
4001764c: 80 a4 20 00 cmp %l0, 0
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40017650: 10 80 00 09 b 40017674 <msdos_dir_is_empty+0xd8>
40017654: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
40017658: 12 80 00 04 bne 40017668 <msdos_dir_is_empty+0xcc>
4001765c: b0 10 20 00 clr %i0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
40017660: 82 10 20 01 mov 1, %g1
40017664: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
40017668: 81 c7 e0 08 ret
4001766c: 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;
40017670: a6 10 00 08 mov %o0, %l3
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
40017674: 80 a7 00 13 cmp %i4, %l3
40017678: 2a bf ff e0 bcs,a 400175f8 <msdos_dir_is_empty+0x5c> <== ALWAYS TAKEN
4001767c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
40017680: b6 06 e0 01 inc %i3 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
40017684: f8 17 40 00 lduh [ %i5 ], %i4
40017688: 90 10 00 1b mov %i3, %o0
4001768c: 7f ff ab f1 call 40002650 <.umul>
40017690: 92 10 00 1c mov %i4, %o1
40017694: d8 07 60 a0 ld [ %i5 + 0xa0 ], %o4
40017698: 94 10 00 08 mov %o0, %o2
4001769c: 92 10 00 19 mov %i1, %o1
400176a0: 90 10 00 1d mov %i5, %o0
400176a4: 7f ff e8 51 call 400117e8 <fat_file_read>
400176a8: 96 10 00 1c mov %i4, %o3
400176ac: 80 a2 20 00 cmp %o0, 0
400176b0: 32 bf ff c4 bne,a 400175c0 <msdos_dir_is_empty+0x24> <== ALWAYS TAKEN
400176b4: 80 a2 20 1f cmp %o0, 0x1f
*/
return RC_OK;
}
j++;
}
*ret_val = true;
400176b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400176bc: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED
400176c0: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
400176c4: 81 c7 e0 08 ret <== NOT EXECUTED
400176c8: 81 e8 00 00 restore <== NOT EXECUTED
40019dc0 <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)
{
40019dc0: 9d e3 be 68 save %sp, -408, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40019dc4: 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);
40019dc8: d0 1e 20 08 ldd [ %i0 + 8 ], %o0 <== NOT EXECUTED
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40019dcc: ec 00 60 08 ld [ %g1 + 8 ], %l6 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
40019dd0: 94 10 20 00 clr %o2 <== NOT EXECUTED
40019dd4: 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)
{
40019dd8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
40019ddc: c0 27 be d0 clr [ %fp + -304 ] <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
40019de0: 7f ff a1 31 call 400022a4 <__divdi3> <== NOT EXECUTED
40019de4: c0 27 be d4 clr [ %fp + -300 ] <== NOT EXECUTED
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
40019de8: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
40019dec: a6 10 00 09 mov %o1, %l3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
40019df0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40019df4: 7f ff a2 51 call 40002738 <.udiv> <== NOT EXECUTED
40019df8: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
40019dfc: a5 2a 20 03 sll %o0, 3, %l2 <== NOT EXECUTED
40019e00: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
40019e04: a4 04 80 08 add %l2, %o0, %l2 <== NOT EXECUTED
40019e08: 85 2c a0 03 sll %l2, 3, %g2 <== NOT EXECUTED
40019e0c: a4 20 80 12 sub %g2, %l2, %l2 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
40019e10: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
40019e14: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
40019e18: 32 80 00 0b bne,a 40019e44 <msdos_dir_read+0x84> <== NOT EXECUTED
40019e1c: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40019e20: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
40019e24: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40019e28: 32 80 00 07 bne,a 40019e44 <msdos_dir_read+0x84> <== NOT EXECUTED
40019e2c: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
40019e30: c4 0d a0 0e ldub [ %l6 + 0xe ], %g2 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40019e34: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
40019e38: 22 80 00 03 be,a 40019e44 <msdos_dir_read+0x84> <== NOT EXECUTED
40019e3c: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
40019e40: ea 04 20 18 ld [ %l0 + 0x18 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
40019e44: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
40019e48: 92 10 20 00 clr %o1 <== NOT EXECUTED
40019e4c: 7f ff bc 46 call 40008f64 <rtems_semaphore_obtain> <== NOT EXECUTED
40019e50: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40019e54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019e58: 22 80 00 fe be,a 4001a250 <msdos_dir_read+0x490> <== NOT EXECUTED
40019e5c: a2 10 20 00 clr %l1 <== NOT EXECUTED
40019e60: 30 80 00 0b b,a 40019e8c <msdos_dir_read+0xcc> <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
40019e64: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40019e68: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40019e6c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40019e70: 7f ff de 5e call 400117e8 <fat_file_read> <== NOT EXECUTED
40019e74: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40019e78: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
40019e7c: 14 80 00 ee bg 4001a234 <msdos_dir_read+0x474> <== NOT EXECUTED
40019e80: d0 27 be cc st %o0, [ %fp + -308 ] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
40019e84: 7f ff bc 81 call 40009088 <rtems_semaphore_release> <== NOT EXECUTED
40019e88: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
40019e8c: 40 00 02 90 call 4001a8cc <__errno> <== NOT EXECUTED
40019e90: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
40019e94: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40019e98: 10 80 01 07 b 4001a2b4 <msdos_dir_read+0x4f4> <== NOT EXECUTED
40019e9c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
40019ea0: ae 00 c0 1c add %g3, %i4, %l7 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40019ea4: c6 08 c0 1c ldub [ %g3 + %i4 ], %g3 <== NOT EXECUTED
40019ea8: 88 88 e0 ff andcc %g3, 0xff, %g4 <== NOT EXECUTED
40019eac: 12 80 00 04 bne 40019ebc <msdos_dir_read+0xfc> <== NOT EXECUTED
40019eb0: 80 a1 20 e5 cmp %g4, 0xe5 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
40019eb4: 10 80 00 ef b 4001a270 <msdos_dir_read+0x4b0> <== NOT EXECUTED
40019eb8: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
40019ebc: 22 80 00 df be,a 4001a238 <msdos_dir_read+0x478> <== NOT EXECUTED
40019ec0: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
40019ec4: c8 0d e0 0b ldub [ %l7 + 0xb ], %g4 <== NOT EXECUTED
40019ec8: 9e 09 20 08 and %g4, 8, %o7 <== NOT EXECUTED
40019ecc: 80 8b e0 ff btst 0xff, %o7 <== NOT EXECUTED
40019ed0: 22 80 00 07 be,a 40019eec <msdos_dir_read+0x12c> <== NOT EXECUTED
40019ed4: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
40019ed8: 9e 09 20 3f and %g4, 0x3f, %o7 <== NOT EXECUTED
40019edc: 80 a3 e0 0f cmp %o7, 0xf <== NOT EXECUTED
40019ee0: 32 80 00 d6 bne,a 4001a238 <msdos_dir_read+0x478> <== NOT EXECUTED
40019ee4: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40019ee8: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
40019eec: 80 a1 20 0f cmp %g4, 0xf <== NOT EXECUTED
40019ef0: 12 80 00 3e bne 40019fe8 <msdos_dir_read+0x228> <== NOT EXECUTED
40019ef4: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
40019ef8: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
40019efc: 32 80 00 0f bne,a 40019f38 <msdos_dir_read+0x178> <== NOT EXECUTED
40019f00: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
40019f04: 88 08 e0 40 and %g3, 0x40, %g4 <== NOT EXECUTED
40019f08: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
40019f0c: 22 80 00 cb be,a 4001a238 <msdos_dir_read+0x478> <== NOT EXECUTED
40019f10: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
40019f14: b6 07 00 11 add %i4, %l1, %i3 <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
40019f18: ba 08 e0 3f and %g3, 0x3f, %i5 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
40019f1c: b7 36 e0 05 srl %i3, 5, %i3 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
40019f20: e8 0d e0 0d ldub [ %l7 + 0xd ], %l4 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
40019f24: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
40019f28: 92 10 20 00 clr %o1 <== NOT EXECUTED
40019f2c: 40 00 05 4a call 4001b454 <memset> <== NOT EXECUTED
40019f30: 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) &
40019f34: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
40019f38: 86 08 e0 3f and %g3, 0x3f, %g3 <== NOT EXECUTED
40019f3c: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
40019f40: 32 80 00 bb bne,a 4001a22c <msdos_dir_read+0x46c> <== NOT EXECUTED
40019f44: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
40019f48: c6 0d e0 0d ldub [ %l7 + 0xd ], %g3 <== NOT EXECUTED
40019f4c: 88 0d 20 ff and %l4, 0xff, %g4 <== NOT EXECUTED
40019f50: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
40019f54: 32 80 00 b6 bne,a 4001a22c <msdos_dir_read+0x46c> <== NOT EXECUTED
40019f58: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
40019f5c: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
40019f60: 87 2f 60 02 sll %i5, 2, %g3 <== NOT EXECUTED
40019f64: 89 2f 60 04 sll %i5, 4, %g4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
40019f68: 82 07 be e8 add %fp, -280, %g1 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
40019f6c: 88 21 00 03 sub %g4, %g3, %g4 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
40019f70: 84 05 e0 01 add %l7, 1, %g2 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
40019f74: 88 01 00 1d add %g4, %i5, %g4 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
40019f78: 86 10 20 00 clr %g3 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
40019f7c: 9e 00 40 04 add %g1, %g4, %o7 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
40019f80: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
40019f84: 80 a3 60 fe cmp %o5, 0xfe <== NOT EXECUTED
40019f88: 18 80 00 a3 bgu 4001a214 <msdos_dir_read+0x454> <== NOT EXECUTED
40019f8c: 9a 03 c0 03 add %o7, %g3, %o5 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
40019f90: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
40019f94: d8 2b 60 14 stb %o4, [ %o5 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
40019f98: da 48 80 00 ldsb [ %g2 ], %o5 <== NOT EXECUTED
40019f9c: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
40019fa0: 02 80 00 9d be 4001a214 <msdos_dir_read+0x454> <== NOT EXECUTED
40019fa4: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
break;
switch (q)
40019fa8: 02 80 00 06 be 40019fc0 <msdos_dir_read+0x200> <== NOT EXECUTED
40019fac: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
40019fb0: 32 80 00 08 bne,a 40019fd0 <msdos_dir_read+0x210> <== NOT EXECUTED
40019fb4: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
40019fb8: 10 80 00 04 b 40019fc8 <msdos_dir_read+0x208> <== NOT EXECUTED
40019fbc: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED
switch (q)
{
case 4:
p += 5;
break;
40019fc0: 10 80 00 04 b 40019fd0 <msdos_dir_read+0x210> <== NOT EXECUTED
40019fc4: 84 00 a0 05 add %g2, 5, %g2 <== NOT EXECUTED
case 10:
p += 4;
break;
40019fc8: 10 80 00 03 b 40019fd4 <msdos_dir_read+0x214> <== NOT EXECUTED
40019fcc: 86 00 e0 01 inc %g3 <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
40019fd0: 86 00 e0 01 inc %g3 <== NOT EXECUTED
40019fd4: 80 a0 e0 0d cmp %g3, 0xd <== NOT EXECUTED
40019fd8: 12 bf ff eb bne 40019f84 <msdos_dir_read+0x1c4> <== NOT EXECUTED
40019fdc: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
40019fe0: 10 80 00 8e b 4001a218 <msdos_dir_read+0x458> <== NOT EXECUTED
40019fe4: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
40019fe8: 02 80 00 04 be 40019ff8 <msdos_dir_read+0x238> <== NOT EXECUTED
40019fec: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
40019ff0: 10 80 00 8e b 4001a228 <msdos_dir_read+0x468> <== NOT EXECUTED
40019ff4: a6 04 ff ff add %l3, -1, %l3 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40019ff8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40019ffc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001a000: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001a004: 7f ff de d9 call 40011b68 <fat_file_ioctl> <== NOT EXECUTED
4001a008: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
4001a00c: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001a010: 12 80 00 7d bne 4001a204 <msdos_dir_read+0x444> <== NOT EXECUTED
4001a014: c6 07 be d4 ld [ %fp + -300 ], %g3 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001a018: 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;
4001a01c: c6 27 be d8 st %g3, [ %fp + -296 ] <== NOT EXECUTED
4001a020: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001a024: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
4001a028: f8 27 be dc st %i4, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
4001a02c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
4001a030: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
4001a034: 7f ff dd 8a call 4001165c <fat_file_open> <== NOT EXECUTED
4001a038: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
4001a03c: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001a040: 12 80 00 71 bne 4001a204 <msdos_dir_read+0x444> <== NOT EXECUTED
4001a044: c6 07 be d0 ld [ %fp + -304 ], %g3 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
4001a048: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
4001a04c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
4001a050: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
4001a054: f4 27 be f4 st %i2, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
4001a058: 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)
4001a05c: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
4001a060: 02 80 00 1d be 4001a0d4 <msdos_dir_read+0x314> <== NOT EXECUTED
4001a064: c6 27 be e8 st %g3, [ %fp + -280 ] <== NOT EXECUTED
4001a068: 88 10 20 00 clr %g4 <== NOT EXECUTED
4001a06c: 86 10 20 00 clr %g3 <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001a070: da 0d c0 04 ldub [ %l7 + %g4 ], %o5 <== NOT EXECUTED
4001a074: 9e 08 e0 01 and %g3, 1, %o7 <== NOT EXECUTED
4001a078: 80 a0 00 0f cmp %g0, %o7 <== NOT EXECUTED
4001a07c: 86 08 e0 ff and %g3, 0xff, %g3 <== NOT EXECUTED
4001a080: 9e 40 3f ff addx %g0, -1, %o7 <== NOT EXECUTED
4001a084: 87 30 e0 01 srl %g3, 1, %g3 <== NOT EXECUTED
4001a088: 9e 0b e0 80 and %o7, 0x80, %o7 <== NOT EXECUTED
4001a08c: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
4001a090: 9e 03 ff 80 add %o7, -128, %o7 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
4001a094: 88 01 20 01 inc %g4 <== NOT EXECUTED
4001a098: 80 a1 20 0b cmp %g4, 0xb <== NOT EXECUTED
4001a09c: 12 bf ff f5 bne 4001a070 <msdos_dir_read+0x2b0> <== NOT EXECUTED
4001a0a0: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
4001a0a4: 86 18 c0 14 xor %g3, %l4, %g3 <== NOT EXECUTED
4001a0a8: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
4001a0ac: 12 80 00 0b bne 4001a0d8 <msdos_dir_read+0x318> <== NOT EXECUTED
4001a0b0: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
4001a0b4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4001a0b8: 12 80 00 09 bne 4001a0dc <msdos_dir_read+0x31c> <== NOT EXECUTED
4001a0bc: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
4001a0c0: 30 80 00 70 b,a 4001a280 <msdos_dir_read+0x4c0> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001a0c4: 32 80 00 06 bne,a 4001a0dc <msdos_dir_read+0x31c> <== NOT EXECUTED
4001a0c8: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a0cc: 10 80 00 09 b 4001a0f0 <msdos_dir_read+0x330> <== NOT EXECUTED
4001a0d0: 03 10 00 b0 sethi %hi(0x4002c000), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001a0d4: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001a0d8: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
4001a0dc: c8 49 3f ff ldsb [ %g4 + -1 ], %g4 <== NOT EXECUTED
4001a0e0: 80 a1 20 20 cmp %g4, 0x20 <== NOT EXECUTED
4001a0e4: 22 bf ff f8 be,a 4001a0c4 <msdos_dir_read+0x304> <== NOT EXECUTED
4001a0e8: 86 80 ff ff addcc %g3, -1, %g3 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a0ec: 03 10 00 b0 sethi %hi(0x4002c000), %g1 <== NOT EXECUTED
4001a0f0: b6 10 20 00 clr %i3 <== NOT EXECUTED
4001a0f4: da 00 61 14 ld [ %g1 + 0x114 ], %o5 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
4001a0f8: 10 80 00 0b b 4001a124 <msdos_dir_read+0x364> <== NOT EXECUTED
4001a0fc: 88 07 be fc add %fp, -260, %g4 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a100: 98 03 40 0f add %o5, %o7, %o4 <== NOT EXECUTED
4001a104: d8 0b 20 01 ldub [ %o4 + 1 ], %o4 <== NOT EXECUTED
4001a108: 98 0b 20 03 and %o4, 3, %o4 <== NOT EXECUTED
4001a10c: 80 a3 20 01 cmp %o4, 1 <== NOT EXECUTED
4001a110: 22 80 00 02 be,a 4001a118 <msdos_dir_read+0x358> <== NOT EXECUTED
4001a114: 9e 03 e0 20 add %o7, 0x20, %o7 <== NOT EXECUTED
4001a118: de 29 00 00 stb %o7, [ %g4 ] <== NOT EXECUTED
4001a11c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
4001a120: 88 01 20 01 inc %g4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001a124: 9e 20 c0 1b sub %g3, %i3, %o7 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
4001a128: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
4001a12c: 34 bf ff f5 bg,a 4001a100 <msdos_dir_read+0x340> <== NOT EXECUTED
4001a130: de 0d c0 1b ldub [ %l7 + %i3 ], %o7 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
4001a134: f6 4d e0 0a ldsb [ %l7 + 0xa ], %i3 <== NOT EXECUTED
4001a138: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
4001a13c: 12 80 00 55 bne 4001a290 <msdos_dir_read+0x4d0> <== NOT EXECUTED
4001a140: b6 10 20 03 mov 3, %i3 <== NOT EXECUTED
4001a144: f6 4d e0 09 ldsb [ %l7 + 9 ], %i3 <== NOT EXECUTED
4001a148: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
4001a14c: 12 80 00 51 bne 4001a290 <msdos_dir_read+0x4d0> <== NOT EXECUTED
4001a150: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED
4001a154: f6 4d e0 08 ldsb [ %l7 + 8 ], %i3 <== NOT EXECUTED
4001a158: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
4001a15c: 22 80 00 18 be,a 4001a1bc <msdos_dir_read+0x3fc> <== NOT EXECUTED
4001a160: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
4001a164: 10 80 00 4b b 4001a290 <msdos_dir_read+0x4d0> <== NOT EXECUTED
4001a168: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a16c: da 0b 60 08 ldub [ %o5 + 8 ], %o5 <== NOT EXECUTED
4001a170: 94 03 00 0d add %o4, %o5, %o2 <== NOT EXECUTED
4001a174: d4 0a a0 01 ldub [ %o2 + 1 ], %o2 <== NOT EXECUTED
4001a178: 94 0a a0 03 and %o2, 3, %o2 <== NOT EXECUTED
4001a17c: 80 a2 a0 01 cmp %o2, 1 <== NOT EXECUTED
4001a180: 22 80 00 02 be,a 4001a188 <msdos_dir_read+0x3c8> <== NOT EXECUTED
4001a184: 9a 03 60 20 add %o5, 0x20, %o5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001a188: 94 01 00 0f add %g4, %o7, %o2 <== NOT EXECUTED
4001a18c: 9e 03 e0 01 inc %o7 <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a190: da 2a a0 01 stb %o5, [ %o2 + 1 ] <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001a194: 9a 26 c0 0f sub %i3, %o7, %o5 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
4001a198: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
4001a19c: 14 bf ff f4 bg 4001a16c <msdos_dir_read+0x3ac> <== NOT EXECUTED
4001a1a0: 9a 05 c0 0f add %l7, %o7, %o5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001a1a4: 84 38 00 1b xnor %g0, %i3, %g2 <== NOT EXECUTED
4001a1a8: 85 38 a0 1f sra %g2, 0x1f, %g2 <== NOT EXECUTED
4001a1ac: b6 0e c0 02 and %i3, %g2, %i3 <== NOT EXECUTED
4001a1b0: 88 02 c0 1b add %o3, %i3, %g4 <== NOT EXECUTED
4001a1b4: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
4001a1b8: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
4001a1bc: c6 37 be fa sth %g3, [ %fp + -262 ] <== NOT EXECUTED
4001a1c0: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
4001a1c4: c2 07 a0 48 ld [ %fp + 0x48 ], %g1 <== NOT EXECUTED
4001a1c8: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
4001a1cc: 90 00 40 1a add %g1, %i2, %o0 <== NOT EXECUTED
4001a1d0: 40 00 04 64 call 4001b360 <memcpy> <== NOT EXECUTED
4001a1d4: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
4001a1d8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4001a1dc: 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);
4001a1e0: 9a 80 e1 18 addcc %g3, 0x118, %o5 <== NOT EXECUTED
4001a1e4: 98 40 a0 00 addx %g2, 0, %o4 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4001a1e8: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
4001a1ec: d8 3e 20 08 std %o4, [ %i0 + 8 ] <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4001a1f0: 7f ff de 31 call 40011ab4 <fat_file_close> <== NOT EXECUTED
4001a1f4: b4 06 a1 18 add %i2, 0x118, %i2 <== NOT EXECUTED
if (rc != RC_OK)
4001a1f8: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001a1fc: 02 80 00 06 be 4001a214 <msdos_dir_read+0x454> <== NOT EXECUTED
4001a200: a4 04 be e8 add %l2, -280, %l2 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
4001a204: 7f ff bb a1 call 40009088 <rtems_semaphore_release> <== NOT EXECUTED
4001a208: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
4001a20c: 81 c7 e0 08 ret <== NOT EXECUTED
4001a210: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
4001a214: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001a218: 32 80 00 08 bne,a 4001a238 <msdos_dir_read+0x478> <== NOT EXECUTED
4001a21c: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
4001a220: 10 80 00 10 b 4001a260 <msdos_dir_read+0x4a0> <== NOT EXECUTED
4001a224: a2 04 40 15 add %l1, %l5, %l1 <== NOT EXECUTED
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
4001a228: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001a22c: 10 80 00 03 b 4001a238 <msdos_dir_read+0x478> <== NOT EXECUTED
4001a230: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001a234: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001a238: c2 07 be cc ld [ %fp + -308 ], %g1 <== NOT EXECUTED
4001a23c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
4001a240: 2a bf ff 18 bcs,a 40019ea0 <msdos_dir_read+0xe0> <== NOT EXECUTED
4001a244: c6 05 a0 a0 ld [ %l6 + 0xa0 ], %g3 <== NOT EXECUTED
4001a248: 10 80 00 06 b 4001a260 <msdos_dir_read+0x4a0> <== NOT EXECUTED
4001a24c: a2 04 40 15 add %l1, %l5, %l1 <== NOT EXECUTED
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a250: ba 10 20 00 clr %i5 <== NOT EXECUTED
4001a254: a8 10 20 00 clr %l4 <== NOT EXECUTED
4001a258: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
4001a25c: b4 10 20 00 clr %i2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
4001a260: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001a264: 32 bf ff 00 bne,a 40019e64 <msdos_dir_read+0xa4> <== NOT EXECUTED
4001a268: d8 05 a0 a0 ld [ %l6 + 0xa0 ], %o4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
4001a26c: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
4001a270: 7f ff bb 86 call 40009088 <rtems_semaphore_release> <== NOT EXECUTED
4001a274: b2 10 00 1a mov %i2, %i1 <== NOT EXECUTED
return cmpltd;
}
4001a278: 81 c7 e0 08 ret <== NOT EXECUTED
4001a27c: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
4001a280: 40 00 08 78 call 4001c460 <strlen> <== NOT EXECUTED
4001a284: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001a288: 10 bf ff cf b 4001a1c4 <msdos_dir_read+0x404> <== NOT EXECUTED
4001a28c: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001a290: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
4001a294: 9e 06 e0 01 add %i3, 1, %o7 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001a298: c2 29 00 00 stb %g1, [ %g4 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
4001a29c: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a2a0: 03 10 00 b0 sethi %hi(0x4002c000), %g1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001a2a4: 96 01 20 01 add %g4, 1, %o3 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001a2a8: d8 00 61 14 ld [ %g1 + 0x114 ], %o4 <== NOT EXECUTED
4001a2ac: 10 bf ff ba b 4001a194 <msdos_dir_read+0x3d4> <== NOT EXECUTED
4001a2b0: 9e 10 20 00 clr %o7 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
4001a2b4: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
4001a2b8: 81 c7 e0 08 ret <== NOT EXECUTED
4001a2bc: 81 e8 00 00 restore <== NOT EXECUTED
4001a2c0 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001a2c0: 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;
4001a2c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001a2c8: 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;
4001a2cc: 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,
4001a2d0: 92 10 20 00 clr %o1
4001a2d4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001a2d8: 7f ff bb 23 call 40008f64 <rtems_semaphore_obtain>
4001a2dc: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a2e0: 80 a2 20 00 cmp %o0, 0
4001a2e4: 22 80 00 08 be,a 4001a304 <msdos_dir_stat+0x44> <== ALWAYS TAKEN
4001a2e8: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
4001a2ec: 40 00 01 78 call 4001a8cc <__errno> <== NOT EXECUTED
4001a2f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a2f4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a2f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a2fc: 81 c7 e0 08 ret <== NOT EXECUTED
4001a300: 81 e8 00 00 restore <== NOT EXECUTED
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
4001a304: 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);
4001a308: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
4001a30c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001a310: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
4001a314: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
4001a318: 03 00 00 10 sethi %hi(0x4000), %g1
4001a31c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 41ff <PROM_START+0x41ff>
4001a320: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001a324: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001a328: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
4001a32c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
4001a330: 83 30 60 09 srl %g1, 9, %g1
4001a334: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
4001a338: c2 17 40 00 lduh [ %i5 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001a33c: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
4001a340: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001a344: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001a348: c0 26 60 20 clr [ %i1 + 0x20 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
4001a34c: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
4001a350: 7f ff bb 4e call 40009088 <rtems_semaphore_release>
4001a354: b0 10 20 00 clr %i0
return RC_OK;
}
4001a358: 81 c7 e0 08 ret
4001a35c: 81 e8 00 00 restore
40016e8c <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40016e8c: 9d e3 bf a0 save %sp, -96, %sp
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
40016e90: 82 10 20 00 clr %g1
40016e94: 80 a6 e0 01 cmp %i3, 1
40016e98: 12 80 00 06 bne 40016eb0 <msdos_eval_token+0x24>
40016e9c: ba 10 00 18 mov %i0, %i5
40016ea0: c2 4e 80 00 ldsb [ %i2 ], %g1
40016ea4: 82 18 60 2e xor %g1, 0x2e, %g1
40016ea8: 80 a0 00 01 cmp %g0, %g1
40016eac: 82 60 3f ff subx %g0, -1, %g1
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
40016eb0: 80 a0 60 00 cmp %g1, 0
40016eb4: 02 80 00 05 be 40016ec8 <msdos_eval_token+0x3c>
40016eb8: b0 10 20 00 clr %i0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
40016ebc: c0 27 60 0c clr [ %i5 + 0xc ]
40016ec0: 81 c7 e0 08 ret
40016ec4: 81 e8 00 00 restore
rtems_filesystem_eval_path_clear_token(ctx);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc(ctx);
int rc = msdos_find_name(currentloc, token, tokenlen);
40016ec8: 90 07 60 18 add %i5, 0x18, %o0
40016ecc: 92 10 00 1a mov %i2, %o1
40016ed0: 40 00 05 aa call 40018578 <msdos_find_name>
40016ed4: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
40016ed8: 80 a2 20 00 cmp %o0, 0
40016edc: 12 80 00 12 bne 40016f24 <msdos_eval_token+0x98>
40016ee0: 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)
40016ee4: 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;
40016ee8: 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)
40016eec: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
40016ef0: c0 27 60 0c clr [ %i5 + 0xc ]
40016ef4: 80 a0 a0 00 cmp %g2, 0
40016ef8: 12 80 00 04 bne 40016f08 <msdos_eval_token+0x7c>
40016efc: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
40016f00: 10 80 00 03 b 40016f0c <msdos_eval_token+0x80>
40016f04: c2 00 60 94 ld [ %g1 + 0x94 ], %g1
else
loc->handlers = fs_info->file_handlers;
40016f08: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
40016f0c: 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)) {
40016f10: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40016f14: 80 a0 00 01 cmp %g0, %g1
40016f18: b0 60 3f ff subx %g0, -1, %i0
40016f1c: 81 c7 e0 08 ret
40016f20: 81 e8 00 00 restore
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
40016f24: 82 10 61 01 or %g1, 0x101, %g1
40016f28: 80 a2 00 01 cmp %o0, %g1
40016f2c: 02 bf ff e5 be 40016ec0 <msdos_eval_token+0x34> <== ALWAYS TAKEN
40016f30: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
40016f34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40016f38: 92 10 20 00 clr %o1 <== NOT EXECUTED
40016f3c: 7f ff bb 55 call 40005c90 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40016f40: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return status;
}
40016f44: 81 c7 e0 08 ret <== NOT EXECUTED
40016f48: 81 e8 00 00 restore <== NOT EXECUTED
4001a3bc <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)
{
4001a3bc: 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;
4001a3c0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001a3c4: 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;
4001a3c8: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001a3cc: 94 10 20 00 clr %o2
4001a3d0: 7f ff ba e5 call 40008f64 <rtems_semaphore_obtain>
4001a3d4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a3d8: 80 a2 20 00 cmp %o0, 0
4001a3dc: 02 80 00 08 be 4001a3fc <msdos_file_close+0x40> <== ALWAYS TAKEN
4001a3e0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
4001a3e4: 40 00 01 3a call 4001a8cc <__errno> <== NOT EXECUTED
4001a3e8: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001a3ec: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a3f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a3f4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a3f8: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
4001a3fc: 7f ff ff d9 call 4001a360 <msdos_file_update>
4001a400: 90 10 00 18 mov %i0, %o0
4001a404: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
4001a408: 7f ff bb 20 call 40009088 <rtems_semaphore_release>
4001a40c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001a410: 81 c7 e0 08 ret
4001a414: 81 e8 00 00 restore
4001a620 <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)
{
4001a620: 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;
4001a624: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001a628: 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;
4001a62c: 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,
4001a630: 92 10 20 00 clr %o1
4001a634: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001a638: 7f ff ba 4b call 40008f64 <rtems_semaphore_obtain>
4001a63c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a640: 80 a2 20 00 cmp %o0, 0
4001a644: 02 80 00 08 be 4001a664 <msdos_file_ftruncate+0x44> <== ALWAYS TAKEN
4001a648: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
4001a64c: 40 00 00 a0 call 4001a8cc <__errno> <== NOT EXECUTED
4001a650: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a654: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a658: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a65c: 81 c7 e0 08 ret <== NOT EXECUTED
4001a660: 81 e8 00 00 restore <== NOT EXECUTED
old_length = fat_fd->fat_file_size;
if (length < old_length) {
4001a664: 14 80 00 08 bg 4001a684 <msdos_file_ftruncate+0x64> <== NEVER TAKEN
4001a668: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
4001a66c: 80 a2 00 19 cmp %o0, %i1
4001a670: 12 80 00 0d bne 4001a6a4 <msdos_file_ftruncate+0x84> <== NEVER TAKEN
4001a674: 90 10 00 1d mov %i5, %o0
4001a678: 80 a6 c0 1a cmp %i3, %i2
4001a67c: 08 80 00 0b bleu 4001a6a8 <msdos_file_ftruncate+0x88>
4001a680: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
4001a684: 90 10 00 1d mov %i5, %o0
4001a688: 92 10 00 1c mov %i4, %o1
4001a68c: 7f ff dc c5 call 400119a0 <fat_file_truncate>
4001a690: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
4001a694: b0 92 20 00 orcc %o0, 0, %i0
4001a698: 22 80 00 18 be,a 4001a6f8 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
4001a69c: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
4001a6a0: 30 80 00 16 b,a 4001a6f8 <msdos_file_ftruncate+0xd8> <== NOT EXECUTED
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
4001a6a4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001a6a8: 94 10 20 01 mov 1, %o2
4001a6ac: 96 10 00 1a mov %i2, %o3
4001a6b0: 7f ff dd 62 call 40011c38 <fat_file_extend>
4001a6b4: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
4001a6b8: b0 92 20 00 orcc %o0, 0, %i0
4001a6bc: 12 80 00 0f bne 4001a6f8 <msdos_file_ftruncate+0xd8> <== NEVER TAKEN
4001a6c0: 80 a6 60 00 cmp %i1, 0
4001a6c4: 12 80 00 05 bne 4001a6d8 <msdos_file_ftruncate+0xb8> <== NEVER TAKEN
4001a6c8: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a6cc: 80 a6 80 01 cmp %i2, %g1
4001a6d0: 22 80 00 0a be,a 4001a6f8 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
4001a6d4: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
4001a6d8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001a6dc: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001a6e0: 7f ff dc b0 call 400119a0 <fat_file_truncate> <== NOT EXECUTED
4001a6e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
4001a6e8: 40 00 00 79 call 4001a8cc <__errno> <== NOT EXECUTED
4001a6ec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a6f0: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
4001a6f4: 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);
4001a6f8: 7f ff ba 64 call 40009088 <rtems_semaphore_release>
4001a6fc: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001a700: 81 c7 e0 08 ret
4001a704: 81 e8 00 00 restore
4001a418 <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)
{
4001a418: 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;
4001a41c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001a420: 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;
4001a424: 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,
4001a428: 92 10 20 00 clr %o1
4001a42c: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001a430: 7f ff ba cd call 40008f64 <rtems_semaphore_obtain>
4001a434: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a438: 80 a2 20 00 cmp %o0, 0
4001a43c: 22 80 00 07 be,a 4001a458 <msdos_file_read+0x40> <== ALWAYS TAKEN
4001a440: d4 06 20 0c ld [ %i0 + 0xc ], %o2
rtems_set_errno_and_return_minus_one(EIO);
4001a444: 40 00 01 22 call 4001a8cc <__errno> <== NOT EXECUTED
4001a448: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001a44c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a450: 10 80 00 10 b 4001a490 <msdos_file_read+0x78> <== NOT EXECUTED
4001a454: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
4001a458: 98 10 00 19 mov %i1, %o4
4001a45c: 90 10 00 10 mov %l0, %o0
4001a460: 92 10 00 1d mov %i5, %o1
4001a464: 7f ff dc e1 call 400117e8 <fat_file_read>
4001a468: 96 10 00 1a mov %i2, %o3
buffer);
if (ret > 0)
4001a46c: b2 92 20 00 orcc %o0, 0, %i1
4001a470: 04 80 00 06 ble 4001a488 <msdos_file_read+0x70>
4001a474: 85 3e 60 1f sra %i1, 0x1f, %g2
iop->offset += ret;
4001a478: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
4001a47c: b6 87 40 19 addcc %i5, %i1, %i3
4001a480: b4 47 00 02 addx %i4, %g2, %i2
4001a484: f4 3e 20 08 std %i2, [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
4001a488: 7f ff bb 00 call 40009088 <rtems_semaphore_release>
4001a48c: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001a490: 81 c7 e0 08 ret
4001a494: 91 e8 00 19 restore %g0, %i1, %o0
4001a570 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001a570: 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;
4001a574: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001a578: 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;
4001a57c: 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,
4001a580: 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;
4001a584: f6 17 60 06 lduh [ %i5 + 6 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001a588: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001a58c: 94 10 20 00 clr %o2
4001a590: 7f ff ba 75 call 40008f64 <rtems_semaphore_obtain>
4001a594: b6 06 ff ff add %i3, -1, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a598: 80 a2 20 00 cmp %o0, 0
4001a59c: 22 80 00 08 be,a 4001a5bc <msdos_file_stat+0x4c> <== ALWAYS TAKEN
4001a5a0: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
4001a5a4: 40 00 00 ca call 4001a8cc <__errno> <== NOT EXECUTED
4001a5a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a5ac: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a5b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a5b4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a5b8: 81 e8 00 00 restore <== NOT EXECUTED
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
4001a5bc: 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);
4001a5c0: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
4001a5c4: c2 07 20 0c ld [ %i4 + 0xc ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001a5c8: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
4001a5cc: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
4001a5d0: 03 00 00 20 sethi %hi(0x8000), %g1
4001a5d4: 82 10 61 ff or %g1, 0x1ff, %g1 ! 81ff <PROM_START+0x81ff>
4001a5d8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001a5dc: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001a5e0: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
4001a5e4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
4001a5e8: 82 06 c0 01 add %i3, %g1, %g1
4001a5ec: b6 28 40 1b andn %g1, %i3, %i3
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
4001a5f0: c2 17 60 06 lduh [ %i5 + 6 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001a5f4: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
4001a5f8: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001a5fc: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001a600: c0 26 60 20 clr [ %i1 + 0x20 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
4001a604: b7 36 e0 09 srl %i3, 9, %i3
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
4001a608: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
4001a60c: f6 26 60 44 st %i3, [ %i1 + 0x44 ]
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
4001a610: 7f ff ba 9e call 40009088 <rtems_semaphore_release>
4001a614: b0 10 20 00 clr %i0
return RC_OK;
}
4001a618: 81 c7 e0 08 ret
4001a61c: 81 e8 00 00 restore
4001a708 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
4001a708: 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;
4001a70c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001a710: 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;
4001a714: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001a718: 94 10 20 00 clr %o2
4001a71c: 7f ff ba 12 call 40008f64 <rtems_semaphore_obtain>
4001a720: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a724: 80 a2 20 00 cmp %o0, 0
4001a728: 02 80 00 08 be 4001a748 <msdos_file_sync+0x40> <== ALWAYS TAKEN
4001a72c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
4001a730: 40 00 00 67 call 4001a8cc <__errno> <== NOT EXECUTED
4001a734: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001a738: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a73c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a740: 81 c7 e0 08 ret <== NOT EXECUTED
4001a744: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
4001a748: 7f ff ff 06 call 4001a360 <msdos_file_update>
4001a74c: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4001a750: b0 92 20 00 orcc %o0, 0, %i0
4001a754: 12 80 00 04 bne 4001a764 <msdos_file_sync+0x5c> <== NEVER TAKEN
4001a758: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
4001a75c: 7f ff e2 27 call 40012ff8 <fat_sync>
4001a760: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
4001a764: 7f ff ba 49 call 40009088 <rtems_semaphore_release>
4001a768: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return RC_OK;
}
4001a76c: 81 c7 e0 08 ret
4001a770: 81 e8 00 00 restore
4001a360 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
4001a360: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001a364: 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))
4001a368: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4001a36c: 80 88 60 01 btst 1, %g1
4001a370: 12 80 00 11 bne 4001a3b4 <msdos_file_update+0x54> <== NEVER TAKEN
4001a374: 90 10 20 00 clr %o0
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
4001a378: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001a37c: 7f ff f3 f0 call 4001733c <msdos_set_first_cluster_num>
4001a380: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001a384: 80 a2 20 00 cmp %o0, 0
4001a388: 12 80 00 0b bne 4001a3b4 <msdos_file_update+0x54> <== NEVER TAKEN
4001a38c: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
4001a390: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001a394: 7f ff f4 1c call 40017404 <msdos_set_file_size>
4001a398: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001a39c: 80 a2 20 00 cmp %o0, 0
4001a3a0: 12 80 00 05 bne 4001a3b4 <msdos_file_update+0x54> <== NEVER TAKEN
4001a3a4: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
4001a3a8: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
4001a3ac: 7f ff f3 a9 call 40017250 <msdos_set_dir_wrt_time_and_date>
4001a3b0: 81 e8 00 00 restore
return rc;
}
}
return rc;
}
4001a3b4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a3b8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4001a498 <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)
{
4001a498: 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;
4001a49c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001a4a0: 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;
4001a4a4: 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,
4001a4a8: 92 10 20 00 clr %o1
4001a4ac: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001a4b0: 7f ff ba ad call 40008f64 <rtems_semaphore_obtain>
4001a4b4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001a4b8: 80 a2 20 00 cmp %o0, 0
4001a4bc: 22 80 00 07 be,a 4001a4d8 <msdos_file_write+0x40> <== ALWAYS TAKEN
4001a4c0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
4001a4c4: 40 00 01 02 call 4001a8cc <__errno> <== NOT EXECUTED
4001a4c8: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001a4cc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a4d0: 10 80 00 14 b 4001a520 <msdos_file_write+0x88> <== NOT EXECUTED
4001a4d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
4001a4d8: 80 88 62 00 btst 0x200, %g1
4001a4dc: 22 80 00 06 be,a 4001a4f4 <msdos_file_write+0x5c>
4001a4e0: d4 06 20 0c ld [ %i0 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
4001a4e4: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
4001a4e8: c0 26 20 08 clr [ %i0 + 8 ]
4001a4ec: c2 26 20 0c st %g1, [ %i0 + 0xc ]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
4001a4f0: d4 06 20 0c ld [ %i0 + 0xc ], %o2
4001a4f4: 98 10 00 19 mov %i1, %o4
4001a4f8: 90 10 00 10 mov %l0, %o0
4001a4fc: 92 10 00 11 mov %l1, %o1
4001a500: 7f ff de 64 call 40011e90 <fat_file_write>
4001a504: 96 10 00 1a mov %i2, %o3
buffer);
if (ret < 0)
4001a508: b2 92 20 00 orcc %o0, 0, %i1
4001a50c: 36 80 00 07 bge,a 4001a528 <msdos_file_write+0x90> <== ALWAYS TAKEN
4001a510: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
{
rtems_semaphore_release(fs_info->vol_sema);
4001a514: 7f ff ba dd call 40009088 <rtems_semaphore_release> <== NOT EXECUTED
4001a518: d0 04 20 9c ld [ %l0 + 0x9c ], %o0 <== NOT EXECUTED
return -1;
4001a51c: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001a520: 81 c7 e0 08 ret <== NOT EXECUTED
4001a524: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
4001a528: b9 3e 60 1f sra %i1, 0x1f, %i4
4001a52c: 86 86 40 1b addcc %i1, %i3, %g3
4001a530: 84 47 00 1a addx %i4, %i2, %g2
4001a534: c4 3e 20 08 std %g2, [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
4001a538: 80 a0 a0 00 cmp %g2, 0
4001a53c: 14 80 00 07 bg 4001a558 <msdos_file_write+0xc0> <== NEVER TAKEN
4001a540: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
4001a544: 80 a0 a0 00 cmp %g2, 0
4001a548: 12 80 00 05 bne 4001a55c <msdos_file_write+0xc4> <== NEVER TAKEN
4001a54c: 80 a0 c0 01 cmp %g3, %g1
4001a550: 08 80 00 03 bleu 4001a55c <msdos_file_write+0xc4>
4001a554: 01 00 00 00 nop
fat_fd->fat_file_size = iop->offset;
4001a558: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
rtems_semaphore_release(fs_info->vol_sema);
4001a55c: 7f ff ba cb call 40009088 <rtems_semaphore_release>
4001a560: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001a564: b0 10 00 19 mov %i1, %i0
4001a568: 81 c7 e0 08 ret
4001a56c: 81 e8 00 00 restore
40019c44 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
40019c44: 82 10 20 00 clr %g1
dn[i] = ' ';
40019c48: 84 10 20 20 mov 0x20, %g2
40019c4c: 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++)
40019c50: 82 00 60 01 inc %g1
40019c54: 80 a0 60 0b cmp %g1, 0xb
40019c58: 32 bf ff fe bne,a 40019c50 <msdos_filename_unix2dos+0xc>
40019c5c: 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) {
40019c60: c2 4a 00 00 ldsb [ %o0 ], %g1
40019c64: 80 a0 60 2e cmp %g1, 0x2e
40019c68: 12 80 00 12 bne 40019cb0 <msdos_filename_unix2dos+0x6c> <== ALWAYS TAKEN
40019c6c: 80 a2 60 00 cmp %o1, 0
40019c70: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
40019c74: 32 80 00 04 bne,a 40019c84 <msdos_filename_unix2dos+0x40><== NOT EXECUTED
40019c78: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
dn[0] = '.';
return 0;
40019c7c: 10 80 00 4f b 40019db8 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
40019c80: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
40019c84: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
40019c88: 12 80 00 0a bne 40019cb0 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
40019c8c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
40019c90: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
40019c94: 12 80 00 07 bne 40019cb0 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
40019c98: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
dn[0] = '.';
40019c9c: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
40019ca0: 10 80 00 46 b 40019db8 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
40019ca4: c2 2a a0 01 stb %g1, [ %o2 + 1 ] <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
unlen--;
40019ca8: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
40019cac: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
40019cb0: 32 80 00 05 bne,a 40019cc4 <msdos_filename_unix2dos+0x80><== ALWAYS TAKEN
40019cb4: c2 4a 00 00 ldsb [ %o0 ], %g1
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
40019cb8: 82 10 20 00 clr %g1 <== NOT EXECUTED
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
40019cbc: 10 80 00 0d b 40019cf0 <msdos_filename_unix2dos+0xac>
40019cc0: 1b 10 00 ad sethi %hi(0x4002b400), %o5
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
40019cc4: 80 a0 60 2e cmp %g1, 0x2e
40019cc8: 22 bf ff f8 be,a 40019ca8 <msdos_filename_unix2dos+0x64> <== NEVER TAKEN
40019ccc: 90 02 20 01 inc %o0 <== NOT EXECUTED
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
40019cd0: 10 bf ff fb b 40019cbc <msdos_filename_unix2dos+0x78>
40019cd4: 82 10 20 00 clr %g1
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
40019cd8: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
40019cdc: 80 89 20 ff btst 0xff, %g4
40019ce0: 02 80 00 1a be 40019d48 <msdos_filename_unix2dos+0x104>
40019ce4: 80 a0 a0 00 cmp %g2, 0
break;
dn[i] = msdos_map[c];
40019ce8: c8 2a 80 01 stb %g4, [ %o2 + %g1 ]
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
40019cec: 82 00 60 01 inc %g1
40019cf0: 84 a2 40 01 subcc %o1, %g1, %g2
40019cf4: 02 80 00 14 be 40019d44 <msdos_filename_unix2dos+0x100>
40019cf8: 86 02 00 01 add %o0, %g1, %g3
40019cfc: 80 a0 60 07 cmp %g1, 7
40019d00: 04 80 00 03 ble 40019d0c <msdos_filename_unix2dos+0xc8>
40019d04: 88 10 20 01 mov 1, %g4
40019d08: 88 10 20 00 clr %g4
40019d0c: 80 89 20 ff btst 0xff, %g4
40019d10: 02 80 00 0e be 40019d48 <msdos_filename_unix2dos+0x104>
40019d14: 80 a0 a0 00 cmp %g2, 0
40019d18: c8 0a 00 01 ldub [ %o0 + %g1 ], %g4
40019d1c: 80 a1 20 00 cmp %g4, 0
40019d20: 02 80 00 09 be 40019d44 <msdos_filename_unix2dos+0x100> <== NEVER TAKEN
40019d24: 80 a1 20 2e cmp %g4, 0x2e
40019d28: 12 bf ff ec bne 40019cd8 <msdos_filename_unix2dos+0x94>
40019d2c: 98 13 63 f0 or %o5, 0x3f0, %o4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
40019d30: 10 80 00 06 b 40019d48 <msdos_filename_unix2dos+0x104>
40019d34: 80 a0 a0 00 cmp %g2, 0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
40019d38: 80 a0 60 2e cmp %g1, 0x2e
40019d3c: 02 80 00 09 be 40019d60 <msdos_filename_unix2dos+0x11c>
40019d40: 84 00 bf ff add %g2, -1, %g2
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
40019d44: 80 a0 a0 00 cmp %g2, 0
40019d48: 02 80 00 07 be 40019d64 <msdos_filename_unix2dos+0x120>
40019d4c: 82 10 20 08 mov 8, %g1
40019d50: c2 08 c0 00 ldub [ %g3 ], %g1
40019d54: 80 a0 60 00 cmp %g1, 0
40019d58: 32 bf ff f8 bne,a 40019d38 <msdos_filename_unix2dos+0xf4><== ALWAYS TAKEN
40019d5c: 86 00 e0 01 inc %g3
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
40019d60: 82 10 20 08 mov 8, %g1
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
if (msdos_map[c] == 0)
40019d64: 10 80 00 08 b 40019d84 <msdos_filename_unix2dos+0x140>
40019d68: 1b 10 00 ad sethi %hi(0x4002b400), %o5
40019d6c: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
40019d70: 80 89 20 ff btst 0xff, %g4
40019d74: 02 80 00 11 be 40019db8 <msdos_filename_unix2dos+0x174>
40019d78: 84 00 bf ff add %g2, -1, %g2
break;
dn[i] = msdos_map[c];
40019d7c: c8 2a 80 01 stb %g4, [ %o2 + %g1 ]
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
40019d80: 82 00 60 01 inc %g1
40019d84: 80 a0 a0 00 cmp %g2, 0
40019d88: 02 80 00 0c be 40019db8 <msdos_filename_unix2dos+0x174>
40019d8c: 80 a0 60 0a cmp %g1, 0xa
40019d90: 04 80 00 03 ble 40019d9c <msdos_filename_unix2dos+0x158> <== ALWAYS TAKEN
40019d94: 88 10 20 01 mov 1, %g4
40019d98: 88 10 20 00 clr %g4 <== NOT EXECUTED
40019d9c: 80 89 20 ff btst 0xff, %g4
40019da0: 02 80 00 06 be 40019db8 <msdos_filename_unix2dos+0x174> <== NEVER TAKEN
40019da4: 88 00 c0 01 add %g3, %g1, %g4
40019da8: c8 09 3f f8 ldub [ %g4 + -8 ], %g4
40019dac: 80 a1 20 00 cmp %g4, 0
40019db0: 12 bf ff ef bne 40019d6c <msdos_filename_unix2dos+0x128> <== ALWAYS TAKEN
40019db4: 98 13 63 f0 or %o5, 0x3f0, %o4
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
40019db8: 81 c3 e0 08 retl
40019dbc: 90 10 20 00 clr %o0
40018578 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
40018578: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
4001857c: 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);
40018580: b8 07 bf e0 add %fp, -32, %i4
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40018584: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40018588: 92 10 20 00 clr %o1
4001858c: 94 10 20 20 mov 0x20, %o2
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
40018590: 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);
40018594: 40 00 0b b0 call 4001b454 <memset>
40018598: 90 10 00 1c mov %i4, %o0
name_type = msdos_long_to_short (name,
4001859c: 92 10 00 1a mov %i2, %o1
400185a0: 94 10 00 1c mov %i4, %o2
400185a4: 96 10 20 0b mov 0xb, %o3
400185a8: 7f ff fa 9f call 40017024 <msdos_long_to_short>
400185ac: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
400185b0: b6 10 00 18 mov %i0, %i3
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
400185b4: 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,
400185b8: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
400185bc: 90 10 00 18 mov %i0, %o0
400185c0: 92 10 20 00 clr %o1
400185c4: 94 10 00 19 mov %i1, %o2
400185c8: 96 10 00 1a mov %i2, %o3
400185cc: 7f ff ff ab call 40018478 <msdos_get_name_node>
400185d0: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
400185d4: b0 92 20 00 orcc %o0, 0, %i0
400185d8: 12 80 00 68 bne 40018778 <msdos_find_name+0x200>
400185dc: 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;
400185e0: 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) ||
400185e4: 84 08 60 08 and %g1, 8, %g2
400185e8: 80 88 a0 ff btst 0xff, %g2
400185ec: 12 80 00 63 bne 40018778 <msdos_find_name+0x200> <== NEVER TAKEN
400185f0: b0 16 21 01 or %i0, 0x101, %i0
400185f4: 82 08 60 3f and %g1, 0x3f, %g1
400185f8: 80 a0 60 0f cmp %g1, 0xf
400185fc: 02 80 00 5f be 40018778 <msdos_find_name+0x200> <== NEVER TAKEN
40018600: 90 10 00 1d mov %i5, %o0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
40018604: 92 07 bf d0 add %fp, -48, %o1
40018608: 7f ff e4 15 call 4001165c <fat_file_open>
4001860c: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
40018610: b0 92 20 00 orcc %o0, 0, %i0
40018614: 12 80 00 59 bne 40018778 <msdos_find_name+0x200> <== NEVER TAKEN
40018618: f8 07 bf cc ld [ %fp + -52 ], %i4
return rc;
fat_fd->dir_pos = dir_pos;
4001861c: 92 07 bf d0 add %fp, -48, %o1
40018620: 90 07 20 20 add %i4, 0x20, %o0
40018624: 40 00 0b 4f call 4001b360 <memcpy>
40018628: 94 10 20 10 mov 0x10, %o2
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
4001862c: c2 07 20 08 ld [ %i4 + 8 ], %g1
40018630: 80 a0 60 01 cmp %g1, 1
40018634: 32 80 00 49 bne,a 40018758 <msdos_find_name+0x1e0>
40018638: d2 06 e0 08 ld [ %i3 + 8 ], %o1
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001863c: c2 17 bf f4 lduh [ %fp + -12 ], %g1
40018640: 83 28 60 10 sll %g1, 0x10, %g1
40018644: 85 30 60 18 srl %g1, 0x18, %g2
40018648: 87 30 60 08 srl %g1, 8, %g3
4001864c: 03 00 00 3f sethi %hi(0xfc00), %g1
40018650: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40018654: 86 08 c0 01 and %g3, %g1, %g3
40018658: 86 10 80 03 or %g2, %g3, %g3
4001865c: c4 17 bf fa lduh [ %fp + -6 ], %g2
40018660: 87 28 e0 10 sll %g3, 0x10, %g3
40018664: 85 28 a0 10 sll %g2, 0x10, %g2
40018668: 89 30 a0 18 srl %g2, 0x18, %g4
4001866c: 85 30 a0 08 srl %g2, 8, %g2
40018670: 84 08 80 01 and %g2, %g1, %g2
40018674: 84 11 00 02 or %g4, %g2, %g2
40018678: 84 10 c0 02 or %g3, %g2, %g2
4001867c: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
40018680: c4 17 bf f8 lduh [ %fp + -8 ], %g2
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40018684: 85 28 a0 10 sll %g2, 0x10, %g2
40018688: 91 30 a0 18 srl %g2, 0x18, %o0
4001868c: 85 30 a0 08 srl %g2, 8, %g2
40018690: 86 08 80 01 and %g2, %g1, %g3
40018694: c4 17 bf f6 lduh [ %fp + -10 ], %g2
40018698: 90 12 00 03 or %o0, %g3, %o0
4001869c: 85 28 a0 10 sll %g2, 0x10, %g2
400186a0: 93 30 a0 18 srl %g2, 0x18, %o1
400186a4: 85 30 a0 08 srl %g2, 8, %g2
400186a8: 82 08 80 01 and %g2, %g1, %g1
400186ac: 40 00 05 1e call 40019b24 <msdos_date_dos2unix>
400186b0: 92 12 40 01 or %o1, %g1, %o1
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
400186b4: c2 0f bf eb ldub [ %fp + -21 ], %g1
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
400186b8: d0 27 20 40 st %o0, [ %i4 + 0x40 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
400186bc: 82 08 60 10 and %g1, 0x10, %g1
400186c0: 80 88 60 ff btst 0xff, %g1
400186c4: 02 80 00 0e be 400186fc <msdos_find_name+0x184>
400186c8: f8 07 bf cc ld [ %fp + -52 ], %i4
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
400186cc: 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;
400186d0: c0 27 20 10 clr [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
400186d4: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400186d8: 90 10 00 1d mov %i5, %o0
400186dc: 7f ff e6 8d call 40012110 <fat_file_size>
400186e0: 92 10 00 1c mov %i4, %o1
if (rc != RC_OK)
400186e4: b0 92 20 00 orcc %o0, 0, %i0
400186e8: 02 80 00 0d be 4001871c <msdos_find_name+0x1a4> <== ALWAYS TAKEN
400186ec: c2 07 bf cc ld [ %fp + -52 ], %g1
{
fat_file_close(&fs_info->fat, fat_fd);
400186f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400186f4: 10 80 00 1f b 40018770 <msdos_find_name+0x1f8> <== NOT EXECUTED
400186f8: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
400186fc: 7f ff fa 30 call 40016fbc <CPU_swap_u32>
40018700: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_fd->fat_file_type = FAT_FILE;
40018704: 82 10 20 04 mov 4, %g1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
40018708: d0 27 20 18 st %o0, [ %i4 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
4001870c: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
40018710: 82 10 3f ff mov -1, %g1
40018714: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
40018718: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_fd->map.disk_cln = fat_fd->cln;
4001871c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ((fat_fd->fat_file_size != 0) &&
40018720: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
40018724: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
40018728: 80 a0 e0 00 cmp %g3, 0
4001872c: 02 80 00 08 be 4001874c <msdos_find_name+0x1d4>
40018730: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
40018734: c8 17 60 06 lduh [ %i5 + 6 ], %g4
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
40018738: 80 a0 c0 04 cmp %g3, %g4
4001873c: 38 80 00 05 bgu,a 40018750 <msdos_find_name+0x1d8>
40018740: 84 10 3f ff mov -1, %g2
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
40018744: 10 80 00 04 b 40018754 <msdos_find_name+0x1dc>
40018748: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
4001874c: 84 10 3f ff mov -1, %g2
40018750: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
40018754: d2 06 e0 08 ld [ %i3 + 8 ], %o1
40018758: 7f ff e4 d7 call 40011ab4 <fat_file_close>
4001875c: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
40018760: b0 92 20 00 orcc %o0, 0, %i0
40018764: 02 80 00 07 be 40018780 <msdos_find_name+0x208> <== ALWAYS TAKEN
40018768: d2 07 bf cc ld [ %fp + -52 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
4001876c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018770: 7f ff e4 d1 call 40011ab4 <fat_file_close> <== NOT EXECUTED
40018774: 01 00 00 00 nop <== NOT EXECUTED
40018778: 81 c7 e0 08 ret
4001877c: 81 e8 00 00 restore
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
40018780: d2 26 e0 08 st %o1, [ %i3 + 8 ]
return rc;
}
40018784: 81 c7 e0 08 ret
40018788: 81 e8 00 00 restore
400176cc <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
)
{
400176cc: 9d e3 bf 60 save %sp, -160, %sp
400176d0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400176d4: 84 10 00 1a mov %i2, %g2
400176d8: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
400176dc: e8 07 a0 60 ld [ %fp + 0x60 ], %l4
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
400176e0: 80 a7 20 00 cmp %i4, 0
400176e4: 14 80 00 0a bg 4001770c <msdos_find_name_in_fat_file+0x40><== ALWAYS TAKEN
400176e8: e0 06 20 08 ld [ %i0 + 8 ], %l0
400176ec: 11 10 00 ad sethi %hi(0x4002b400), %o0 <== NOT EXECUTED
400176f0: 15 10 00 ad sethi %hi(0x4002b400), %o2 <== NOT EXECUTED
400176f4: 17 10 00 ad sethi %hi(0x4002b400), %o3 <== NOT EXECUTED
400176f8: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
400176fc: 92 10 23 c9 mov 0x3c9, %o1 <== NOT EXECUTED
40017700: 94 12 a3 a0 or %o2, 0x3a0, %o2 <== NOT EXECUTED
40017704: 10 80 00 3e b 400177fc <msdos_find_name_in_fat_file+0x130><== NOT EXECUTED
40017708: 96 12 e3 60 or %o3, 0x360, %o3 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001770c: 82 10 3f ff mov -1, %g1
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
40017710: c0 24 80 00 clr [ %l2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40017714: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40017718: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
4001771c: c2 27 bf fc st %g1, [ %fp + -4 ]
40017720: c2 27 bf f8 st %g1, [ %fp + -8 ]
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
40017724: 82 1f 60 01 xor %i5, 1, %g1
40017728: 80 a0 00 01 cmp %g0, %g1
4001772c: b4 60 3f ff subx %g0, -1, %i2
40017730: 80 8e a0 ff btst 0xff, %i2
40017734: 02 80 00 05 be 40017748 <msdos_find_name_in_fat_file+0x7c>
40017738: c0 24 a0 04 clr [ %l2 + 4 ]
4001773c: 80 a0 a0 00 cmp %g2, 0
40017740: 12 80 00 08 bne 40017760 <msdos_find_name_in_fat_file+0x94>
40017744: a6 10 20 00 clr %l3
lfn_entries = 0;
else
lfn_entries =
40017748: c4 27 bf d0 st %g2, [ %fp + -48 ]
4001774c: 90 07 20 0c add %i4, 0xc, %o0
40017750: 7f ff ab fc call 40002740 <.div>
40017754: 92 10 20 0d mov 0xd, %o1
40017758: c4 07 bf d0 ld [ %fp + -48 ], %g2
4001775c: a6 10 00 08 mov %o0, %l3
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40017760: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40017764: 80 a0 60 01 cmp %g1, 1
40017768: 32 80 00 0b bne,a 40017794 <msdos_find_name_in_fat_file+0xc8>
4001776c: e2 14 20 06 lduh [ %l0 + 6 ], %l1
40017770: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40017774: 80 a0 60 00 cmp %g1, 0
40017778: 32 80 00 07 bne,a 40017794 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
4001777c: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
40017780: c2 0c 20 0e ldub [ %l0 + 0xe ], %g1
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40017784: 80 88 60 03 btst 3, %g1
40017788: 22 80 00 03 be,a 40017794 <msdos_find_name_in_fat_file+0xc8>
4001778c: e2 14 20 06 lduh [ %l0 + 6 ], %l1
40017790: e2 06 60 18 ld [ %i1 + 0x18 ], %l1
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
40017794: b4 0e a0 ff and %i2, 0xff, %i2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
40017798: 82 04 e0 01 add %l3, 1, %g1
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
4001779c: 88 10 20 00 clr %g4
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
400177a0: c0 2f bf e7 clrb [ %fp + -25 ]
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
400177a4: b0 10 20 00 clr %i0
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
400177a8: ae 10 20 00 clr %l7
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
400177ac: ac 10 20 00 clr %l6
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
400177b0: 86 10 20 00 clr %g3
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
400177b4: c0 2f bf ef clrb [ %fp + -17 ]
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
400177b8: 9a 10 20 00 clr %o5
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
400177bc: b6 10 20 00 clr %i3
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
400177c0: f4 27 bf dc st %i2, [ %fp + -36 ]
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
400177c4: 10 80 00 eb b 40017b70 <msdos_find_name_in_fat_file+0x4a4>
400177c8: c2 27 bf d8 st %g1, [ %fp + -40 ]
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400177cc: 80 a2 20 1f cmp %o0, 0x1f
400177d0: 04 80 02 02 ble 40017fd8 <msdos_find_name_in_fat_file+0x90c><== NEVER TAKEN
400177d4: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
400177d8: 22 80 00 0b be,a 40017804 <msdos_find_name_in_fat_file+0x138><== ALWAYS TAKEN
400177dc: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
400177e0: 11 10 00 ad sethi %hi(0x4002b400), %o0 <== NOT EXECUTED
400177e4: 15 10 00 ad sethi %hi(0x4002b400), %o2 <== NOT EXECUTED
400177e8: 17 10 00 ad sethi %hi(0x4002b400), %o3 <== NOT EXECUTED
400177ec: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
400177f0: 92 10 23 f9 mov 0x3f9, %o1 <== NOT EXECUTED
400177f4: 94 12 a3 a0 or %o2, 0x3a0, %o2 <== NOT EXECUTED
400177f8: 96 12 e3 70 or %o3, 0x370, %o3 <== NOT EXECUTED
400177fc: 7f ff b4 5b call 40004968 <__assert_func> <== NOT EXECUTED
40017800: 01 00 00 00 nop <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
40017804: b4 10 20 00 clr %i2 ! 0 <PROM_START>
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
40017808: 80 a6 20 00 cmp %i0, 0
4001780c: 12 80 00 04 bne 4001781c <msdos_find_name_in_fat_file+0x150>
40017810: de 0d 40 00 ldub [ %l5 ], %o7
40017814: ae 10 00 1a mov %i2, %l7
40017818: ac 10 00 1b mov %i3, %l6
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
4001781c: 98 8b e0 ff andcc %o7, 0xff, %o4
40017820: 12 80 00 11 bne 40017864 <msdos_find_name_in_fat_file+0x198>
40017824: 80 a3 20 e5 cmp %o4, 0xe5
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
40017828: 80 a0 a0 00 cmp %g2, 0
4001782c: 12 80 00 06 bne 40017844 <msdos_find_name_in_fat_file+0x178>
40017830: c4 0f bf e7 ldub [ %fp + -25 ], %g2
return MSDOS_NAME_NOT_FOUND_ERR;
40017834: 31 00 00 1f sethi %hi(0x7c00), %i0
40017838: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
4001783c: 81 c7 e0 08 ret
40017840: 81 e8 00 00 restore
* Lets go and write the directory entries. If we have not found
* any available space add the remaining number of entries to any that
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
40017844: 80 88 a0 ff btst 0xff, %g2
40017848: 12 80 00 dc bne 40017bb8 <msdos_find_name_in_fat_file+0x4ec>
4001784c: 80 a7 60 02 cmp %i5, 2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40017850: 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);
40017854: b5 36 a0 05 srl %i2, 5, %i2
40017858: b0 06 00 02 add %i0, %g2, %i0
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
4001785c: 10 80 00 d7 b 40017bb8 <msdos_find_name_in_fat_file+0x4ec>
40017860: b0 26 00 1a sub %i0, %i2, %i0
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
40017864: 12 80 00 0c bne 40017894 <msdos_find_name_in_fat_file+0x1c8>
40017868: c2 0f bf e7 ldub [ %fp + -25 ], %g1
{
if (create_node)
4001786c: 80 a0 a0 00 cmp %g2, 0
40017870: 22 80 00 bb be,a 40017b5c <msdos_find_name_in_fat_file+0x490>
40017874: b4 06 a0 20 add %i2, 0x20, %i2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
40017878: c2 07 bf d8 ld [ %fp + -40 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
4001787c: b0 06 20 01 inc %i0
if (empty_space_count == (lfn_entries + 1))
40017880: 80 a6 00 01 cmp %i0, %g1
40017884: 32 80 00 b6 bne,a 40017b5c <msdos_find_name_in_fat_file+0x490>
40017888: b4 06 a0 20 add %i2, 0x20, %i2
empty_space_found = true;
4001788c: 10 80 00 b2 b 40017b54 <msdos_find_name_in_fat_file+0x488>
40017890: 82 10 20 01 mov 1, %g1
* A valid entry so handle it.
*
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
40017894: 98 18 60 01 xor %g1, 1, %o4
40017898: 80 8b 20 ff btst 0xff, %o4
4001789c: 02 80 00 07 be 400178b8 <msdos_find_name_in_fat_file+0x1ec><== NEVER TAKEN
400178a0: d8 0d 60 0b ldub [ %l5 + 0xb ], %o4
400178a4: 80 a0 a0 00 cmp %g2, 0
400178a8: 02 80 00 04 be 400178b8 <msdos_find_name_in_fat_file+0x1ec>
400178ac: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
400178b0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
{
empty_space_entry = 0;
400178b4: ae 10 20 00 clr %l7
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
400178b8: 98 0b 20 3f and %o4, 0x3f, %o4
400178bc: 80 a3 20 0f cmp %o4, 0xf
400178c0: 12 80 00 54 bne 40017a10 <msdos_find_name_in_fat_file+0x344>
400178c4: 80 8b 60 ff btst 0xff, %o5
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
400178c8: d8 07 bf f8 ld [ %fp + -8 ], %o4
400178cc: 80 a3 3f ff cmp %o4, -1
400178d0: 32 80 00 10 bne,a 40017910 <msdos_find_name_in_fat_file+0x244>
400178d4: de 0d 40 00 ldub [ %l5 ], %o7
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
400178d8: 98 0b e0 40 and %o7, 0x40, %o4
400178dc: 80 8b 20 ff btst 0xff, %o4
400178e0: 02 80 00 9e be 40017b58 <msdos_find_name_in_fat_file+0x48c>
400178e4: 9a 10 20 00 clr %o5
* entry match the number we expect for this
* file name. Note we do not know the number of
* characters in the entry so this is check further
* on when the characters are checked.
*/
if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
400178e8: 9e 0b e0 3f and %o7, 0x3f, %o7
400178ec: 80 a4 c0 0f cmp %l3, %o7
400178f0: 32 80 00 9b bne,a 40017b5c <msdos_find_name_in_fat_file+0x490>
400178f4: b4 06 a0 20 add %i2, 0x20, %i2
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
400178f8: f6 27 bf f8 st %i3, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
400178fc: f4 27 bf fc st %i2, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
40017900: c6 0d 60 0d ldub [ %l5 + 0xd ], %g3
40017904: c6 2f bf ef stb %g3, [ %fp + -17 ]
40017908: 86 10 00 13 mov %l3, %g3
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
4001790c: de 0d 40 00 ldub [ %l5 ], %o7
40017910: 9e 0b e0 3f and %o7, 0x3f, %o7
40017914: 80 a0 c0 0f cmp %g3, %o7
40017918: 12 80 00 07 bne 40017934 <msdos_find_name_in_fat_file+0x268><== NEVER TAKEN
4001791c: 82 10 3f ff mov -1, %g1
MSDOS_LAST_LONG_ENTRY_MASK)) ||
40017920: d8 0f bf ef ldub [ %fp + -17 ], %o4
40017924: de 0d 60 0d ldub [ %l5 + 0xd ], %o7
40017928: 80 a3 00 0f cmp %o4, %o7
4001792c: 02 80 00 04 be 4001793c <msdos_find_name_in_fat_file+0x270><== ALWAYS TAKEN
40017930: 98 00 ff ff add %g3, -1, %o4
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
40017934: 10 80 00 89 b 40017b58 <msdos_find_name_in_fat_file+0x48c><== NOT EXECUTED
40017938: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
4001793c: 9f 2b 20 02 sll %o4, 2, %o7
40017940: 97 2b 20 04 sll %o4, 4, %o3
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017944: 9a 05 60 01 add %l5, 1, %o5
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
40017948: 96 22 c0 0f sub %o3, %o7, %o3
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
4001794c: 9e 10 20 00 clr %o7
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
40017950: 96 02 c0 0c add %o3, %o4, %o3
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
40017954: d4 4b 40 00 ldsb [ %o5 ], %o2
40017958: 80 a2 a0 00 cmp %o2, 0
4001795c: 12 80 00 0b bne 40017988 <msdos_find_name_in_fat_file+0x2bc>
40017960: 92 03 c0 0b add %o7, %o3, %o1
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
40017964: 80 a0 c0 13 cmp %g3, %l3
40017968: 12 80 00 22 bne 400179f0 <msdos_find_name_in_fat_file+0x324><== NEVER TAKEN
4001796c: 80 a3 20 00 cmp %o4, 0
((o + i) != name_len))
40017970: 9e 02 c0 0f add %o3, %o7, %o7
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
40017974: 80 a3 c0 1c cmp %o7, %i4
40017978: 02 80 00 1e be 400179f0 <msdos_find_name_in_fat_file+0x324><== ALWAYS TAKEN
4001797c: 80 a3 20 00 cmp %o4, 0
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
40017980: 10 80 00 0b b 400179ac <msdos_find_name_in_fat_file+0x2e0><== NOT EXECUTED
40017984: 86 10 3f ff mov -1, %g3 <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
40017988: 80 a2 40 1c cmp %o1, %i4
4001798c: 16 80 00 07 bge 400179a8 <msdos_find_name_in_fat_file+0x2dc>
40017990: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017994: 92 00 40 0b add %g1, %o3, %o1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
40017998: d2 4a 40 0f ldsb [ %o1 + %o7 ], %o1
4001799c: 80 a2 80 09 cmp %o2, %o1
400179a0: 02 80 00 05 be 400179b4 <msdos_find_name_in_fat_file+0x2e8>
400179a4: 80 a3 e0 04 cmp %o7, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
400179a8: 86 10 3f ff mov -1, %g3
break;
400179ac: 10 80 00 10 b 400179ec <msdos_find_name_in_fat_file+0x320>
400179b0: c6 27 bf f8 st %g3, [ %fp + -8 ]
}
switch (i)
400179b4: 02 80 00 06 be 400179cc <msdos_find_name_in_fat_file+0x300>
400179b8: 80 a3 e0 0a cmp %o7, 0xa
400179bc: 32 80 00 08 bne,a 400179dc <msdos_find_name_in_fat_file+0x310>
400179c0: 9a 03 60 02 add %o5, 2, %o5
{
case 4:
p += 5;
break;
case 10:
p += 4;
400179c4: 10 80 00 04 b 400179d4 <msdos_find_name_in_fat_file+0x308>
400179c8: 9a 03 60 04 add %o5, 4, %o5
switch (i)
{
case 4:
p += 5;
break;
400179cc: 10 80 00 04 b 400179dc <msdos_find_name_in_fat_file+0x310>
400179d0: 9a 03 60 05 add %o5, 5, %o5
case 10:
p += 4;
break;
400179d4: 10 80 00 03 b 400179e0 <msdos_find_name_in_fat_file+0x314>
400179d8: 9e 03 e0 01 inc %o7
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
400179dc: 9e 03 e0 01 inc %o7
400179e0: 80 a3 e0 0d cmp %o7, 0xd
400179e4: 32 bf ff dd bne,a 40017958 <msdos_find_name_in_fat_file+0x28c>
400179e8: d4 4b 40 00 ldsb [ %o5 ], %o2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
400179ec: 80 a3 20 00 cmp %o4, 0
400179f0: 12 80 00 06 bne 40017a08 <msdos_find_name_in_fat_file+0x33c>
400179f4: 9a 10 20 00 clr %o5
400179f8: c6 07 bf f8 ld [ %fp + -8 ], %g3
400179fc: 86 38 00 03 xnor %g0, %g3, %g3
40017a00: 80 a0 00 03 cmp %g0, %g3
40017a04: 9a 40 20 00 addx %g0, 0, %o5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
40017a08: 10 80 00 54 b 40017b58 <msdos_find_name_in_fat_file+0x48c>
40017a0c: 86 10 00 0c mov %o4, %g3
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
40017a10: 02 80 01 85 be 40018024 <msdos_find_name_in_fat_file+0x958>
40017a14: c2 07 bf dc ld [ %fp + -36 ], %g1
40017a18: 9a 10 20 00 clr %o5
40017a1c: 9e 10 20 00 clr %o7
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
40017a20: d6 0d 40 0d ldub [ %l5 + %o5 ], %o3
40017a24: 98 0b e0 01 and %o7, 1, %o4
40017a28: 80 a0 00 0c cmp %g0, %o4
40017a2c: 9e 0b e0 ff and %o7, 0xff, %o7
40017a30: 98 40 3f ff addx %g0, -1, %o4
40017a34: 9f 33 e0 01 srl %o7, 1, %o7
40017a38: 98 0b 20 80 and %o4, 0x80, %o4
40017a3c: 9e 02 c0 0f add %o3, %o7, %o7
40017a40: 98 03 3f 80 add %o4, -128, %o4
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
40017a44: 9a 03 60 01 inc %o5
40017a48: 80 a3 60 0b cmp %o5, 0xb
40017a4c: 12 bf ff f5 bne 40017a20 <msdos_find_name_in_fat_file+0x354>
40017a50: 9e 03 c0 0c add %o7, %o4, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
40017a54: c2 0f bf ef ldub [ %fp + -17 ], %g1
40017a58: 9e 1b c0 01 xor %o7, %g1, %o7
40017a5c: 80 8b e0 ff btst 0xff, %o7
40017a60: 12 80 01 71 bne 40018024 <msdos_find_name_in_fat_file+0x958><== NEVER TAKEN
40017a64: c2 07 bf dc ld [ %fp + -36 ], %g1
40017a68: 80 a0 e0 00 cmp %g3, 0
40017a6c: 12 80 01 6f bne 40018028 <msdos_find_name_in_fat_file+0x95c><== NEVER TAKEN
40017a70: 80 a0 60 00 cmp %g1, 0
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40017a74: 90 10 00 10 mov %l0, %o0
40017a78: 92 10 00 19 mov %i1, %o1
40017a7c: 94 10 20 01 mov 1, %o2
40017a80: 96 10 00 04 mov %g4, %o3
40017a84: 7f ff e8 39 call 40011b68 <fat_file_ioctl>
40017a88: 98 10 00 12 mov %l2, %o4
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
40017a8c: b0 92 20 00 orcc %o0, 0, %i0
40017a90: 02 80 00 13 be 40017adc <msdos_find_name_in_fat_file+0x410><== ALWAYS TAKEN
40017a94: d2 07 bf f8 ld [ %fp + -8 ], %o1
40017a98: 81 c7 e0 08 ret <== NOT EXECUTED
40017a9c: 81 e8 00 00 restore <== NOT EXECUTED
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
40017aa0: 80 a3 ff ff cmp %o7, -1
40017aa4: 12 80 00 29 bne 40017b48 <msdos_find_name_in_fat_file+0x47c><== NEVER TAKEN
40017aa8: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
40017aac: c4 3f bf d0 std %g2, [ %fp + -48 ]
40017ab0: c8 27 bf cc st %g4, [ %fp + -52 ]
40017ab4: 90 10 00 15 mov %l5, %o0
40017ab8: 92 10 00 14 mov %l4, %o1
40017abc: 40 00 0d ff call 4001b2b8 <memcmp>
40017ac0: 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) &&
40017ac4: c4 1f bf d0 ldd [ %fp + -48 ], %g2
40017ac8: 80 a2 20 00 cmp %o0, 0
40017acc: 12 80 00 1e bne 40017b44 <msdos_find_name_in_fat_file+0x478>
40017ad0: c8 07 bf cc ld [ %fp + -52 ], %g4
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40017ad4: 10 bf ff e9 b 40017a78 <msdos_find_name_in_fat_file+0x3ac>
40017ad8: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
40017adc: 80 a2 7f ff cmp %o1, -1
40017ae0: 12 80 00 0c bne 40017b10 <msdos_find_name_in_fat_file+0x444>
40017ae4: f4 24 a0 04 st %i2, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40017ae8: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
40017aec: 90 10 00 14 mov %l4, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40017af0: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
40017af4: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
40017af8: 92 10 00 15 mov %l5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
40017afc: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
memcpy(name_dir_entry, entry,
40017b00: 40 00 0e 18 call 4001b360 <memcpy>
40017b04: 94 10 20 20 mov 0x20, %o2
40017b08: 81 c7 e0 08 ret
40017b0c: 81 e8 00 00 restore
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40017b10: 7f ff aa d0 call 40002650 <.umul>
40017b14: 90 10 00 11 mov %l1, %o0
40017b18: 92 10 00 19 mov %i1, %o1
40017b1c: 96 10 00 08 mov %o0, %o3
40017b20: 94 10 20 01 mov 1, %o2
40017b24: 90 10 00 10 mov %l0, %o0
40017b28: 7f ff e8 10 call 40011b68 <fat_file_ioctl>
40017b2c: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
40017b30: 80 a2 20 00 cmp %o0, 0
40017b34: 12 80 01 37 bne 40018010 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
40017b38: c2 07 bf f8 ld [ %fp + -8 ], %g1
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
40017b3c: 10 bf ff ed b 40017af0 <msdos_find_name_in_fat_file+0x424>
40017b40: 90 10 00 14 mov %l4, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
40017b44: 82 10 3f ff mov -1, %g1
lfn_matched = false;
40017b48: 9a 10 20 00 clr %o5
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
40017b4c: 10 80 00 03 b 40017b58 <msdos_find_name_in_fat_file+0x48c>
40017b50: c2 27 bf f8 st %g1, [ %fp + -8 ]
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
40017b54: c2 2f bf e7 stb %g1, [ %fp + -25 ]
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40017b58: b4 06 a0 20 add %i2, 0x20, %i2
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
40017b5c: 80 a6 80 11 cmp %i2, %l1
40017b60: 0a bf ff 2a bcs 40017808 <msdos_find_name_in_fat_file+0x13c>
40017b64: aa 05 60 20 add %l5, 0x20, %l5
}
if (remainder_empty)
break;
dir_offset++;
40017b68: b6 06 e0 01 inc %i3
40017b6c: 88 01 00 11 add %g4, %l1, %g4
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40017b70: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
40017b74: 94 10 00 04 mov %g4, %o2
40017b78: c4 3f bf d0 std %g2, [ %fp + -48 ]
40017b7c: c8 27 bf cc st %g4, [ %fp + -52 ]
40017b80: da 27 bf c4 st %o5, [ %fp + -60 ]
40017b84: 90 10 00 10 mov %l0, %o0
40017b88: 92 10 00 19 mov %i1, %o1
40017b8c: 7f ff e7 17 call 400117e8 <fat_file_read>
40017b90: 96 10 00 11 mov %l1, %o3
40017b94: c4 1f bf d0 ldd [ %fp + -48 ], %g2
40017b98: 80 a2 20 00 cmp %o0, 0
40017b9c: c8 07 bf cc ld [ %fp + -52 ], %g4
40017ba0: 12 bf ff 0b bne 400177cc <msdos_find_name_in_fat_file+0x100>
40017ba4: da 07 bf c4 ld [ %fp + -60 ], %o5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
40017ba8: 80 a0 a0 00 cmp %g2, 0
40017bac: 22 bf ff 23 be,a 40017838 <msdos_find_name_in_fat_file+0x16c>
40017bb0: 31 00 00 1f sethi %hi(0x7c00), %i0
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
40017bb4: 80 a7 60 02 cmp %i5, 2
40017bb8: 12 80 00 2e bne 40017c70 <msdos_find_name_in_fat_file+0x5a4>
40017bbc: 80 a4 e0 00 cmp %l3, 0
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40017bc0: 90 10 00 16 mov %l6, %o0
40017bc4: 7f ff aa a3 call 40002650 <.umul>
40017bc8: 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 == '.'))
40017bcc: c4 4d 00 00 ldsb [ %l4 ], %g2
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
40017bd0: ba 04 e0 01 add %l3, 1, %i5
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40017bd4: 90 02 00 17 add %o0, %l7, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
40017bd8: 80 a0 a0 2e cmp %g2, 0x2e
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40017bdc: 91 32 20 05 srl %o0, 5, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
40017be0: 02 80 00 05 be 40017bf4 <msdos_find_name_in_fat_file+0x528><== NEVER TAKEN
40017be4: ba 07 40 08 add %i5, %o0, %i5
40017be8: 80 a0 a0 20 cmp %g2, 0x20
40017bec: 32 80 00 05 bne,a 40017c00 <msdos_find_name_in_fat_file+0x534>
40017bf0: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
*c = '_';
40017bf4: 84 10 20 5f mov 0x5f, %g2
40017bf8: c4 2d 00 00 stb %g2, [ %l4 ]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
40017bfc: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
40017c00: 80 a0 a0 2e cmp %g2, 0x2e
40017c04: 22 80 00 06 be,a 40017c1c <msdos_find_name_in_fat_file+0x550><== NEVER TAKEN
40017c08: 84 10 20 5f mov 0x5f, %g2 <== NOT EXECUTED
40017c0c: 80 a0 a0 20 cmp %g2, 0x20
40017c10: 12 80 00 05 bne 40017c24 <msdos_find_name_in_fat_file+0x558>
40017c14: 86 05 20 02 add %l4, 2, %g3
*c = '_';
40017c18: 84 10 20 5f mov 0x5f, %g2
40017c1c: c4 2d 20 01 stb %g2, [ %l4 + 1 ]
msdos_short_name_hex(char* sfn, int num)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
40017c20: 86 05 20 02 add %l4, 2, %g3
40017c24: 84 10 20 00 clr %g2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40017c28: 35 10 00 ab sethi %hi(0x4002ac00), %i2
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017c2c: 88 20 00 02 neg %g2, %g4
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40017c30: b8 16 a2 98 or %i2, 0x298, %i4
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017c34: 89 29 20 02 sll %g4, 2, %g4
40017c38: 88 01 20 0c add %g4, 0xc, %g4
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40017c3c: 89 3f 40 04 sra %i5, %g4, %g4
40017c40: 88 09 20 0f and %g4, 0xf, %g4
40017c44: c8 0f 00 04 ldub [ %i4 + %g4 ], %g4
40017c48: c8 28 c0 02 stb %g4, [ %g3 + %g2 ]
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
40017c4c: 84 00 a0 01 inc %g2
40017c50: 80 a0 a0 04 cmp %g2, 4
40017c54: 12 bf ff f8 bne 40017c34 <msdos_find_name_in_fat_file+0x568>
40017c58: 88 20 00 02 neg %g2, %g4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
40017c5c: 84 10 20 7e mov 0x7e, %g2
40017c60: c4 2d 20 06 stb %g2, [ %l4 + 6 ]
*c++ = '1';
40017c64: 84 10 20 31 mov 0x31, %g2
40017c68: c4 2d 20 07 stb %g2, [ %l4 + 7 ]
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
40017c6c: 80 a4 e0 00 cmp %l3, 0
40017c70: 02 80 00 10 be 40017cb0 <msdos_find_name_in_fat_file+0x5e4>
40017c74: b8 10 20 00 clr %i4
40017c78: 84 10 20 00 clr %g2
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
40017c7c: c8 0d 00 02 ldub [ %l4 + %g2 ], %g4
40017c80: 86 0f 20 01 and %i4, 1, %g3
40017c84: 80 a0 00 03 cmp %g0, %g3
40017c88: b8 0f 20 ff and %i4, 0xff, %i4
40017c8c: 86 40 3f ff addx %g0, -1, %g3
40017c90: b9 37 20 01 srl %i4, 1, %i4
40017c94: 86 08 e0 80 and %g3, 0x80, %g3
40017c98: b8 01 00 1c add %g4, %i4, %i4
40017c9c: 86 00 ff 80 add %g3, -128, %g3
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
40017ca0: 84 00 a0 01 inc %g2
40017ca4: 80 a0 a0 0b cmp %g2, 0xb
40017ca8: 12 bf ff f5 bne 40017c7c <msdos_find_name_in_fat_file+0x5b0>
40017cac: b8 07 00 03 add %i4, %g3, %i4
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
40017cb0: 80 a6 20 00 cmp %i0, 0
40017cb4: 22 80 00 06 be,a 40017ccc <msdos_find_name_in_fat_file+0x600>
40017cb8: ac 10 00 1b mov %i3, %l6
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
40017cbc: 82 1e c0 16 xor %i3, %l6, %g1
40017cc0: 80 a0 00 01 cmp %g0, %g1
40017cc4: 10 80 00 04 b 40017cd4 <msdos_find_name_in_fat_file+0x608>
40017cc8: b4 40 20 00 addx %g0, 0, %i2
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
{
read_cluster = true;
40017ccc: b4 10 20 01 mov 1, %i2
empty_space_offset = dir_offset;
empty_space_entry = 0;
40017cd0: ae 10 20 00 clr %l7
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
40017cd4: 84 10 3f ff mov -1, %g2
40017cd8: 90 10 00 16 mov %l6, %o0
40017cdc: c4 27 bf fc st %g2, [ %fp + -4 ]
40017ce0: c4 27 bf f8 st %g2, [ %fp + -8 ]
40017ce4: 7f ff aa 5b call 40002650 <.umul>
40017ce8: 92 10 00 11 mov %l1, %o1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017cec: c6 07 a0 50 ld [ %fp + 0x50 ], %g3
40017cf0: 83 2c e0 02 sll %l3, 2, %g1
40017cf4: 85 2c e0 04 sll %l3, 4, %g2
40017cf8: 82 20 80 01 sub %g2, %g1, %g1
40017cfc: 82 00 40 13 add %g1, %l3, %g1
40017d00: 82 00 c0 01 add %g3, %g1, %g1
40017d04: ba 10 00 08 mov %o0, %i5
40017d08: c2 27 bf e4 st %g1, [ %fp + -28 ]
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
40017d0c: b0 10 20 00 clr %i0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
40017d10: 82 04 e0 01 add %l3, 1, %g1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
40017d14: 10 80 00 ba b 40017ffc <msdos_find_name_in_fat_file+0x930>
40017d18: c2 27 bf ec st %g1, [ %fp + -20 ]
{
int length = 0;
if (read_cluster)
40017d1c: 02 80 00 2f be 40017dd8 <msdos_find_name_in_fat_file+0x70c>
40017d20: c6 07 bf e4 ld [ %fp + -28 ], %g3
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
40017d24: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
40017d28: 90 10 00 10 mov %l0, %o0
40017d2c: 92 10 00 19 mov %i1, %o1
40017d30: 94 10 00 1d mov %i5, %o2
40017d34: 7f ff e6 ad call 400117e8 <fat_file_read>
40017d38: 96 10 00 11 mov %l1, %o3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
40017d3c: 80 a2 00 11 cmp %o0, %l1
40017d40: 02 80 00 25 be 40017dd4 <msdos_find_name_in_fat_file+0x708><== NEVER TAKEN
40017d44: 80 a2 20 00 cmp %o0, 0
{
if (ret != FAT_EOF)
40017d48: 22 80 00 03 be,a 40017d54 <msdos_find_name_in_fat_file+0x688><== ALWAYS TAKEN
40017d4c: 90 10 00 10 mov %l0, %o0
40017d50: 30 80 00 1b b,a 40017dbc <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (&fs_info->fat, fat_fd, false,
40017d54: 92 10 00 19 mov %i1, %o1
40017d58: 94 10 20 00 clr %o2
40017d5c: 96 10 00 1d mov %i5, %o3
40017d60: 7f ff e7 b6 call 40011c38 <fat_file_extend>
40017d64: 98 07 bf f4 add %fp, -12, %o4
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
40017d68: 80 a2 20 00 cmp %o0, 0
40017d6c: 12 80 00 a9 bne 40018010 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
40017d70: 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))
40017d74: 80 a0 40 1d cmp %g1, %i5
40017d78: 22 80 00 03 be,a 40017d84 <msdos_find_name_in_fat_file+0x6b8><== ALWAYS TAKEN
40017d7c: d0 04 20 a0 ld [ %l0 + 0xa0 ], %o0
40017d80: 30 80 00 0f b,a 40017dbc <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
40017d84: 92 10 20 00 clr %o1
40017d88: 40 00 0d b3 call 4001b454 <memset>
40017d8c: 94 10 00 11 mov %l1, %o2
ret = fat_file_write(&fs_info->fat, fat_fd,
40017d90: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
40017d94: 90 10 00 10 mov %l0, %o0
40017d98: 92 10 00 19 mov %i1, %o1
40017d9c: 94 10 00 1d mov %i5, %o2
40017da0: 7f ff e8 3c call 40011e90 <fat_file_write>
40017da4: 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)
40017da8: 80 a2 3f ff cmp %o0, -1
40017dac: 02 80 00 99 be 40018010 <msdos_find_name_in_fat_file+0x944><== ALWAYS TAKEN
40017db0: 80 a2 00 11 cmp %o0, %l1
return ret;
else if (ret != bts2rd)
40017db4: 02 80 00 09 be 40017dd8 <msdos_find_name_in_fat_file+0x70c><== NOT EXECUTED
40017db8: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
40017dbc: 40 00 0a c4 call 4001a8cc <__errno> <== NOT EXECUTED
40017dc0: 01 00 00 00 nop <== NOT EXECUTED
40017dc4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40017dc8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40017dcc: 10 80 00 91 b 40018010 <msdos_find_name_in_fat_file+0x944><== NOT EXECUTED
40017dd0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017dd4: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
40017dd8: 83 2e 20 02 sll %i0, 2, %g1
40017ddc: 97 2e 20 04 sll %i0, 4, %o3
40017de0: 84 06 20 01 add %i0, 1, %g2
40017de4: 96 22 c0 01 sub %o3, %g1, %o3
40017de8: 9a 10 20 00 clr %o5
40017dec: 96 02 c0 18 add %o3, %i0, %o3
40017df0: b4 10 20 00 clr %i2
40017df4: 96 20 c0 0b sub %g3, %o3, %o3
40017df8: 10 80 00 68 b 40017f98 <msdos_find_name_in_fat_file+0x8cc>
40017dfc: 96 02 ff f3 add %o3, -13, %o3
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
40017e00: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
40017e04: c2 07 bf ec ld [ %fp + -20 ], %g1
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
40017e08: aa 03 00 1b add %o4, %i3, %l5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40017e0c: b4 06 a0 20 add %i2, 0x20, %i2
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
40017e10: 80 a0 80 01 cmp %g2, %g1
40017e14: 12 80 00 25 bne 40017ea8 <msdos_find_name_in_fat_file+0x7dc>
40017e18: b0 10 00 02 mov %g2, %i0
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40017e1c: 90 10 00 10 mov %l0, %o0
40017e20: 92 10 00 19 mov %i1, %o1
40017e24: 94 10 20 01 mov 1, %o2
40017e28: 96 10 00 1d mov %i5, %o3
40017e2c: 7f ff e7 4f call 40011b68 <fat_file_ioctl>
40017e30: 98 10 00 12 mov %l2, %o4
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
40017e34: 80 a2 20 00 cmp %o0, 0
40017e38: 12 80 00 76 bne 40018010 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
40017e3c: d2 07 bf f8 ld [ %fp + -8 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
40017e40: 80 a2 7f ff cmp %o1, -1
40017e44: 12 80 00 0c bne 40017e74 <msdos_find_name_in_fat_file+0x7a8>
40017e48: f6 24 a0 04 st %i3, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40017e4c: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40017e50: 90 10 00 15 mov %l5, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40017e54: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
40017e58: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40017e5c: 92 10 00 14 mov %l4, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
40017e60: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40017e64: 40 00 0d 3f call 4001b360 <memcpy>
40017e68: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
40017e6c: 10 80 00 50 b 40017fac <msdos_find_name_in_fat_file+0x8e0>
40017e70: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40017e74: 7f ff a9 f7 call 40002650 <.umul>
40017e78: 90 10 00 11 mov %l1, %o0
40017e7c: 92 10 00 19 mov %i1, %o1
40017e80: 96 10 00 08 mov %o0, %o3
40017e84: 94 10 20 01 mov 1, %o2
40017e88: 90 10 00 10 mov %l0, %o0
40017e8c: 7f ff e7 37 call 40011b68 <fat_file_ioctl>
40017e90: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
40017e94: 80 a2 20 00 cmp %o0, 0
40017e98: 02 bf ff ee be 40017e50 <msdos_find_name_in_fat_file+0x784><== ALWAYS TAKEN
40017e9c: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40017ea0: 81 c7 e0 08 ret <== NOT EXECUTED
40017ea4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* This is a long file name and we need to write
* a long file name entry. See if this is the
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
40017ea8: c2 07 bf f8 ld [ %fp + -8 ], %g1
40017eac: 80 a0 7f ff cmp %g1, -1
40017eb0: 32 80 00 05 bne,a 40017ec4 <msdos_find_name_in_fat_file+0x7f8>
40017eb4: d8 3f bf c0 std %o4, [ %fp + -64 ]
{
lfn_start.cln = empty_space_offset;
40017eb8: ec 27 bf f8 st %l6, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
40017ebc: f6 27 bf fc st %i3, [ %fp + -4 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40017ec0: d8 3f bf c0 std %o4, [ %fp + -64 ]
40017ec4: 94 10 20 20 mov 0x20, %o2
40017ec8: c4 27 bf d0 st %g2, [ %fp + -48 ]
40017ecc: d6 27 bf c8 st %o3, [ %fp + -56 ]
40017ed0: 90 10 00 15 mov %l5, %o0
40017ed4: 40 00 0d 60 call 4001b454 <memset>
40017ed8: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
40017edc: f8 2d 60 0d stb %i4, [ %l5 + 0xd ]
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017ee0: d6 07 bf c8 ld [ %fp + -56 ], %o3
40017ee4: da 07 bf c4 ld [ %fp + -60 ], %o5
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
40017ee8: d8 07 bf c0 ld [ %fp + -64 ], %o4
40017eec: c4 07 bf d0 ld [ %fp + -48 ], %g2
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
40017ef0: 82 05 60 01 add %l5, 1, %g1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017ef4: 9e 02 c0 0d add %o3, %o5, %o7
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
40017ef8: 94 10 20 00 clr %o2
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
40017efc: b0 10 20 00 clr %i0
{
if (*n != 0)
40017f00: d0 4b c0 00 ldsb [ %o7 ], %o0
40017f04: 80 a2 20 00 cmp %o0, 0
40017f08: 02 80 00 05 be 40017f1c <msdos_find_name_in_fat_file+0x850>
40017f0c: d2 0b c0 00 ldub [ %o7 ], %o1
{
*p = *n;
40017f10: d2 28 40 00 stb %o1, [ %g1 ]
n++;
40017f14: 10 80 00 05 b 40017f28 <msdos_find_name_in_fat_file+0x85c>
40017f18: 9e 03 e0 01 inc %o7
}
else
{
p [0] = fill;
40017f1c: d4 28 40 00 stb %o2, [ %g1 ]
p [1] = fill;
40017f20: d4 28 60 01 stb %o2, [ %g1 + 1 ]
fill = 0xff;
40017f24: 94 10 3f ff mov -1, %o2
}
switch (i)
40017f28: 80 a6 20 04 cmp %i0, 4
40017f2c: 02 80 00 06 be 40017f44 <msdos_find_name_in_fat_file+0x878>
40017f30: 80 a6 20 0a cmp %i0, 0xa
40017f34: 32 80 00 08 bne,a 40017f54 <msdos_find_name_in_fat_file+0x888>
40017f38: 82 00 60 02 add %g1, 2, %g1
{
case 4:
p += 5;
break;
case 10:
p += 4;
40017f3c: 10 80 00 04 b 40017f4c <msdos_find_name_in_fat_file+0x880>
40017f40: 82 00 60 04 add %g1, 4, %g1
switch (i)
{
case 4:
p += 5;
break;
40017f44: 10 80 00 04 b 40017f54 <msdos_find_name_in_fat_file+0x888>
40017f48: 82 00 60 05 add %g1, 5, %g1
case 10:
p += 4;
break;
40017f4c: 10 80 00 03 b 40017f58 <msdos_find_name_in_fat_file+0x88c>
40017f50: b0 06 20 01 inc %i0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
40017f54: b0 06 20 01 inc %i0
40017f58: 80 a6 20 0d cmp %i0, 0xd
40017f5c: 32 bf ff ea bne,a 40017f04 <msdos_find_name_in_fat_file+0x838>
40017f60: d0 4b c0 00 ldsb [ %o7 ], %o0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017f64: c6 07 bf ec ld [ %fp + -20 ], %g3
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
40017f68: 80 a0 a0 01 cmp %g2, 1
40017f6c: 02 80 00 04 be 40017f7c <msdos_find_name_in_fat_file+0x8b0>
40017f70: 82 20 c0 02 sub %g3, %g2, %g1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
40017f74: 10 80 00 04 b 40017f84 <msdos_find_name_in_fat_file+0x8b8>
40017f78: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
40017f7c: 82 10 60 40 or %g1, 0x40, %g1
40017f80: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
40017f84: c2 0d 60 0b ldub [ %l5 + 0xb ], %g1
40017f88: 84 00 a0 01 inc %g2
40017f8c: 82 10 60 0f or %g1, 0xf, %g1
40017f90: 9a 03 7f f3 add %o5, -13, %o5
40017f94: c2 2d 60 0b stb %g1, [ %l5 + 0xb ]
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
40017f98: b6 06 80 17 add %i2, %l7, %i3
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
40017f9c: 80 a6 c0 11 cmp %i3, %l1
40017fa0: 0a bf ff 98 bcs 40017e00 <msdos_find_name_in_fat_file+0x734><== ALWAYS TAKEN
40017fa4: b0 00 bf ff add %g2, -1, %i0
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(&fs_info->fat, fat_fd,
40017fa8: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4 <== NOT EXECUTED
40017fac: 90 10 00 10 mov %l0, %o0
40017fb0: 92 10 00 19 mov %i1, %o1
40017fb4: 94 07 40 17 add %i5, %l7, %o2
40017fb8: 96 10 00 1a mov %i2, %o3
40017fbc: 7f ff e7 b5 call 40011e90 <fat_file_write>
40017fc0: 98 03 00 17 add %o4, %l7, %o4
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
40017fc4: 80 a2 3f ff cmp %o0, -1
40017fc8: 02 80 00 14 be 40018018 <msdos_find_name_in_fat_file+0x94c><== NEVER TAKEN
40017fcc: 80 a2 00 1a cmp %o0, %i2
return ret;
else if (ret != length)
40017fd0: 02 80 00 08 be 40017ff0 <msdos_find_name_in_fat_file+0x924><== ALWAYS TAKEN
40017fd4: ba 07 40 11 add %i5, %l1, %i5
rtems_set_errno_and_return_minus_one(EIO);
40017fd8: 40 00 0a 3d call 4001a8cc <__errno> <== NOT EXECUTED
40017fdc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017fe0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40017fe4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40017fe8: 81 c7 e0 08 ret <== NOT EXECUTED
40017fec: 81 e8 00 00 restore <== NOT EXECUTED
empty_space_offset++;
40017ff0: ac 05 a0 01 inc %l6
empty_space_entry = 0;
40017ff4: ae 10 20 00 clr %l7
read_cluster = true;
40017ff8: b4 10 20 01 mov 1, %i2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
40017ffc: 80 a4 c0 18 cmp %l3, %i0
40018000: 16 bf ff 47 bge 40017d1c <msdos_find_name_in_fat_file+0x650>
40018004: 80 8e a0 ff btst 0xff, %i2
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
40018008: 81 c7 e0 08 ret
4001800c: 91 e8 20 00 restore %g0, 0, %o0
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40018010: 81 c7 e0 08 ret
40018014: 91 e8 00 08 restore %g0, %o0, %o0
}
ret = fat_file_write(&fs_info->fat, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
40018018: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001801c: 81 c7 e0 08 ret <== NOT EXECUTED
40018020: 81 e8 00 00 restore <== NOT EXECUTED
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
40018024: 80 a0 60 00 cmp %g1, 0
40018028: 02 bf fe c8 be 40017b48 <msdos_find_name_in_fat_file+0x47c>
4001802c: 82 10 3f ff mov -1, %g1
((name_type == MSDOS_NAME_SHORT) &&
40018030: 10 bf fe 9c b 40017aa0 <msdos_find_name_in_fat_file+0x3d4>
40018034: de 07 bf f8 ld [ %fp + -8 ], %o7
40018038 <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
)
{
40018038: 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) &&
4001803c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40018040: 80 a0 60 01 cmp %g1, 1
40018044: 12 80 00 0f bne 40018080 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
40018048: fa 06 20 08 ld [ %i0 + 8 ], %i5
4001804c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
40018050: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40018054: 32 80 00 07 bne,a 40018070 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
40018058: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
4001805c: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40018060: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40018064: 22 80 00 03 be,a 40018070 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
40018068: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
4001806c: f0 06 60 18 ld [ %i1 + 0x18 ], %i0 <== NOT EXECUTED
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
40018070: 27 00 00 3f sethi %hi(0xfc00), %l3
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
40018074: a2 10 20 00 clr %l1
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
40018078: 10 80 00 44 b 40018188 <msdos_find_node_by_cluster_num_in_fat_file+0x150>
4001807c: a6 14 e3 ff or %l3, 0x3ff, %l3
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
40018080: 10 bf ff fc b 40018070 <msdos_find_node_by_cluster_num_in_fat_file+0x38>
40018084: f0 17 60 06 lduh [ %i5 + 6 ], %i0
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
40018088: 14 80 00 08 bg 400180a8 <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
4001808c: 80 a2 00 18 cmp %o0, %i0
rtems_set_errno_and_return_minus_one( EIO );
40018090: 40 00 0a 0f call 4001a8cc <__errno> <== NOT EXECUTED
40018094: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40018098: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001809c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400180a0: 81 c7 e0 08 ret <== NOT EXECUTED
400180a4: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
400180a8: 22 80 00 0a be,a 400180d0 <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
400180ac: e0 07 60 a0 ld [ %i5 + 0xa0 ], %l0
400180b0: 11 10 00 ad sethi %hi(0x4002b400), %o0 <== NOT EXECUTED
400180b4: 15 10 00 ad sethi %hi(0x4002b400), %o2 <== NOT EXECUTED
400180b8: 17 10 00 ad sethi %hi(0x4002b400), %o3 <== NOT EXECUTED
400180bc: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
400180c0: 92 10 26 4e mov 0x64e, %o1 <== NOT EXECUTED
400180c4: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED
400180c8: 7f ff b2 28 call 40004968 <__assert_func> <== NOT EXECUTED
400180cc: 96 12 e3 70 or %o3, 0x370, %o3 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
400180d0: a4 10 20 00 clr %l2
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
400180d4: c2 0c 00 00 ldub [ %l0 ], %g1
400180d8: 80 a0 60 00 cmp %g1, 0
400180dc: 02 80 00 34 be 400181ac <msdos_find_node_by_cluster_num_in_fat_file+0x174><== NEVER TAKEN
400180e0: 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)) ==
400180e4: 22 80 00 25 be,a 40018178 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
400180e8: a4 04 a0 20 add %l2, 0x20, %l2 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
400180ec: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
400180f0: c2 14 20 1a lduh [ %l0 + 0x1a ], %g1
400180f4: 85 28 a0 10 sll %g2, 0x10, %g2
400180f8: 87 30 a0 18 srl %g2, 0x18, %g3
400180fc: 83 28 60 10 sll %g1, 0x10, %g1
40018100: 85 30 a0 08 srl %g2, 8, %g2
40018104: 84 08 80 13 and %g2, %l3, %g2
40018108: 84 10 c0 02 or %g3, %g2, %g2
4001810c: 87 30 60 18 srl %g1, 0x18, %g3
40018110: 85 28 a0 10 sll %g2, 0x10, %g2
40018114: 83 30 60 08 srl %g1, 8, %g1
40018118: 82 08 40 13 and %g1, %l3, %g1
4001811c: 82 10 c0 01 or %g3, %g1, %g1
40018120: 82 10 80 01 or %g2, %g1, %g1
40018124: 80 a0 40 1a cmp %g1, %i2
40018128: 32 80 00 14 bne,a 40018178 <msdos_find_node_by_cluster_num_in_fat_file+0x140>
4001812c: a4 04 a0 20 add %l2, 0x20, %l2
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
40018130: 90 10 00 1d mov %i5, %o0
40018134: 92 10 00 19 mov %i1, %o1
40018138: 94 10 20 01 mov 1, %o2
4001813c: 96 10 00 11 mov %l1, %o3
40018140: 7f ff e6 8a call 40011b68 <fat_file_ioctl>
40018144: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
40018148: b0 92 20 00 orcc %o0, 0, %i0
4001814c: 12 bf ff d5 bne 400180a0 <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
40018150: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
40018154: e4 26 e0 04 st %l2, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40018158: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001815c: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
40018160: 90 10 00 1c mov %i4, %o0
40018164: 92 10 00 10 mov %l0, %o1
40018168: 40 00 0c 7e call 4001b360 <memcpy>
4001816c: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
40018170: 81 c7 e0 08 ret
40018174: 81 e8 00 00 restore
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40018178: 80 a4 80 18 cmp %l2, %i0
4001817c: 0a bf ff d6 bcs 400180d4 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
40018180: a0 04 20 20 add %l0, 0x20, %l0
40018184: a2 04 40 18 add %l1, %i0, %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
40018188: d8 07 60 a0 ld [ %i5 + 0xa0 ], %o4
4001818c: 90 10 00 1d mov %i5, %o0
40018190: 92 10 00 19 mov %i1, %o1
40018194: 94 10 00 11 mov %l1, %o2
40018198: 7f ff e5 94 call 400117e8 <fat_file_read>
4001819c: 96 10 00 18 mov %i0, %o3
400181a0: 80 a2 20 00 cmp %o0, 0
400181a4: 12 bf ff b9 bne 40018088 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
400181a8: 80 a2 20 1f cmp %o0, 0x1f
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
400181ac: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
400181b0: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
400181b4: 81 c7 e0 08 ret <== NOT EXECUTED
400181b8: 81 e8 00 00 restore <== NOT EXECUTED
4000cd38 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000cd38: 9d e3 bc d0 save %sp, -816, %sp
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4000cd3c: 92 10 20 02 mov 2, %o1
4000cd40: 90 10 00 19 mov %i1, %o0
4000cd44: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000cd48: 7f ff ff 60 call 4000cac8 <msdos_format_printf>
4000cd4c: 94 12 a0 98 or %o2, 0x98, %o2 ! 4002b098 <_CPU_Trap_slot_template+0x68>
fd = open(devname, O_RDWR);
4000cd50: 92 10 20 02 mov 2, %o1
4000cd54: 7f ff e2 bc call 40005844 <open>
4000cd58: 90 10 00 18 mov %i0, %o0
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
struct stat stat_buf;
int ret_val = 0;
4000cd5c: 82 38 00 08 xnor %g0, %o0, %g1
4000cd60: 80 a0 00 01 cmp %g0, %g1
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
4000cd64: b8 10 00 08 mov %o0, %i4
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
struct stat stat_buf;
int ret_val = 0;
4000cd68: b6 40 3f ff addx %g0, -1, %i3
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000cd6c: 90 10 00 19 mov %i1, %o0
4000cd70: 92 10 20 02 mov 2, %o1
4000cd74: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000cd78: 96 10 00 18 mov %i0, %o3
4000cd7c: 7f ff ff 53 call 4000cac8 <msdos_format_printf>
4000cd80: 94 12 a0 a8 or %o2, 0xa8, %o2
"stat check: %s\n", devname);
if (ret_val == 0) {
4000cd84: 80 a6 e0 00 cmp %i3, 0
4000cd88: 12 80 00 06 bne 4000cda0 <msdos_format+0x68> <== NEVER TAKEN
4000cd8c: ba 10 3f ff mov -1, %i5
ret_val = fstat(fd, &stat_buf);
4000cd90: 90 10 00 1c mov %i4, %o0
4000cd94: 7f ff df 85 call 40004ba8 <fstat>
4000cd98: 92 07 bd 60 add %fp, -672, %o1
4000cd9c: ba 10 00 08 mov %o0, %i5
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000cda0: 90 10 00 19 mov %i1, %o0
4000cda4: 92 10 20 01 mov 1, %o1
4000cda8: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000cdac: 96 10 00 18 mov %i0, %o3
4000cdb0: 7f ff ff 46 call 4000cac8 <msdos_format_printf>
4000cdb4: 94 12 a0 b8 or %o2, 0xb8, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4000cdb8: 80 a7 60 00 cmp %i5, 0
4000cdbc: 12 80 02 0d bne 4000d5f0 <msdos_format+0x8b8> <== NEVER TAKEN
4000cdc0: 80 a0 00 19 cmp %g0, %i1
4000cdc4: c4 07 bd 6c ld [ %fp + -660 ], %g2
4000cdc8: 03 00 00 3c sethi %hi(0xf000), %g1
4000cdcc: 84 08 80 01 and %g2, %g1, %g2
4000cdd0: 03 00 00 18 sethi %hi(0x6000), %g1
4000cdd4: 80 a0 80 01 cmp %g2, %g1
4000cdd8: 02 80 03 7d be 4000dbcc <msdos_format+0xe94> <== ALWAYS TAKEN
4000cddc: 92 10 20 00 clr %o1
errno = ENOTTY;
4000cde0: 40 00 36 bb call 4001a8cc <__errno> <== NOT EXECUTED
4000cde4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4000cde8: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
4000cdec: 10 80 02 00 b 4000d5ec <msdos_format+0x8b4> <== NOT EXECUTED
4000cdf0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
4000cdf4: 92 16 e2 05 or %i3, 0x205, %o1
4000cdf8: 40 00 1c 04 call 40013e08 <ioctl>
4000cdfc: 94 07 bd b0 add %fp, -592, %o2
ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
4000ce00: ba 92 20 00 orcc %o0, 0, %i5
4000ce04: 12 80 01 67 bne 4000d3a0 <msdos_format+0x668> <== NEVER TAKEN
4000ce08: f0 07 bd ac ld [ %fp + -596 ], %i0
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000ce0c: fa 07 bd b0 ld [ %fp + -592 ], %i5
4000ce10: 92 10 00 18 mov %i0, %o1
4000ce14: 7f ff d6 0f call 40002650 <.umul>
4000ce18: 90 10 00 1d mov %i5, %o0
4000ce1c: b4 10 20 00 clr %i2
4000ce20: b6 10 00 08 mov %o0, %i3
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000ce24: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
4000ce28: f4 3f bd 58 std %i2, [ %fp + -680 ]
4000ce2c: 9a 10 20 00 clr %o5
4000ce30: 90 10 00 19 mov %i1, %o0
4000ce34: 92 10 20 02 mov 2, %o1
4000ce38: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000ce3c: 96 10 00 18 mov %i0, %o3
4000ce40: 94 12 a0 c8 or %o2, 0xc8, %o2
4000ce44: 7f ff ff 21 call 4000cac8 <msdos_format_printf>
4000ce48: 98 10 00 1d mov %i5, %o4
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000ce4c: 80 a6 60 00 cmp %i1, 0
4000ce50: 02 80 00 0a be 4000ce78 <msdos_format+0x140>
4000ce54: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
4000ce58: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000ce5c: 80 a0 60 00 cmp %g1, 0
4000ce60: 12 80 00 04 bne 4000ce70 <msdos_format+0x138>
4000ce64: 80 a0 60 06 cmp %g1, 6
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
4000ce68: 10 80 00 04 b 4000ce78 <msdos_format+0x140>
4000ce6c: 82 10 20 02 mov 2, %g1
}
else if (rqdata->fat_num <= 6) {
4000ce70: 18 80 00 04 bgu 4000ce80 <msdos_format+0x148>
4000ce74: 01 00 00 00 nop
fmt_params->fat_num = rqdata->fat_num;
4000ce78: 10 80 03 62 b 4000dc00 <msdos_format+0xec8>
4000ce7c: c2 2f bd dc stb %g1, [ %fp + -548 ]
}
else {
errno = EINVAL;
4000ce80: 40 00 36 93 call 4001a8cc <__errno>
4000ce84: ba 10 3f ff mov -1, %i5
4000ce88: 82 10 20 16 mov 0x16, %g1
4000ce8c: 10 80 01 45 b 4000d3a0 <msdos_format+0x668>
4000ce90: c2 22 00 00 st %g1, [ %o0 ]
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
4000ce94: 84 90 60 00 orcc %g1, 0, %g2
4000ce98: 12 80 00 05 bne 4000ceac <msdos_format+0x174>
4000ce9c: c6 07 bd b0 ld [ %fp + -592 ], %g3
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
4000cea0: 84 10 20 20 mov 0x20, %g2
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
4000cea4: 82 10 20 08 mov 8, %g1
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
4000cea8: c6 07 bd b0 ld [ %fp + -592 ], %g3
4000ceac: 89 28 60 02 sll %g1, 2, %g4
4000ceb0: bb 28 60 0a sll %g1, 0xa, %i5
4000ceb4: 88 27 40 04 sub %i5, %g4, %g4
4000ceb8: 88 01 00 01 add %g4, %g1, %g4
4000cebc: 89 29 20 02 sll %g4, 2, %g4
4000cec0: 82 01 00 01 add %g4, %g1, %g1
4000cec4: 80 a0 c0 01 cmp %g3, %g1
4000cec8: 3a 80 00 04 bcc,a 4000ced8 <msdos_format+0x1a0>
4000cecc: 83 28 a0 02 sll %g2, 2, %g1
fmt_params->fattype = FAT_FAT12;
4000ced0: 10 80 00 0b b 4000cefc <msdos_format+0x1c4>
4000ced4: 82 10 20 01 mov 1, %g1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
4000ced8: 89 28 a0 0e sll %g2, 0xe, %g4
4000cedc: 82 21 00 01 sub %g4, %g1, %g1
4000cee0: 82 00 40 02 add %g1, %g2, %g1
4000cee4: 83 28 60 02 sll %g1, 2, %g1
4000cee8: 84 00 40 02 add %g1, %g2, %g2
4000ceec: 80 a0 c0 02 cmp %g3, %g2
4000cef0: 1a 80 00 06 bcc 4000cf08 <msdos_format+0x1d0>
4000cef4: 1b 10 00 00 sethi %hi(0x40000000), %o5
fmt_params->fattype = FAT_FAT16;
4000cef8: 82 10 20 02 mov 2, %g1
4000cefc: c2 2f bd de stb %g1, [ %fp + -546 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000cf00: 10 80 00 15 b 4000cf54 <msdos_format+0x21c>
4000cf04: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4000cf08: 86 86 c0 0d addcc %i3, %o5, %g3
4000cf0c: 83 30 e0 1e srl %g3, 0x1e, %g1
4000cf10: 98 10 20 00 clr %o4
4000cf14: 84 46 80 0c addx %i2, %o4, %g2
4000cf18: 85 28 a0 02 sll %g2, 2, %g2
4000cf1c: 84 10 80 01 or %g2, %g1, %g2
int b;
fmt_params->fattype = FAT_FAT32;
4000cf20: 82 10 20 04 mov 4, %g1
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4000cf24: 86 10 20 01 mov 1, %g3
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
4000cf28: c2 2f bd de stb %g1, [ %fp + -546 ]
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4000cf2c: 82 10 20 1f mov 0x1f, %g1
if ((gigs & (1 << b)) != 0)
4000cf30: 89 28 c0 01 sll %g3, %g1, %g4
4000cf34: 80 89 00 02 btst %g4, %g2
4000cf38: 32 80 00 06 bne,a 4000cf50 <msdos_format+0x218>
4000cf3c: 84 10 20 01 mov 1, %g2
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4000cf40: 82 80 7f ff addcc %g1, -1, %g1
4000cf44: 12 bf ff fc bne 4000cf34 <msdos_format+0x1fc>
4000cf48: 89 28 c0 01 sll %g3, %g1, %g4
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
4000cf4c: 84 10 20 01 mov 1, %g2
4000cf50: 83 28 80 01 sll %g2, %g1, %g1
4000cf54: c2 27 bd b8 st %g1, [ %fp + -584 ]
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
4000cf58: 90 10 00 19 mov %i1, %o0
4000cf5c: 7f ff ff 53 call 4000cca8 <msdos_set_sectors_per_cluster_from_request>
4000cf60: 92 07 bd ac add %fp, -596, %o1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
4000cf64: 98 10 20 00 clr %o4
4000cf68: 1b 10 00 00 sethi %hi(0x40000000), %o5
4000cf6c: 86 86 c0 0d addcc %i3, %o5, %g3
4000cf70: 84 46 80 0c addx %i2, %o4, %g2
4000cf74: 83 30 e0 1e srl %g3, 0x1e, %g1
4000cf78: 85 28 a0 02 sll %g2, 2, %g2
4000cf7c: 82 10 80 01 or %g2, %g1, %g1
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
4000cf80: 80 a0 00 19 cmp %g0, %i1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
4000cf84: c2 27 bd 40 st %g1, [ %fp + -704 ]
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
4000cf88: ba 10 00 08 mov %o0, %i5
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
4000cf8c: 82 40 20 00 addx %g0, 0, %g1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
4000cf90: b4 10 3f ff mov -1, %i2
4000cf94: a8 10 20 00 clr %l4
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
4000cf98: 10 80 00 f8 b 4000d378 <msdos_format+0x640>
4000cf9c: c2 27 bd 48 st %g1, [ %fp + -696 ]
4000cfa0: 80 a1 20 00 cmp %g4, 0
4000cfa4: 02 80 00 05 be 4000cfb8 <msdos_format+0x280>
4000cfa8: d6 07 bd b8 ld [ %fp + -584 ], %o3
fmt_params->skip_alignment = rqdata->skip_alignment;
4000cfac: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
4000cfb0: c2 2f bd fc stb %g1, [ %fp + -516 ]
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000cfb4: d6 07 bd b8 ld [ %fp + -584 ], %o3
4000cfb8: 90 10 00 19 mov %i1, %o0
4000cfbc: 92 10 20 02 mov 2, %o1
4000cfc0: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000cfc4: 7f ff fe c1 call 4000cac8 <msdos_format_printf>
4000cfc8: 94 12 a1 08 or %o2, 0x108, %o2 ! 4002b108 <_CPU_Trap_slot_template+0xd8>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
4000cfcc: f4 0f bd de ldub [ %fp + -546 ], %i2
4000cfd0: 82 0e a0 ff and %i2, 0xff, %g1
4000cfd4: 80 a0 60 04 cmp %g1, 4
4000cfd8: 12 80 00 0a bne 4000d000 <msdos_format+0x2c8>
4000cfdc: 82 10 20 01 mov 1, %g1
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4000cfe0: 82 10 20 20 mov 0x20, %g1
4000cfe4: c2 27 bd b4 st %g1, [ %fp + -588 ]
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4000cfe8: 82 10 20 06 mov 6, %g1
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
4000cfec: c0 27 bd c4 clr [ %fp + -572 ]
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4000cff0: c2 27 bd d4 st %g1, [ %fp + -556 ]
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4000cff4: 82 10 20 01 mov 1, %g1
4000cff8: 10 80 00 1c b 4000d068 <msdos_format+0x330>
4000cffc: c2 27 bd d8 st %g1, [ %fp + -552 ]
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
4000d000: c2 27 bd b4 st %g1, [ %fp + -588 ]
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4000d004: c2 07 bd 48 ld [ %fp + -696 ], %g1
4000d008: 80 a0 60 00 cmp %g1, 0
4000d00c: 02 80 00 08 be 4000d02c <msdos_format+0x2f4>
4000d010: 82 0e a0 ff and %i2, 0xff, %g1
(rqdata->files_per_root_dir > 0)) {
4000d014: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4000d018: 80 a0 60 00 cmp %g1, 0
4000d01c: 22 80 00 04 be,a 4000d02c <msdos_format+0x2f4>
4000d020: 82 0e a0 ff and %i2, 0xff, %g1
else {
if (fmt_params->fattype == FAT_FAT16) {
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
4000d024: 10 80 00 07 b 4000d040 <msdos_format+0x308>
4000d028: c2 27 bd c4 st %g1, [ %fp + -572 ]
if ((rqdata != NULL) &&
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
4000d02c: 80 a0 60 02 cmp %g1, 2
4000d030: 32 80 00 03 bne,a 4000d03c <msdos_format+0x304>
4000d034: 82 10 20 40 mov 0x40, %g1
4000d038: 82 10 22 00 mov 0x200, %g1
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
4000d03c: c2 27 bd c4 st %g1, [ %fp + -572 ]
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
4000d040: d2 07 bd ac ld [ %fp + -596 ], %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4000d044: f6 07 bd c4 ld [ %fp + -572 ], %i3
(2*fmt_params->bytes_per_sector/
4000d048: 93 2a 60 01 sll %o1, 1, %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4000d04c: b6 06 ff ff add %i3, -1, %i3
(2*fmt_params->bytes_per_sector/
4000d050: 93 32 60 05 srl %o1, 5, %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4000d054: b6 06 c0 09 add %i3, %o1, %i3
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4000d058: 40 00 6a 99 call 40027abc <.urem>
4000d05c: 90 10 00 1b mov %i3, %o0
4000d060: 90 26 c0 08 sub %i3, %o0, %o0
4000d064: d0 27 bd c4 st %o0, [ %fp + -572 ]
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
4000d068: f6 07 bd ac ld [ %fp + -596 ], %i3
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
4000d06c: d0 07 bd c4 ld [ %fp + -572 ], %o0
+ fmt_params->bytes_per_sector - 1)
4000d070: 88 06 ff ff add %i3, -1, %g4
/ fmt_params->bytes_per_sector);
4000d074: 92 10 00 1b mov %i3, %o1
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
4000d078: c8 27 bd 54 st %g4, [ %fp + -684 ]
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
4000d07c: 91 2a 20 05 sll %o0, 5, %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
4000d080: 7f ff d5 ae call 40002738 <.udiv>
4000d084: 90 01 00 08 add %g4, %o0, %o0
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
4000d088: c2 07 bd b0 ld [ %fp + -592 ], %g1
4000d08c: c8 07 bd b4 ld [ %fp + -588 ], %g4
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
4000d090: a4 10 00 08 mov %o0, %l2
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
4000d094: d0 27 bd c8 st %o0, [ %fp + -568 ]
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
4000d098: b0 0e a0 ff and %i2, 0xff, %i0
4000d09c: c2 27 bd 44 st %g1, [ %fp + -700 ]
4000d0a0: c8 27 bd 50 st %g4, [ %fp + -688 ]
4000d0a4: ea 0f bd dc ldub [ %fp + -548 ], %l5
4000d0a8: ec 07 bd b8 ld [ %fp + -584 ], %l6
4000d0ac: e6 0f bd fc ldub [ %fp + -516 ], %l3
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000d0b0: 92 10 00 1b mov %i3, %o1
4000d0b4: 7f ff d5 a1 call 40002738 <.udiv>
4000d0b8: 11 00 00 20 sethi %hi(0x8000), %o0
4000d0bc: 10 80 00 03 b 4000d0c8 <msdos_format+0x390>
4000d0c0: 80 a2 00 16 cmp %o0, %l6
4000d0c4: 80 a2 00 16 cmp %o0, %l6 <== NOT EXECUTED
4000d0c8: 2a bf ff ff bcs,a 4000d0c4 <msdos_format+0x38c> <== NEVER TAKEN
4000d0cc: ad 35 a0 01 srl %l6, 1, %l6 <== NOT EXECUTED
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d0d0: c2 07 bd 50 ld [ %fp + -688 ], %g1
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
4000d0d4: aa 0d 60 ff and %l5, 0xff, %l5
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d0d8: 82 00 7f ff add %g1, -1, %g1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d0dc: a6 0c e0 ff and %l3, 0xff, %l3
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d0e0: c2 27 bd 3c st %g1, [ %fp + -708 ]
4000d0e4: ae 04 bf ff add %l2, -1, %l7
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
4000d0e8: ea 27 bd 4c st %l5, [ %fp + -692 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d0ec: 80 a4 e0 00 cmp %l3, 0
4000d0f0: 12 80 00 06 bne 4000d108 <msdos_format+0x3d0>
4000d0f4: d0 07 bd 50 ld [ %fp + -688 ], %o0
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d0f8: c8 07 bd 3c ld [ %fp + -708 ], %g4
4000d0fc: 90 20 00 16 neg %l6, %o0
4000d100: 84 01 00 16 add %g4, %l6, %g2
4000d104: 90 0a 00 02 and %o0, %g2, %o0
* compute number of data clusters for current data:
* - compute cluster count for data AND fat
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
4000d108: c2 07 bd 44 ld [ %fp + -700 ], %g1
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
4000d10c: 80 a6 20 01 cmp %i0, 1
4000d110: 12 80 00 10 bne 4000d150 <msdos_format+0x418>
4000d114: 90 20 40 08 sub %g1, %o0, %o0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d118: 80 a4 e0 00 cmp %l3, 0
4000d11c: 12 80 00 05 bne 4000d130 <msdos_format+0x3f8>
4000d120: 84 10 00 12 mov %l2, %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d124: 84 05 c0 16 add %l7, %l6, %g2
4000d128: 86 20 00 16 neg %l6, %g3
4000d12c: 84 08 c0 02 and %g3, %g2, %g2
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
4000d130: 90 22 00 02 sub %o0, %g2, %o0
4000d134: 7f ff d5 81 call 40002738 <.udiv>
4000d138: 92 10 00 16 mov %l6, %o1
4000d13c: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 3 / 2;
4000d140: 91 2a 20 01 sll %o0, 1, %o0
4000d144: 90 02 00 10 add %o0, %l0, %o0
4000d148: 10 80 00 14 b 4000d198 <msdos_format+0x460>
4000d14c: 91 32 20 01 srl %o0, 1, %o0
}
else if (fattype == FAT_FAT16) {
4000d150: 80 a6 20 02 cmp %i0, 2
4000d154: 12 80 00 0d bne 4000d188 <msdos_format+0x450>
4000d158: 80 a4 e0 00 cmp %l3, 0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d15c: 12 80 00 05 bne 4000d170 <msdos_format+0x438>
4000d160: 84 10 00 12 mov %l2, %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d164: 84 05 c0 16 add %l7, %l6, %g2
4000d168: 86 20 00 16 neg %l6, %g3
4000d16c: 84 08 c0 02 and %g3, %g2, %g2
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
4000d170: 90 22 00 02 sub %o0, %g2, %o0
4000d174: 7f ff d5 71 call 40002738 <.udiv>
4000d178: 92 10 00 16 mov %l6, %o1
4000d17c: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 2;
4000d180: 10 80 00 06 b 4000d198 <msdos_format+0x460>
4000d184: 91 2a 20 01 sll %o0, 1, %o0
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
4000d188: 7f ff d5 6c call 40002738 <.udiv>
4000d18c: 92 10 00 16 mov %l6, %o1
4000d190: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 4;
4000d194: 91 2a 20 02 sll %o0, 2, %o0
}
sectors_per_fat = ((fat_capacity
4000d198: c8 07 bd 54 ld [ %fp + -684 ], %g4
4000d19c: 92 10 00 1b mov %i3, %o1
4000d1a0: 7f ff d5 66 call 40002738 <.udiv>
4000d1a4: 90 02 00 04 add %o0, %g4, %o0
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
4000d1a8: 7f ff d5 2a call 40002650 <.umul>
4000d1ac: d2 07 bd 4c ld [ %fp + -692 ], %o1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d1b0: 80 a4 e0 00 cmp %l3, 0
4000d1b4: 12 80 00 06 bne 4000d1cc <msdos_format+0x494>
4000d1b8: a2 10 00 08 mov %o0, %l1
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d1bc: 84 05 bf ff add %l6, -1, %g2
4000d1c0: a2 00 80 08 add %g2, %o0, %l1
4000d1c4: 84 20 00 16 neg %l6, %g2
4000d1c8: a2 0c 40 02 and %l1, %g2, %l1
sectors_per_cluster,
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
((fat_sectors_cnt
+ (sectors_per_cluster - 1))
4000d1cc: 90 05 bf ff add %l6, -1, %o0
/ sectors_per_cluster));
4000d1d0: 92 10 00 16 mov %l6, %o1
4000d1d4: 7f ff d5 59 call 40002738 <.udiv>
4000d1d8: 90 02 00 11 add %o0, %l1, %o0
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4000d1dc: 80 a6 20 01 cmp %i0, 1
4000d1e0: 12 80 00 07 bne 4000d1fc <msdos_format+0x4c4>
4000d1e4: a0 24 00 08 sub %l0, %o0, %l0
4000d1e8: 80 a4 2f f5 cmp %l0, 0xff5
4000d1ec: 08 80 00 10 bleu 4000d22c <msdos_format+0x4f4>
4000d1f0: aa 10 20 01 mov 1, %l5
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
4000d1f4: 10 80 00 0b b 4000d220 <msdos_format+0x4e8>
4000d1f8: ad 2d a0 01 sll %l6, 1, %l6
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4000d1fc: 80 a6 20 02 cmp %i0, 2
4000d200: 12 80 00 11 bne 4000d244 <msdos_format+0x50c>
4000d204: aa 10 20 01 mov 1, %l5
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
4000d208: 03 00 00 3f sethi %hi(0xfc00), %g1
4000d20c: 82 10 63 f5 or %g1, 0x3f5, %g1 ! fff5 <PROM_START+0xfff5>
4000d210: 80 a4 00 01 cmp %l0, %g1
4000d214: 08 80 00 0d bleu 4000d248 <msdos_format+0x510>
4000d218: 90 10 00 16 mov %l6, %o0
sectors_per_cluster *= 2;
4000d21c: ad 2d a0 01 sll %l6, 1, %l6
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
4000d220: 80 a6 20 01 cmp %i0, 1
4000d224: 12 80 00 08 bne 4000d244 <msdos_format+0x50c>
4000d228: aa 10 20 00 clr %l5
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
4000d22c: 90 10 00 16 mov %l6, %o0
4000d230: 7f ff d5 08 call 40002650 <.umul>
4000d234: 92 10 00 1b mov %i3, %o1
4000d238: 09 00 00 04 sethi %hi(0x1000), %g4
4000d23c: 10 80 00 07 b 4000d258 <msdos_format+0x520>
4000d240: 80 a2 00 04 cmp %o0, %g4
finished = true;
}
} else if ((sectors_per_cluster * bytes_per_sector)
4000d244: 90 10 00 16 mov %l6, %o0
4000d248: 7f ff d5 02 call 40002650 <.umul>
4000d24c: 92 10 00 1b mov %i3, %o1
4000d250: 03 00 00 20 sethi %hi(0x8000), %g1
4000d254: 80 a2 00 01 cmp %o0, %g1
4000d258: 38 80 00 06 bgu,a 4000d270 <msdos_format+0x538>
4000d25c: d2 07 bd 4c ld [ %fp + -692 ], %o1
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
4000d260: 80 8d 60 ff btst 0xff, %l5
4000d264: 02 bf ff a3 be 4000d0f0 <msdos_format+0x3b8>
4000d268: 80 a4 e0 00 cmp %l3, 0
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000d26c: d2 07 bd 4c ld [ %fp + -692 ], %o1
4000d270: 7f ff d5 32 call 40002738 <.udiv>
4000d274: 90 10 00 11 mov %l1, %o0
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
4000d278: 09 10 00 ac sethi %hi(0x4002b000), %g4
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000d27c: d0 27 bd bc st %o0, [ %fp + -580 ]
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
4000d280: d0 01 21 c8 ld [ %g4 + 0x1c8 ], %o0
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment,
§ors_per_cluster_adj,
&fmt_params->sectors_per_fat,
&data_clusters_cnt);
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
4000d284: ec 27 bd b8 st %l6, [ %fp + -584 ]
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
4000d288: 7f ff d5 2c call 40002738 <.udiv>
4000d28c: 92 10 00 1b mov %i3, %o1
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
if ( number_of_clusters < FAT_FAT12_MAX_CLN
4000d290: 80 a2 00 16 cmp %o0, %l6
4000d294: 2a 80 00 06 bcs,a 4000d2ac <msdos_format+0x574>
4000d298: 11 00 00 20 sethi %hi(0x8000), %o0
4000d29c: 80 a4 2f f4 cmp %l0, 0xff4
4000d2a0: 08 80 00 0f bleu 4000d2dc <msdos_format+0x5a4>
4000d2a4: 84 10 20 01 mov 1, %g2
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
4000d2a8: 11 00 00 20 sethi %hi(0x8000), %o0
4000d2ac: 92 10 00 1b mov %i3, %o1
4000d2b0: 7f ff d5 22 call 40002738 <.udiv>
4000d2b4: 90 12 20 01 or %o0, 1, %o0
if ( number_of_clusters < FAT_FAT12_MAX_CLN
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
fattype = FAT_FAT12;
}
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
4000d2b8: 80 a2 00 16 cmp %o0, %l6
4000d2bc: 2a 80 00 08 bcs,a 4000d2dc <msdos_format+0x5a4>
4000d2c0: 84 10 20 04 mov 4, %g2
4000d2c4: 03 00 00 3f sethi %hi(0xfc00), %g1
4000d2c8: 82 10 63 f4 or %g1, 0x3f4, %g1 ! fff4 <PROM_START+0xfff4>
4000d2cc: 80 a0 40 10 cmp %g1, %l0
4000d2d0: 1a 80 00 03 bcc 4000d2dc <msdos_format+0x5a4>
4000d2d4: 84 10 20 02 mov 2, %g2
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
4000d2d8: 84 10 20 04 mov 4, %g2
fmt_params->fattype = msdos_get_fat_type(
fmt_params->bytes_per_sector,
fmt_params->sectors_per_cluster,
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
4000d2dc: 86 0e a0 ff and %i2, 0xff, %g3
4000d2e0: 82 08 a0 ff and %g2, 0xff, %g1
4000d2e4: 80 a0 c0 01 cmp %g3, %g1
4000d2e8: 02 80 00 19 be 4000d34c <msdos_format+0x614>
4000d2ec: c4 2f bd de stb %g2, [ %fp + -546 ]
msdos_set_default_sectors_per_cluster_for_fattype(
msdos_format_param_t *fmt_params,
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
|| fmt_params->fattype == FAT_FAT16 ) {
4000d2f0: 84 00 bf ff add %g2, -1, %g2
static void
msdos_set_default_sectors_per_cluster_for_fattype(
msdos_format_param_t *fmt_params,
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
4000d2f4: 82 10 20 1f mov 0x1f, %g1
4000d2f8: 84 08 a0 ff and %g2, 0xff, %g2
4000d2fc: 80 a0 a0 01 cmp %g2, 1
4000d300: 18 80 00 04 bgu 4000d310 <msdos_format+0x5d8>
4000d304: 86 10 20 01 mov 1, %g3
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000d308: 10 80 00 0c b 4000d338 <msdos_format+0x600>
4000d30c: 82 10 20 02 mov 2, %g1
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
int b;
/* scale with the size of disk... */
for ( b = 31; b > 0; b-- ) {
if ( (gigs & ( 1 << b) ) != 0 )
4000d310: c8 07 bd 40 ld [ %fp + -704 ], %g4
4000d314: 85 28 c0 01 sll %g3, %g1, %g2
4000d318: 80 88 80 04 btst %g2, %g4
4000d31c: 12 80 00 06 bne 4000d334 <msdos_format+0x5fc>
4000d320: 84 10 20 01 mov 1, %g2
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
int b;
/* scale with the size of disk... */
for ( b = 31; b > 0; b-- ) {
4000d324: 82 80 7f ff addcc %g1, -1, %g1
4000d328: 12 bf ff fc bne 4000d318 <msdos_format+0x5e0> <== ALWAYS TAKEN
4000d32c: 85 28 c0 01 sll %g3, %g1, %g2
if ( (gigs & ( 1 << b) ) != 0 )
break;
}
fmt_params->sectors_per_cluster = 1 << b;
4000d330: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4000d334: 83 28 80 01 sll %g2, %g1, %g1
4000d338: c2 27 bd b8 st %g1, [ %fp + -584 ]
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
msdos_set_default_sectors_per_cluster_for_fattype( fmt_params,
total_size );
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
4000d33c: 90 10 00 19 mov %i1, %o0
4000d340: 7f ff fe 5a call 4000cca8 <msdos_set_sectors_per_cluster_from_request>
4000d344: 92 07 bd ac add %fp, -596, %o1
4000d348: ba 10 00 08 mov %o0, %i5
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
4000d34c: c2 0f bd de ldub [ %fp + -546 ], %g1
4000d350: 84 0e a0 ff and %i2, 0xff, %g2
4000d354: 80 a0 80 01 cmp %g2, %g1
4000d358: 02 80 00 07 be 4000d374 <msdos_format+0x63c>
4000d35c: 82 0d 20 ff and %l4, 0xff, %g1
4000d360: 80 a0 60 01 cmp %g1, 1
4000d364: 08 80 00 04 bleu 4000d374 <msdos_format+0x63c>
4000d368: c2 07 bd b0 ld [ %fp + -592 ], %g1
--fmt_params->totl_sector_cnt;
4000d36c: 82 00 7f ff add %g1, -1, %g1
4000d370: c2 27 bd b0 st %g1, [ %fp + -592 ]
}
}
++iteration_cnt;
4000d374: a8 05 20 01 inc %l4
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
4000d378: 80 a7 60 00 cmp %i5, 0
4000d37c: 12 80 00 09 bne 4000d3a0 <msdos_format+0x668> <== NEVER TAKEN
4000d380: c2 0f bd de ldub [ %fp + -546 ], %g1
&& fmt_params->fattype != fat_type
4000d384: b4 0e a0 ff and %i2, 0xff, %i2
4000d388: 80 a0 40 1a cmp %g1, %i2
4000d38c: 02 80 00 05 be 4000d3a0 <msdos_format+0x668>
4000d390: c2 07 bd b0 ld [ %fp + -592 ], %g1
&& fmt_params->totl_sector_cnt > 0 ) {
4000d394: 80 a0 60 00 cmp %g1, 0
4000d398: 12 bf ff 02 bne 4000cfa0 <msdos_format+0x268> <== ALWAYS TAKEN
4000d39c: c8 07 bd 48 ld [ %fp + -696 ], %g4
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000d3a0: c2 07 bd b0 ld [ %fp + -592 ], %g1
4000d3a4: 80 a0 60 00 cmp %g1, 0
4000d3a8: 02 80 00 2f be 4000d464 <msdos_format+0x72c> <== NEVER TAKEN
4000d3ac: 80 a7 60 00 cmp %i5, 0
{
errno = EINVAL;
ret_val = -1;
}
if (0 == ret_val)
4000d3b0: 12 80 00 34 bne 4000d480 <msdos_format+0x748>
4000d3b4: c2 0f bd de ldub [ %fp + -546 ], %g1
{
if (FAT_FAT32 != fmt_params->fattype)
4000d3b8: 80 a0 60 04 cmp %g1, 4
4000d3bc: 02 80 00 0e be 4000d3f4 <msdos_format+0x6bc>
4000d3c0: d0 07 bd c8 ld [ %fp + -568 ], %o0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d3c4: c4 0f bd fc ldub [ %fp + -516 ], %g2
4000d3c8: 80 a0 a0 00 cmp %g2, 0
4000d3cc: 12 80 00 06 bne 4000d3e4 <msdos_format+0x6ac>
4000d3d0: c2 07 bd b8 ld [ %fp + -584 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d3d4: 90 02 00 01 add %o0, %g1, %o0
4000d3d8: 82 20 00 01 neg %g1
4000d3dc: 90 02 3f ff add %o0, -1, %o0
4000d3e0: 90 0a 00 01 and %o0, %g1, %o0
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
4000d3e4: d2 07 bd ac ld [ %fp + -596 ], %o1
4000d3e8: 7f ff d4 9a call 40002650 <.umul>
4000d3ec: 93 32 60 05 srl %o1, 5, %o1
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
4000d3f0: d0 27 bd c4 st %o0, [ %fp + -572 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d3f4: c6 0f bd fc ldub [ %fp + -516 ], %g3
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
}
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
4000d3f8: c2 07 bd b4 ld [ %fp + -588 ], %g1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000d3fc: 80 a0 e0 00 cmp %g3, 0
4000d400: 12 80 00 06 bne 4000d418 <msdos_format+0x6e0>
4000d404: c4 07 bd b8 ld [ %fp + -584 ], %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000d408: 82 00 40 02 add %g1, %g2, %g1
4000d40c: 84 20 00 02 neg %g2
4000d410: 82 00 7f ff add %g1, -1, %g1
4000d414: 82 08 40 02 and %g1, %g2, %g1
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000d418: 80 a6 60 00 cmp %i1, 0
4000d41c: 02 80 00 17 be 4000d478 <msdos_format+0x740>
4000d420: c2 27 bd b4 st %g1, [ %fp + -588 ]
(rqdata->media != 0)) {
4000d424: f6 0e 60 14 ldub [ %i1 + 0x14 ], %i3
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000d428: b4 8e e0 ff andcc %i3, 0xff, %i2
4000d42c: 02 80 00 14 be 4000d47c <msdos_format+0x744>
4000d430: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
const char valid_media_codes[] =
4000d434: 94 10 20 09 mov 9, %o2
4000d438: 90 07 be 00 add %fp, -512, %o0
4000d43c: 13 10 00 ac sethi %hi(0x4002b000), %o1
4000d440: 40 00 37 c8 call 4001b360 <memcpy>
4000d444: 92 12 61 b8 or %o1, 0x1b8, %o1 ! 4002b1b8 <_CPU_Trap_slot_template+0x188>
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
4000d448: 90 07 be 00 add %fp, -512, %o0
4000d44c: 92 10 00 1a mov %i2, %o1
4000d450: 40 00 37 56 call 4001b1a8 <memchr>
4000d454: 94 10 20 09 mov 9, %o2
4000d458: 80 a2 20 00 cmp %o0, 0
4000d45c: 32 80 00 09 bne,a 4000d480 <msdos_format+0x748> <== NEVER TAKEN
4000d460: f6 2f bd dd stb %i3, [ %fp + -547 ] <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
4000d464: 40 00 35 1a call 4001a8cc <__errno>
4000d468: ba 10 3f ff mov -1, %i5
4000d46c: 82 10 20 16 mov 0x16, %g1
4000d470: 10 80 00 04 b 4000d480 <msdos_format+0x748>
4000d474: c2 22 00 00 st %g1, [ %o0 ]
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000d478: 82 10 3f f8 mov -8, %g1
4000d47c: c2 2f bd dd stb %g1, [ %fp + -547 ]
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000d480: f4 07 bd c8 ld [ %fp + -568 ], %i2
4000d484: d0 0f bd dc ldub [ %fp + -548 ], %o0
4000d488: 80 a6 a0 00 cmp %i2, 0
4000d48c: f6 07 bd b4 ld [ %fp + -588 ], %i3
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000d490: 90 0a 20 ff and %o0, 0xff, %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000d494: 02 80 00 08 be 4000d4b4 <msdos_format+0x77c>
4000d498: d2 07 bd bc ld [ %fp + -580 ], %o1
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000d49c: 7f ff d4 6d call 40002650 <.umul>
4000d4a0: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
4000d4a4: f4 27 bd d0 st %i2, [ %fp + -560 ]
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000d4a8: 90 02 00 1b add %o0, %i3, %o0
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
4000d4ac: 10 80 00 08 b 4000d4cc <msdos_format+0x794>
4000d4b0: d0 27 bd cc st %o0, [ %fp + -564 ]
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000d4b4: 7f ff d4 67 call 40002650 <.umul>
4000d4b8: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000d4bc: c2 07 bd b8 ld [ %fp + -584 ], %g1
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000d4c0: 90 02 00 1b add %o0, %i3, %o0
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000d4c4: c2 27 bd d0 st %g1, [ %fp + -560 ]
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
4000d4c8: d0 27 bd cc st %o0, [ %fp + -564 ]
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
4000d4cc: 80 a7 60 00 cmp %i5, 0
4000d4d0: 12 80 00 48 bne 4000d5f0 <msdos_format+0x8b8>
4000d4d4: 80 a0 00 19 cmp %g0, %i1
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
4000d4d8: 80 a6 60 00 cmp %i1, 0
4000d4dc: 02 80 00 07 be 4000d4f8 <msdos_format+0x7c0>
4000d4e0: 03 10 00 ac sethi %hi(0x4002b000), %g1
(rqdata->OEMName != NULL)) {
4000d4e4: c2 06 40 00 ld [ %i1 ], %g1
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
4000d4e8: 80 a0 60 00 cmp %g1, 0
4000d4ec: 32 80 00 05 bne,a 4000d500 <msdos_format+0x7c8>
4000d4f0: 05 10 00 b0 sethi %hi(0x4002c000), %g2
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4000d4f4: 03 10 00 ac sethi %hi(0x4002b000), %g1
4000d4f8: 82 10 60 70 or %g1, 0x70, %g1 ! 4002b070 <_CPU_Trap_slot_template+0x40>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000d4fc: 05 10 00 b0 sethi %hi(0x4002c000), %g2
4000d500: 86 10 20 09 mov 9, %g3
4000d504: f4 00 a1 14 ld [ %g2 + 0x114 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000d508: b0 10 20 20 mov 0x20, %i0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
4000d50c: 10 80 00 0f b 4000d548 <msdos_format+0x810>
4000d510: 84 07 bd df add %fp, -545, %g2
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000d514: 88 0e e0 ff and %i3, 0xff, %g4
4000d518: 88 06 80 04 add %i2, %g4, %g4
4000d51c: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
4000d520: 80 89 20 97 btst 0x97, %g4
4000d524: 02 80 00 06 be 4000d53c <msdos_format+0x804>
4000d528: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
4000d52c: f6 28 80 00 stb %i3, [ %g2 ]
4000d530: 82 00 60 01 inc %g1
4000d534: 10 80 00 04 b 4000d544 <msdos_format+0x80c>
4000d538: 84 10 00 04 mov %g4, %g2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000d53c: f0 28 80 00 stb %i0, [ %g2 ]
4000d540: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
4000d544: c0 29 00 00 clrb [ %g4 ]
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
4000d548: 86 80 ff ff addcc %g3, -1, %g3
4000d54c: 32 bf ff f2 bne,a 4000d514 <msdos_format+0x7dc>
4000d550: f6 08 40 00 ldub [ %g1 ], %i3
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
4000d554: 10 80 01 b6 b 4000dc2c <msdos_format+0xef4>
4000d558: 80 a6 60 00 cmp %i1, 0
4000d55c: 80 a0 60 00 cmp %g1, 0
4000d560: 22 80 00 05 be,a 4000d574 <msdos_format+0x83c>
4000d564: 03 10 00 aa sethi %hi(0x4002a800), %g1
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
4000d568: 84 10 20 01 mov 1, %g2
4000d56c: 10 80 00 03 b 4000d578 <msdos_format+0x840>
4000d570: c4 2f bd f4 stb %g2, [ %fp + -524 ]
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4000d574: 82 10 62 f0 or %g1, 0x2f0, %g1
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000d578: 05 10 00 b0 sethi %hi(0x4002c000), %g2
4000d57c: 86 10 20 0c mov 0xc, %g3
4000d580: f4 00 a1 14 ld [ %g2 + 0x114 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000d584: b0 10 20 20 mov 0x20, %i0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
4000d588: 10 80 00 0f b 4000d5c4 <msdos_format+0x88c>
4000d58c: 84 07 bd e8 add %fp, -536, %g2
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000d590: 88 0e e0 ff and %i3, 0xff, %g4
4000d594: 88 06 80 04 add %i2, %g4, %g4
4000d598: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
4000d59c: 80 89 20 97 btst 0x97, %g4
4000d5a0: 02 80 00 06 be 4000d5b8 <msdos_format+0x880>
4000d5a4: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
4000d5a8: f6 28 80 00 stb %i3, [ %g2 ]
4000d5ac: 82 00 60 01 inc %g1
4000d5b0: 10 80 00 04 b 4000d5c0 <msdos_format+0x888>
4000d5b4: 84 10 00 04 mov %g4, %g2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000d5b8: f0 28 80 00 stb %i0, [ %g2 ]
4000d5bc: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
4000d5c0: c0 29 00 00 clrb [ %g4 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
4000d5c4: 86 80 ff ff addcc %g3, -1, %g3
4000d5c8: 32 bf ff f2 bne,a 4000d590 <msdos_format+0x858>
4000d5cc: f6 08 40 00 ldub [ %g1 ], %i3
4000d5d0: 30 80 01 9b b,a 4000dc3c <msdos_format+0xf04>
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
4000d5d4: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
4000d5d8: 10 80 00 05 b 4000d5ec <msdos_format+0x8b4> <== NOT EXECUTED
4000d5dc: c2 27 bd f8 st %g1, [ %fp + -520 ] <== NOT EXECUTED
}
else {
*volid_ptr = rand();
4000d5e0: 40 00 3a 1c call 4001be50 <rand>
4000d5e4: 01 00 00 00 nop
4000d5e8: d0 27 bd f8 st %o0, [ %fp + -520 ]
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
4000d5ec: 80 a0 00 19 cmp %g0, %i1
4000d5f0: b4 40 20 00 addx %g0, 0, %i2
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
4000d5f4: 80 a7 60 00 cmp %i5, 0
4000d5f8: 12 80 01 5f bne 4000db74 <msdos_format+0xe3c>
4000d5fc: b0 10 00 1d mov %i5, %i0
4000d600: 80 8e a0 ff btst 0xff, %i2
4000d604: 02 80 00 1d be 4000d678 <msdos_format+0x940>
4000d608: 80 a7 60 00 cmp %i5, 0
(rqdata != NULL) &&
4000d60c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
4000d610: 80 a0 60 00 cmp %g1, 0
4000d614: 02 80 00 11 be 4000d658 <msdos_format+0x920>
4000d618: 90 10 00 19 mov %i1, %o0
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d61c: 92 10 20 02 mov 2, %o1
4000d620: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000d624: 7f ff fd 29 call 4000cac8 <msdos_format_printf>
4000d628: 94 12 a1 28 or %o2, 0x128, %o2 ! 4002b128 <_CPU_Trap_slot_template+0xf8>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000d62c: 90 10 00 1c mov %i4, %o0
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
4000d630: fa 07 bd ac ld [ %fp + -596 ], %i5
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000d634: 92 10 20 00 clr %o1
4000d638: 94 10 20 00 clr %o2
4000d63c: 40 00 1a 14 call 40013e8c <lseek>
4000d640: 96 10 20 00 clr %o3
4000d644: 80 a2 20 00 cmp %o0, 0
4000d648: 16 80 01 83 bge 4000dc54 <msdos_format+0xf1c> <== ALWAYS TAKEN
4000d64c: 90 10 00 1c mov %i4, %o0
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
4000d650: 10 80 01 89 b 4000dc74 <msdos_format+0xf3c> <== NOT EXECUTED
4000d654: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4000d658: d6 07 bd b0 ld [ %fp + -592 ], %o3
4000d65c: d8 07 bd ac ld [ %fp + -596 ], %o4
4000d660: 92 10 00 1c mov %i4, %o1
4000d664: 94 10 20 00 clr %o2
4000d668: 7f ff fd 45 call 4000cb7c <msdos_format_fill_sectors>
4000d66c: 9a 10 3f e5 mov -27, %o5
4000d670: ba 10 00 08 mov %o0, %i5
}
/*
* create master boot record
*/
if (ret_val == 0) {
4000d674: 80 a7 60 00 cmp %i5, 0
4000d678: 12 80 01 3f bne 4000db74 <msdos_format+0xe3c> <== NEVER TAKEN
4000d67c: b0 10 00 1d mov %i5, %i0
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d680: 10 bf ff e7 b 4000d61c <msdos_format+0x8e4>
4000d684: 90 10 00 19 mov %i1, %o0
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
4000d688: ba 10 20 00 clr %i5
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4000d68c: 92 10 20 00 clr %o1
4000d690: 94 10 21 be mov 0x1be, %o2
4000d694: 40 00 37 70 call 4001b454 <memset>
4000d698: 90 07 be 00 add %fp, -512, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000d69c: 90 07 be 03 add %fp, -509, %o0
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
4000d6a0: c0 37 bf fe clrh [ %fp + -2 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000d6a4: 92 07 bd df add %fp, -545, %o1
4000d6a8: 40 00 37 2e call 4001b360 <memcpy>
4000d6ac: 94 10 20 08 mov 8, %o2
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
4000d6b0: c2 07 bd ac ld [ %fp + -596 ], %g1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000d6b4: 05 00 00 3f sethi %hi(0xfc00), %g2
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
4000d6b8: c2 2f be 0b stb %g1, [ %fp + -501 ]
4000d6bc: 83 30 60 08 srl %g1, 8, %g1
4000d6c0: c2 2f be 0c stb %g1, [ %fp + -500 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000d6c4: c2 07 bd b8 ld [ %fp + -584 ], %g1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000d6c8: 84 10 a3 ff or %g2, 0x3ff, %g2
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000d6cc: c2 2f be 0d stb %g1, [ %fp + -499 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4000d6d0: c2 07 bd b4 ld [ %fp + -588 ], %g1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000d6d4: fa 2f be 20 stb %i5, [ %fp + -480 ]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4000d6d8: c2 2f be 0e stb %g1, [ %fp + -498 ]
4000d6dc: 83 30 60 08 srl %g1, 8, %g1
4000d6e0: c2 2f be 0f stb %g1, [ %fp + -497 ]
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000d6e4: c2 07 bd c4 ld [ %fp + -572 ], %g1
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4000d6e8: 88 10 20 02 mov 2, %g4
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000d6ec: c2 2f be 11 stb %g1, [ %fp + -495 ]
4000d6f0: 83 30 60 08 srl %g1, 8, %g1
4000d6f4: c2 2f be 12 stb %g1, [ %fp + -494 ]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4000d6f8: c2 0f bd dd ldub [ %fp + -547 ], %g1
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4000d6fc: f6 2f be 13 stb %i3, [ %fp + -493 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4000d700: c2 2f be 15 stb %g1, [ %fp + -491 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4000d704: 82 10 3f ff mov -1, %g1
4000d708: c2 2f be 18 stb %g1, [ %fp + -488 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4000d70c: 82 10 20 06 mov 6, %g1
4000d710: c2 2f be 1a stb %g1, [ %fp + -486 ]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000d714: 82 0f 40 02 and %i5, %g2, %g1
4000d718: 83 30 60 08 srl %g1, 8, %g1
4000d71c: c2 2f be 21 stb %g1, [ %fp + -479 ]
4000d720: 83 37 60 10 srl %i5, 0x10, %g1
4000d724: bb 37 60 18 srl %i5, 0x18, %i5
4000d728: fa 2f be 23 stb %i5, [ %fp + -477 ]
if (fmt_params->fattype != FAT_FAT32) {
4000d72c: fa 0f bd de ldub [ %fp + -546 ], %i5
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4000d730: b7 36 e0 08 srl %i3, 8, %i3
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4000d734: 86 10 20 01 mov 1, %g3
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000d738: c2 2f be 22 stb %g1, [ %fp + -478 ]
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4000d73c: c8 2f be 10 stb %g4, [ %fp + -496 ]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4000d740: f6 2f be 14 stb %i3, [ %fp + -492 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4000d744: c6 2f be 1c stb %g3, [ %fp + -484 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4000d748: 80 a7 60 04 cmp %i5, 4
4000d74c: 02 80 00 1c be 4000d7bc <msdos_format+0xa84>
4000d750: c2 07 bd bc ld [ %fp + -580 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4000d754: c2 2f be 16 stb %g1, [ %fp + -490 ]
4000d758: 83 30 60 08 srl %g1, 8, %g1
4000d75c: c2 2f be 17 stb %g1, [ %fp + -489 ]
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
4000d760: 82 10 20 29 mov 0x29, %g1
4000d764: c2 2f be 26 stb %g1, [ %fp + -474 ]
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4000d768: c2 07 bd f8 ld [ %fp + -520 ], %g1
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4000d76c: 92 07 bd e8 add %fp, -536, %o1
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4000d770: 84 08 40 02 and %g1, %g2, %g2
4000d774: 85 30 a0 08 srl %g2, 8, %g2
4000d778: c2 2f be 27 stb %g1, [ %fp + -473 ]
4000d77c: c4 2f be 28 stb %g2, [ %fp + -472 ]
4000d780: 85 30 60 10 srl %g1, 0x10, %g2
4000d784: 83 30 60 18 srl %g1, 0x18, %g1
4000d788: c4 2f be 29 stb %g2, [ %fp + -471 ]
4000d78c: c2 2f be 2a stb %g1, [ %fp + -470 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4000d790: 90 07 be 2b add %fp, -469, %o0
4000d794: 40 00 36 f3 call 4001b360 <memcpy>
4000d798: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4000d79c: 13 10 00 ac sethi %hi(0x4002b000), %o1
4000d7a0: 80 a7 60 01 cmp %i5, 1
4000d7a4: 12 80 00 04 bne 4000d7b4 <msdos_format+0xa7c>
4000d7a8: 92 12 60 88 or %o1, 0x88, %o1
4000d7ac: 13 10 00 ac sethi %hi(0x4002b000), %o1
4000d7b0: 92 12 60 78 or %o1, 0x78, %o1 ! 4002b078 <_CPU_Trap_slot_template+0x48>
4000d7b4: 10 80 00 1d b 4000d828 <msdos_format+0xaf0>
4000d7b8: 90 07 be 36 add %fp, -458, %o0
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000d7bc: 84 08 40 02 and %g1, %g2, %g2
4000d7c0: 85 30 a0 08 srl %g2, 8, %g2
4000d7c4: c2 2f be 24 stb %g1, [ %fp + -476 ]
4000d7c8: c4 2f be 25 stb %g2, [ %fp + -475 ]
4000d7cc: 85 30 60 10 srl %g1, 0x10, %g2
4000d7d0: 83 30 60 18 srl %g1, 0x18, %g1
4000d7d4: c2 2f be 27 stb %g1, [ %fp + -473 ]
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000d7d8: c2 07 bd d4 ld [ %fp + -556 ], %g1
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000d7dc: c4 2f be 26 stb %g2, [ %fp + -474 ]
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000d7e0: c2 2f be 32 stb %g1, [ %fp + -462 ]
4000d7e4: 83 30 60 08 srl %g1, 8, %g1
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
4000d7e8: c8 2f be 2c stb %g4, [ %fp + -468 ]
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4000d7ec: c6 2f be 30 stb %g3, [ %fp + -464 ]
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000d7f0: c2 2f be 33 stb %g1, [ %fp + -461 ]
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4000d7f4: 92 10 20 00 clr %o1
4000d7f8: 94 10 20 0c mov 0xc, %o2
4000d7fc: 40 00 37 16 call 4001b454 <memset>
4000d800: 90 07 be 34 add %fp, -460, %o0
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4000d804: 82 10 20 29 mov 0x29, %g1
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4000d808: 92 10 20 00 clr %o1
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4000d80c: c2 2f be 42 stb %g1, [ %fp + -446 ]
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4000d810: 90 07 be 47 add %fp, -441, %o0
4000d814: 40 00 37 10 call 4001b454 <memset>
4000d818: 94 10 20 0b mov 0xb, %o2
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000d81c: 13 10 00 ac sethi %hi(0x4002b000), %o1
4000d820: 90 07 be 52 add %fp, -430, %o0
4000d824: 92 12 61 40 or %o1, 0x140, %o1
4000d828: 40 00 36 ce call 4001b360 <memcpy>
4000d82c: 94 10 20 08 mov 8, %o2
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4000d830: 82 10 20 55 mov 0x55, %g1
4000d834: c2 2f bf fe stb %g1, [ %fp + -2 ]
4000d838: 82 10 3f aa mov -86, %g1
4000d83c: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4000d840: 82 10 3f eb mov -21, %g1
4000d844: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(mbr,1,0x3c);
4000d848: 82 10 20 3c mov 0x3c, %g1
4000d84c: c2 2f be 01 stb %g1, [ %fp + -511 ]
FAT_SET_VAL8(mbr,2,0x90);
4000d850: 82 10 3f 90 mov -112, %g1
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d854: 90 10 00 19 mov %i1, %o0
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
FAT_SET_VAL8(mbr,2,0x90);
4000d858: c2 2f be 02 stb %g1, [ %fp + -510 ]
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d85c: 92 10 20 02 mov 2, %o1
4000d860: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000d864: 7f ff fc 99 call 4000cac8 <msdos_format_printf>
4000d868: 94 12 a1 50 or %o2, 0x150, %o2 ! 4002b150 <_CPU_Trap_slot_template+0x120>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000d86c: d4 07 bd ac ld [ %fp + -596 ], %o2
4000d870: 90 10 00 1c mov %i4, %o0
4000d874: 92 10 20 00 clr %o1
4000d878: 7f ff fc a9 call 4000cb1c <msdos_format_write_sec>
4000d87c: 96 07 be 00 add %fp, -512, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4000d880: ba 92 20 00 orcc %o0, 0, %i5
4000d884: 12 80 00 fc bne 4000dc74 <msdos_format+0xf3c> <== NEVER TAKEN
4000d888: c2 07 bd d4 ld [ %fp + -556 ], %g1
4000d88c: 80 a0 60 00 cmp %g1, 0
4000d890: 12 80 00 08 bne 4000d8b0 <msdos_format+0xb78>
4000d894: 90 10 00 19 mov %i1, %o0
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
4000d898: fa 07 bd d8 ld [ %fp + -552 ], %i5
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000d89c: 80 a7 60 00 cmp %i5, 0
4000d8a0: 22 80 00 37 be,a 4000d97c <msdos_format+0xc44>
4000d8a4: d2 07 bd bc ld [ %fp + -580 ], %o1
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4000d8a8: 10 80 00 10 b 4000d8e8 <msdos_format+0xbb0>
4000d8ac: 92 10 20 00 clr %o1
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d8b0: 92 10 20 02 mov 2, %o1
4000d8b4: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000d8b8: 7f ff fc 84 call 4000cac8 <msdos_format_printf>
4000d8bc: 94 12 a1 68 or %o2, 0x168, %o2 ! 4002b168 <_CPU_Trap_slot_template+0x138>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000d8c0: d2 07 bd d4 ld [ %fp + -556 ], %o1
4000d8c4: d4 07 bd ac ld [ %fp + -596 ], %o2
4000d8c8: 90 10 00 1c mov %i4, %o0
4000d8cc: 7f ff fc 94 call 4000cb1c <msdos_format_write_sec>
4000d8d0: 96 07 be 00 add %fp, -512, %o3
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000d8d4: ba 92 20 00 orcc %o0, 0, %i5
4000d8d8: 22 bf ff f1 be,a 4000d89c <msdos_format+0xb64> <== ALWAYS TAKEN
4000d8dc: fa 07 bd d8 ld [ %fp + -552 ], %i5
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
4000d8e0: 10 80 00 a5 b 4000db74 <msdos_format+0xe3c> <== NOT EXECUTED
4000d8e4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4000d8e8: 94 10 22 00 mov 0x200, %o2
4000d8ec: 40 00 36 da call 4001b454 <memset>
4000d8f0: 90 07 be 00 add %fp, -512, %o0
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000d8f4: 82 10 20 52 mov 0x52, %g1
4000d8f8: c2 2f be 00 stb %g1, [ %fp + -512 ]
4000d8fc: c2 2f be 01 stb %g1, [ %fp + -511 ]
4000d900: 82 10 20 61 mov 0x61, %g1
4000d904: c2 2f be 02 stb %g1, [ %fp + -510 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000d908: c2 2f bf e7 stb %g1, [ %fp + -25 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000d90c: 82 10 20 55 mov 0x55, %g1
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4000d910: d4 07 bd ac ld [ %fp + -596 ], %o2
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000d914: c2 2f bf fe stb %g1, [ %fp + -2 ]
4000d918: 82 10 3f aa mov -86, %g1
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000d91c: 84 10 20 41 mov 0x41, %g2
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000d920: 86 10 20 72 mov 0x72, %g3
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000d924: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4000d928: 82 10 3f ff mov -1, %g1
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4000d92c: 92 10 00 1d mov %i5, %o1
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000d930: c4 2f be 03 stb %g2, [ %fp + -509 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000d934: c6 2f bf e4 stb %g3, [ %fp + -28 ]
4000d938: c6 2f bf e5 stb %g3, [ %fp + -27 ]
4000d93c: c4 2f bf e6 stb %g2, [ %fp + -26 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4000d940: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4000d944: c2 2f bf e9 stb %g1, [ %fp + -23 ]
4000d948: c2 2f bf ea stb %g1, [ %fp + -22 ]
4000d94c: c2 2f bf eb stb %g1, [ %fp + -21 ]
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
4000d950: c2 2f bf ec stb %g1, [ %fp + -20 ]
4000d954: c2 2f bf ed stb %g1, [ %fp + -19 ]
4000d958: c2 2f bf ee stb %g1, [ %fp + -18 ]
4000d95c: c2 2f bf ef stb %g1, [ %fp + -17 ]
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4000d960: 90 10 00 1c mov %i4, %o0
4000d964: 7f ff fc 6e call 4000cb1c <msdos_format_write_sec>
4000d968: 96 07 be 00 add %fp, -512, %o3
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4000d96c: ba 92 20 00 orcc %o0, 0, %i5
4000d970: 12 80 00 81 bne 4000db74 <msdos_format+0xe3c> <== NEVER TAKEN
4000d974: b0 10 00 1d mov %i5, %i0
ret_val = msdos_format_fill_sectors
(rqdata,
4000d978: d2 07 bd bc ld [ %fp + -580 ], %o1
4000d97c: d0 0f bd dc ldub [ %fp + -548 ], %o0
4000d980: 7f ff d3 34 call 40002650 <.umul>
4000d984: fa 07 bd b4 ld [ %fp + -588 ], %i5
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4000d988: d8 07 bd ac ld [ %fp + -596 ], %o4
(rqdata,
4000d98c: 96 10 00 08 mov %o0, %o3
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4000d990: 94 10 00 1d mov %i5, %o2
4000d994: 90 10 00 19 mov %i1, %o0
4000d998: 92 10 00 1c mov %i4, %o1
4000d99c: 7f ff fc 78 call 4000cb7c <msdos_format_fill_sectors>
4000d9a0: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4000d9a4: ba 92 20 00 orcc %o0, 0, %i5
4000d9a8: 12 80 00 b3 bne 4000dc74 <msdos_format+0xf3c> <== NEVER TAKEN
4000d9ac: d4 07 bd cc ld [ %fp + -564 ], %o2
ret_val = msdos_format_fill_sectors
4000d9b0: d6 07 bd d0 ld [ %fp + -560 ], %o3
4000d9b4: d8 07 bd ac ld [ %fp + -596 ], %o4
4000d9b8: 90 10 00 19 mov %i1, %o0
4000d9bc: 92 10 00 1c mov %i4, %o1
4000d9c0: 7f ff fc 6f call 4000cb7c <msdos_format_fill_sectors>
4000d9c4: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4000d9c8: ba 92 20 00 orcc %o0, 0, %i5
4000d9cc: 12 80 00 aa bne 4000dc74 <msdos_format+0xf3c> <== NEVER TAKEN
4000d9d0: c2 0f bd f4 ldub [ %fp + -524 ], %g1
4000d9d4: 80 a0 60 00 cmp %g1, 0
4000d9d8: 12 80 00 0f bne 4000da14 <msdos_format+0xcdc>
4000d9dc: 90 07 be 00 add %fp, -512, %o0
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4000d9e0: 92 10 20 00 clr %o1
4000d9e4: 40 00 36 9c call 4001b454 <memset>
4000d9e8: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
4000d9ec: c2 0f bd de ldub [ %fp + -546 ], %g1
4000d9f0: 80 a0 60 02 cmp %g1, 2
4000d9f4: 02 80 00 21 be 4000da78 <msdos_format+0xd40>
4000d9f8: 80 a0 60 04 cmp %g1, 4
4000d9fc: 02 80 00 27 be 4000da98 <msdos_format+0xd60>
4000da00: 80 a0 60 01 cmp %g1, 1
4000da04: 12 80 00 32 bne 4000dacc <msdos_format+0xd94> <== NEVER TAKEN
4000da08: c2 0f bd dd ldub [ %fp + -547 ], %g1
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
4000da0c: 10 80 00 16 b 4000da64 <msdos_format+0xd2c>
4000da10: c2 2f be 00 stb %g1, [ %fp + -512 ]
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
4000da14: 92 10 20 00 clr %o1
4000da18: 94 10 22 00 mov 0x200, %o2
4000da1c: 40 00 36 8e call 4001b454 <memset>
4000da20: 90 07 be 00 add %fp, -512, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4000da24: 92 07 bd e8 add %fp, -536, %o1
4000da28: 94 10 20 0b mov 0xb, %o2
4000da2c: 40 00 36 4d call 4001b360 <memcpy>
4000da30: 90 07 be 00 add %fp, -512, %o0
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
4000da34: d2 07 bd cc ld [ %fp + -564 ], %o1
4000da38: d4 07 bd ac ld [ %fp + -596 ], %o2
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4000da3c: 82 10 20 08 mov 8, %g1
ret_val = msdos_format_write_sec
4000da40: 90 10 00 1c mov %i4, %o0
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4000da44: c2 2f be 0b stb %g1, [ %fp + -501 ]
ret_val = msdos_format_write_sec
4000da48: 7f ff fc 35 call 4000cb1c <msdos_format_write_sec>
4000da4c: 96 07 be 00 add %fp, -512, %o3
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if (ret_val == 0) {
4000da50: b0 92 20 00 orcc %o0, 0, %i0
4000da54: 12 80 00 49 bne 4000db78 <msdos_format+0xe40> <== NEVER TAKEN
4000da58: 80 a6 20 00 cmp %i0, 0
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4000da5c: 10 bf ff e1 b 4000d9e0 <msdos_format+0xca8>
4000da60: 90 07 be 00 add %fp, -512, %o0
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
4000da64: 82 10 3f 8f mov -113, %g1
4000da68: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
4000da6c: 82 10 3f ff mov -1, %g1
break;
4000da70: 10 80 00 1b b 4000dadc <msdos_format+0xda4>
4000da74: c2 2f be 02 stb %g1, [ %fp + -510 ]
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
4000da78: c2 0f bd dd ldub [ %fp + -547 ], %g1
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4000da7c: 84 10 3f f8 mov -8, %g2
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
4000da80: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4000da84: c4 2f be 02 stb %g2, [ %fp + -510 ]
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
4000da88: 82 10 3f ff mov -1, %g1
4000da8c: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
4000da90: 10 80 00 13 b 4000dadc <msdos_format+0xda4>
4000da94: c2 2f be 03 stb %g1, [ %fp + -509 ]
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4000da98: c2 0f bd dd ldub [ %fp + -547 ], %g1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000da9c: 84 10 3f f8 mov -8, %g2
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4000daa0: c2 2f be 00 stb %g1, [ %fp + -512 ]
4000daa4: 82 10 3f ff mov -1, %g1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000daa8: c4 2f be 04 stb %g2, [ %fp + -508 ]
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4000daac: c2 2f be 01 stb %g1, [ %fp + -511 ]
4000dab0: c2 2f be 02 stb %g1, [ %fp + -510 ]
4000dab4: c2 2f be 03 stb %g1, [ %fp + -509 ]
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000dab8: c2 2f be 05 stb %g1, [ %fp + -507 ]
4000dabc: c2 2f be 06 stb %g1, [ %fp + -506 ]
4000dac0: 82 10 20 0f mov 0xf, %g1
break;
4000dac4: 10 80 00 06 b 4000dadc <msdos_format+0xda4>
4000dac8: c2 2f be 07 stb %g1, [ %fp + -505 ]
default:
ret_val = -1;
errno = EINVAL;
4000dacc: 40 00 33 80 call 4001a8cc <__errno> <== NOT EXECUTED
4000dad0: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4000dad4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000dad8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4000dadc: c2 0f bd de ldub [ %fp + -546 ], %g1
4000dae0: 80 a0 60 04 cmp %g1, 4
4000dae4: 12 80 00 0a bne 4000db0c <msdos_format+0xdd4>
4000dae8: c4 0f bd fc ldub [ %fp + -516 ], %g2
/*
* only first valid cluster (cluster number 2) belongs
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
4000daec: 82 10 3f f8 mov -8, %g1
4000daf0: c2 2f be 08 stb %g1, [ %fp + -504 ]
4000daf4: 82 10 3f ff mov -1, %g1
4000daf8: c2 2f be 09 stb %g1, [ %fp + -503 ]
4000dafc: c2 2f be 0a stb %g1, [ %fp + -502 ]
4000db00: 82 10 20 0f mov 0xf, %g1
4000db04: c2 2f be 0b stb %g1, [ %fp + -501 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000db08: c4 0f bd fc ldub [ %fp + -516 ], %g2
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
4000db0c: f6 07 bd b4 ld [ %fp + -588 ], %i3
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000db10: 80 a0 a0 00 cmp %g2, 0
4000db14: 12 80 00 06 bne 4000db2c <msdos_format+0xdf4>
4000db18: c2 07 bd b8 ld [ %fp + -584 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000db1c: b6 06 c0 01 add %i3, %g1, %i3
4000db20: 82 20 00 01 neg %g1
4000db24: b6 06 ff ff add %i3, -1, %i3
4000db28: b6 0e c0 01 and %i3, %g1, %i3
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
4000db2c: b0 10 00 1d mov %i5, %i0
4000db30: 10 80 00 0b b 4000db5c <msdos_format+0xe24>
4000db34: ba 10 20 00 clr %i5
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
(fd,
start_sector
+ (i * fmt_params.sectors_per_fat),
4000db38: 7f ff d2 c6 call 40002650 <.umul>
4000db3c: 90 10 00 1d mov %i5, %o0
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
4000db40: d4 07 bd ac ld [ %fp + -596 ], %o2
(fd,
4000db44: 92 02 00 1b add %o0, %i3, %o1
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
4000db48: 96 07 be 00 add %fp, -512, %o3
4000db4c: 90 10 00 1c mov %i4, %o0
4000db50: 7f ff fb f3 call 4000cb1c <msdos_format_write_sec>
4000db54: ba 07 60 01 inc %i5
4000db58: b0 10 00 08 mov %o0, %i0
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
4000db5c: c2 0f bd dc ldub [ %fp + -548 ], %g1
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
4000db60: 80 a7 40 01 cmp %i5, %g1
4000db64: 16 80 00 04 bge 4000db74 <msdos_format+0xe3c>
4000db68: 80 a6 20 00 cmp %i0, 0
(i < fmt_params.fat_num) && (ret_val == 0);
4000db6c: 02 bf ff f3 be 4000db38 <msdos_format+0xe00> <== ALWAYS TAKEN
4000db70: d2 07 bd bc ld [ %fp + -580 ], %o1
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
4000db74: 80 a6 20 00 cmp %i0, 0
4000db78: 12 80 00 0f bne 4000dbb4 <msdos_format+0xe7c>
4000db7c: 80 a7 3f ff cmp %i4, -1
4000db80: 80 8e a0 ff btst 0xff, %i2
4000db84: 02 80 00 0c be 4000dbb4 <msdos_format+0xe7c>
4000db88: 80 a7 3f ff cmp %i4, -1
4000db8c: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1
4000db90: 80 a0 60 00 cmp %g1, 0
4000db94: 02 80 00 08 be 4000dbb4 <msdos_format+0xe7c>
4000db98: 80 a7 3f ff cmp %i4, -1
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
4000db9c: 90 10 00 1c mov %i4, %o0
4000dba0: 13 08 00 10 sethi %hi(0x20004000), %o1
4000dba4: 40 00 18 99 call 40013e08 <ioctl>
4000dba8: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_SIZE+0x1fc04206>
4000dbac: b0 10 00 08 mov %o0, %i0
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4000dbb0: 80 a7 3f ff cmp %i4, -1
4000dbb4: 02 80 00 40 be 4000dcb4 <msdos_format+0xf7c> <== NEVER TAKEN
4000dbb8: 01 00 00 00 nop
close(fd);
4000dbbc: 7f ff db b0 call 40004a7c <close>
4000dbc0: 90 10 00 1c mov %i4, %o0
4000dbc4: 81 c7 e0 08 ret
4000dbc8: 81 e8 00 00 restore
uint64_t total_size = 0;
uint32_t data_clusters_cnt;
uint8_t iteration_cnt = 0;
uint8_t fat_type = UINT8_MAX;
memset(fmt_params,0,sizeof(*fmt_params));
4000dbcc: 94 10 20 54 mov 0x54, %o2
4000dbd0: 40 00 36 21 call 4001b454 <memset>
4000dbd4: 90 07 bd ac add %fp, -596, %o0
static inline int rtems_disk_fd_get_media_block_size(
int fd,
uint32_t *media_block_size
)
{
return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
4000dbd8: 90 10 00 1c mov %i4, %o0
4000dbdc: 37 10 01 10 sethi %hi(0x40044000), %i3
4000dbe0: 94 07 bd ac add %fp, -596, %o2
4000dbe4: 40 00 18 89 call 40013e08 <ioctl>
4000dbe8: 92 16 e2 02 or %i3, 0x202, %o1
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
4000dbec: ba 92 20 00 orcc %o0, 0, %i5
4000dbf0: 12 bf fd ed bne 4000d3a4 <msdos_format+0x66c> <== NEVER TAKEN
4000dbf4: c2 07 bd b0 ld [ %fp + -592 ], %g1
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
4000dbf8: 10 bf fc 7f b 4000cdf4 <msdos_format+0xbc>
4000dbfc: 90 10 00 1c mov %i4, %o0
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dc00: d6 0f bd dc ldub [ %fp + -548 ], %o3
4000dc04: 90 10 00 19 mov %i1, %o0
4000dc08: 92 10 20 02 mov 2, %o1
4000dc0c: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000dc10: 7f ff fb ae call 4000cac8 <msdos_format_printf>
4000dc14: 94 12 a1 88 or %o2, 0x188, %o2 ! 4002b188 <_CPU_Trap_slot_template+0x158>
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
4000dc18: 80 a6 60 00 cmp %i1, 0
4000dc1c: 32 bf fc 9e bne,a 4000ce94 <msdos_format+0x15c>
4000dc20: c2 06 60 08 ld [ %i1 + 8 ], %g1
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
4000dc24: 10 bf fc a0 b 4000cea4 <msdos_format+0x16c>
4000dc28: 84 10 20 20 mov 0x20, %g2
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
4000dc2c: 32 bf fe 4c bne,a 4000d55c <msdos_format+0x824>
4000dc30: c2 06 60 04 ld [ %i1 + 4 ], %g1
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4000dc34: 10 bf fe 50 b 4000d574 <msdos_format+0x83c>
4000dc38: 03 10 00 aa sethi %hi(0x4002a800), %g1
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
4000dc3c: 40 00 1c 71 call 40014e00 <rtems_clock_get_tod_timeval>
4000dc40: 90 07 be 00 add %fp, -512, %o0
if (rc == RTEMS_SUCCESSFUL) {
4000dc44: 80 a2 20 00 cmp %o0, 0
4000dc48: 02 bf fe 63 be 4000d5d4 <msdos_format+0x89c> <== NEVER TAKEN
4000dc4c: c2 07 be 00 ld [ %fp + -512 ], %g1
4000dc50: 30 bf fe 64 b,a 4000d5e0 <msdos_format+0x8a8>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
4000dc54: 92 07 be 00 add %fp, -512, %o1
4000dc58: 40 00 19 56 call 400141b0 <read>
4000dc5c: 94 10 00 1d mov %i5, %o2
4000dc60: 80 a2 20 00 cmp %o0, 0
4000dc64: 16 80 00 08 bge 4000dc84 <msdos_format+0xf4c> <== ALWAYS TAKEN
4000dc68: 90 10 00 19 mov %i1, %o0
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
4000dc6c: 10 80 00 04 b 4000dc7c <msdos_format+0xf44> <== NOT EXECUTED
4000dc70: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
4000dc74: 10 bf ff c0 b 4000db74 <msdos_format+0xe3c> <== NOT EXECUTED
4000dc78: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4000dc7c: 10 bf ff be b 4000db74 <msdos_format+0xe3c> <== NOT EXECUTED
4000dc80: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dc84: 92 10 20 02 mov 2, %o1
4000dc88: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000dc8c: 7f ff fb 8f call 4000cac8 <msdos_format_printf>
4000dc90: 94 12 a1 a0 or %o2, 0x1a0, %o2 ! 4002b1a0 <_CPU_Trap_slot_template+0x170>
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
4000dc94: fa 07 bd b0 ld [ %fp + -592 ], %i5
4000dc98: 03 00 00 3f sethi %hi(0xfc00), %g1
4000dc9c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
4000dca0: 80 a7 40 01 cmp %i5, %g1
4000dca4: 18 bf fe 7a bgu 4000d68c <msdos_format+0x954>
4000dca8: b6 10 20 00 clr %i3
4000dcac: 10 bf fe 77 b 4000d688 <msdos_format+0x950>
4000dcb0: b6 10 00 1d mov %i5, %i3
if (fd != -1) {
close(fd);
}
return ret_val;
}
4000dcb4: 81 c7 e0 08 ret <== NOT EXECUTED
4000dcb8: 81 e8 00 00 restore <== NOT EXECUTED
4000cb7c <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000cb7c: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4000cb80: 7f ff e1 2a call 40005028 <malloc>
4000cb84: 90 10 00 1c mov %i4, %o0
if (fill_buffer == NULL) {
4000cb88: a0 92 20 00 orcc %o0, 0, %l0
4000cb8c: 12 80 00 07 bne 4000cba8 <msdos_format_fill_sectors+0x2c> <== ALWAYS TAKEN
4000cb90: 92 10 00 1d mov %i5, %o1
errno = ENOMEM;
4000cb94: 40 00 37 4e call 4001a8cc <__errno> <== NOT EXECUTED
4000cb98: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4000cb9c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000cba0: 10 80 00 05 b 4000cbb4 <msdos_format_fill_sectors+0x38> <== NOT EXECUTED
4000cba4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
4000cba8: 94 10 00 1c mov %i4, %o2
4000cbac: 40 00 3a 2a call 4001b454 <memset>
4000cbb0: ba 10 20 00 clr %i5
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000cbb4: 90 10 00 18 mov %i0, %o0
4000cbb8: 92 10 20 02 mov 2, %o1
4000cbbc: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000cbc0: 7f ff ff c2 call 4000cac8 <msdos_format_printf>
4000cbc4: 94 12 a0 40 or %o2, 0x40, %o2 ! 4002b040 <_CPU_Trap_slot_template+0x10>
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000cbc8: 85 2e e0 02 sll %i3, 2, %g2
4000cbcc: 83 2e e0 04 sll %i3, 4, %g1
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000cbd0: 2b 10 00 ab sethi %hi(0x4002ac00), %l5
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000cbd4: 82 00 80 01 add %g2, %g1, %g1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000cbd8: a4 10 20 00 clr %l2
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000cbdc: a7 28 60 02 sll %g1, 2, %l3
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
4000cbe0: a2 10 3f ff mov -1, %l1
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000cbe4: a6 00 40 13 add %g1, %l3, %l3
4000cbe8: a8 06 c0 1a add %i3, %i2, %l4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000cbec: 10 80 00 15 b 4000cc40 <msdos_format_fill_sectors+0xc4>
4000cbf0: aa 15 61 e8 or %l5, 0x1e8, %l5
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
4000cbf4: 7f ff d6 d1 call 40002738 <.udiv>
4000cbf8: 92 10 00 1b mov %i3, %o1
if (percent != last_percent) {
4000cbfc: 80 a2 00 11 cmp %o0, %l1
4000cc00: 02 80 00 08 be 4000cc20 <msdos_format_fill_sectors+0xa4>
4000cc04: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
4000cc08: 12 80 00 06 bne 4000cc20 <msdos_format_fill_sectors+0xa4>
4000cc0c: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000cc10: 90 10 00 18 mov %i0, %o0
4000cc14: 92 10 20 02 mov 2, %o1
4000cc18: 7f ff ff ac call 4000cac8 <msdos_format_printf>
4000cc1c: 94 10 00 15 mov %l5, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000cc20: 92 10 00 1a mov %i2, %o1
4000cc24: 90 10 00 19 mov %i1, %o0
4000cc28: 94 10 00 1c mov %i4, %o2
4000cc2c: 96 10 00 10 mov %l0, %o3
4000cc30: 7f ff ff bb call 4000cb1c <msdos_format_write_sec>
4000cc34: b4 06 a0 01 inc %i2
4000cc38: a4 04 bf 9c add %l2, -100, %l2
4000cc3c: ba 10 00 08 mov %o0, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000cc40: 80 a5 00 1a cmp %l4, %i2
4000cc44: 02 80 00 04 be 4000cc54 <msdos_format_fill_sectors+0xd8>
4000cc48: 80 a7 60 00 cmp %i5, 0
4000cc4c: 02 bf ff ea be 4000cbf4 <msdos_format_fill_sectors+0x78> <== ALWAYS TAKEN
4000cc50: 90 04 80 13 add %l2, %l3, %o0
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4000cc54: 90 10 00 18 mov %i0, %o0
4000cc58: 92 10 20 02 mov 2, %o1
4000cc5c: 15 10 00 ac sethi %hi(0x4002b000), %o2
4000cc60: 7f ff ff 9a call 4000cac8 <msdos_format_printf>
4000cc64: 94 12 a1 60 or %o2, 0x160, %o2 ! 4002b160 <_CPU_Trap_slot_template+0x130>
if (ret_val)
4000cc68: 80 a7 60 00 cmp %i5, 0
4000cc6c: 02 80 00 09 be 4000cc90 <msdos_format_fill_sectors+0x114> <== ALWAYS TAKEN
4000cc70: 80 a4 20 00 cmp %l0, 0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000cc74: 15 10 00 ac sethi %hi(0x4002b000), %o2 <== NOT EXECUTED
4000cc78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000cc7c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000cc80: 94 12 a0 50 or %o2, 0x50, %o2 <== NOT EXECUTED
4000cc84: 7f ff ff 91 call 4000cac8 <msdos_format_printf> <== NOT EXECUTED
4000cc88: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
4000cc8c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
4000cc90: 02 80 00 04 be 4000cca0 <msdos_format_fill_sectors+0x124> <== NEVER TAKEN
4000cc94: 01 00 00 00 nop
free(fill_buffer);
4000cc98: 7f ff df 9a call 40004b00 <free>
4000cc9c: 90 10 00 10 mov %l0, %o0
fill_buffer = NULL;
}
return ret_val;
}
4000cca0: 81 c7 e0 08 ret
4000cca4: 91 e8 00 1d restore %g0, %i5, %o0
4000cac8 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
4000cac8: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
4000cacc: 94 07 a0 50 add %fp, 0x50, %o2
4000cad0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000cad4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000cad8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
4000cadc: 80 a6 20 00 cmp %i0, 0
4000cae0: 02 80 00 0d be 4000cb14 <msdos_format_printf+0x4c>
4000cae4: d4 27 bf fc st %o2, [ %fp + -4 ]
4000cae8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000caec: 80 a0 40 19 cmp %g1, %i1
4000caf0: 06 80 00 09 bl 4000cb14 <msdos_format_printf+0x4c> <== ALWAYS TAKEN
4000caf4: 3b 10 00 b0 sethi %hi(0x4002c000), %i5
{
vfprintf (stdout, format, args);
4000caf8: c2 07 61 18 ld [ %i5 + 0x118 ], %g1 ! 4002c118 <_impure_ptr><== NOT EXECUTED
4000cafc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4000cb00: 40 00 58 a2 call 40022d88 <vfprintf> <== NOT EXECUTED
4000cb04: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
4000cb08: c2 07 61 18 ld [ %i5 + 0x118 ], %g1 <== NOT EXECUTED
4000cb0c: 40 00 38 73 call 4001acd8 <fflush> <== NOT EXECUTED
4000cb10: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
4000cb14: 81 c7 e0 08 ret
4000cb18: 81 e8 00 00 restore
4000cb1c <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000cb1c: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000cb20: 94 10 20 00 clr %o2
4000cb24: 96 10 00 1a mov %i2, %o3
4000cb28: 90 10 20 00 clr %o0
4000cb2c: 7f ff d5 ac call 400021dc <__muldi3>
4000cb30: 92 10 00 19 mov %i1, %o1
4000cb34: 84 10 00 08 mov %o0, %g2
4000cb38: 86 10 00 09 mov %o1, %g3
4000cb3c: 90 10 00 18 mov %i0, %o0
4000cb40: 92 10 00 02 mov %g2, %o1
4000cb44: 94 10 00 03 mov %g3, %o2
4000cb48: 40 00 1c d1 call 40013e8c <lseek>
4000cb4c: 96 10 20 00 clr %o3
4000cb50: 80 a2 20 00 cmp %o0, 0
4000cb54: 16 80 00 04 bge 4000cb64 <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
4000cb58: 90 10 00 18 mov %i0, %o0
4000cb5c: 81 c7 e0 08 ret <== NOT EXECUTED
4000cb60: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
4000cb64: 92 10 00 1b mov %i3, %o1
4000cb68: 7f ff ef 1e call 400087e0 <write>
4000cb6c: 94 10 00 1a mov %i2, %o2
4000cb70: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
4000cb74: 81 c7 e0 08 ret
4000cb78: 81 e8 00 00 restore
400181bc <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
)
{
400181bc: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
400181c0: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
400181c4: 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);
400181c8: 90 10 00 1c mov %i4, %o0
400181cc: 92 10 00 1a mov %i2, %o1
400181d0: 7f ff e5 23 call 4001165c <fat_file_open>
400181d4: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
400181d8: ba 92 20 00 orcc %o0, 0, %i5
400181dc: 32 80 00 a5 bne,a 40018470 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NEVER TAKEN
400181e0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
fat_fd->cln = cln;
400181e4: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
400181e8: 03 00 08 00 sethi %hi(0x200000), %g1
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
400181ec: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
400181f0: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
400181f4: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
400181f8: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
400181fc: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
40018200: 7f ff e7 c4 call 40012110 <fat_file_size>
40018204: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
40018208: ba 92 20 00 orcc %o0, 0, %i5
4001820c: 22 80 00 04 be,a 4001821c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x60><== ALWAYS TAKEN
40018210: ba 07 bf c0 add %fp, -64, %i5
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
40018214: 10 80 00 19 b 40018278 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xbc><== NOT EXECUTED
40018218: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001821c: 92 10 20 00 clr %o1
40018220: 90 10 00 1d mov %i5, %o0
40018224: 40 00 0c 8c call 4001b454 <memset>
40018228: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
4001822c: 94 10 00 1d mov %i5, %o2
40018230: 33 10 00 ab sethi %hi(0x4002ac00), %i1
40018234: 92 10 20 01 mov 1, %o1
40018238: 96 10 20 0b mov 0xb, %o3
4001823c: 7f ff fb 7a call 40017024 <msdos_long_to_short>
40018240: 90 16 61 e8 or %i1, 0x1e8, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
40018244: d2 07 bf bc ld [ %fp + -68 ], %o1
40018248: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
4001824c: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
40018250: 90 10 00 18 mov %i0, %o0
40018254: 94 10 20 00 clr %o2
40018258: 96 16 61 e8 or %i1, 0x1e8, %o3
4001825c: 98 10 20 01 mov 1, %o4
40018260: 7f ff fd 1b call 400176cc <msdos_find_name_in_fat_file>
40018264: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
40018268: ba 92 20 00 orcc %o0, 0, %i5
4001826c: 22 80 00 05 be,a 40018280 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc4><== ALWAYS TAKEN
40018270: ba 07 bf e0 add %fp, -32, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
40018274: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40018278: 10 80 00 77 b 40018454 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
4001827c: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40018280: 92 10 20 00 clr %o1
40018284: 90 10 00 1d mov %i5, %o0
40018288: 40 00 0c 73 call 4001b454 <memset>
4001828c: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
40018290: 94 10 00 1d mov %i5, %o2
40018294: 33 10 00 ad sethi %hi(0x4002b400), %i1
40018298: 92 10 20 02 mov 2, %o1
4001829c: 96 10 20 0b mov 0xb, %o3
400182a0: 7f ff fb 61 call 40017024 <msdos_long_to_short>
400182a4: 90 16 60 80 or %i1, 0x80, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
400182a8: d2 07 bf bc ld [ %fp + -68 ], %o1
400182ac: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
400182b0: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
400182b4: 90 10 00 18 mov %i0, %o0
400182b8: 94 10 20 00 clr %o2
400182bc: 96 16 60 80 or %i1, 0x80, %o3
400182c0: 98 10 20 02 mov 2, %o4
400182c4: 7f ff fd 02 call 400176cc <msdos_find_name_in_fat_file>
400182c8: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
400182cc: ba 92 20 00 orcc %o0, 0, %i5
400182d0: 02 80 00 04 be 400182e0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x124><== ALWAYS TAKEN
400182d4: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
400182d8: 10 80 00 5f b 40018454 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
400182dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
400182e0: e0 17 bf da lduh [ %fp + -38 ], %l0
400182e4: e2 17 bf d4 lduh [ %fp + -44 ], %l1
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
400182e8: 7f ff e5 f3 call 40011ab4 <fat_file_close>
400182ec: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
400182f0: ba 92 20 00 orcc %o0, 0, %i5
400182f4: 12 80 00 5e bne 4001846c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
400182f8: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
400182fc: 83 28 60 10 sll %g1, 0x10, %g1
40018300: 85 30 60 18 srl %g1, 0x18, %g2
40018304: 87 30 60 08 srl %g1, 8, %g3
40018308: 03 00 00 3f sethi %hi(0xfc00), %g1
4001830c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40018310: 86 08 c0 01 and %g3, %g1, %g3
40018314: 86 10 80 03 or %g2, %g3, %g3
40018318: c4 17 bf fa lduh [ %fp + -6 ], %g2
4001831c: 87 28 e0 10 sll %g3, 0x10, %g3
40018320: 85 28 a0 10 sll %g2, 0x10, %g2
40018324: 89 30 a0 18 srl %g2, 0x18, %g4
40018328: 85 30 a0 08 srl %g2, 8, %g2
4001832c: 82 08 80 01 and %g2, %g1, %g1
40018330: 82 11 00 01 or %g4, %g1, %g1
40018334: 80 90 c0 01 orcc %g3, %g1, %g0
40018338: 12 80 00 08 bne 40018358 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x19c><== ALWAYS TAKEN
4001833c: 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;
40018340: 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;
40018344: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40018348: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001834c: 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;
40018350: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40018354: 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);
40018358: 92 10 00 1a mov %i2, %o1
4001835c: 7f ff e4 c0 call 4001165c <fat_file_open>
40018360: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
40018364: ba 92 20 00 orcc %o0, 0, %i5
40018368: 12 80 00 41 bne 4001846c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
4001836c: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40018370: 33 00 00 3f sethi %hi(0xfc00), %i1
40018374: 83 28 60 10 sll %g1, 0x10, %g1
40018378: b2 16 63 ff or %i1, 0x3ff, %i1
4001837c: bb 30 60 18 srl %g1, 0x18, %i5
40018380: 83 30 60 08 srl %g1, 8, %g1
40018384: 82 08 40 19 and %g1, %i1, %g1
40018388: ba 17 40 01 or %i5, %g1, %i5
4001838c: c2 17 bf fa lduh [ %fp + -6 ], %g1
40018390: bb 2f 60 10 sll %i5, 0x10, %i5
40018394: 83 28 60 10 sll %g1, 0x10, %g1
40018398: 89 30 60 18 srl %g1, 0x18, %g4
4001839c: 83 30 60 08 srl %g1, 8, %g1
400183a0: b2 08 40 19 and %g1, %i1, %i1
400183a4: 88 11 00 19 or %g4, %i1, %g4
400183a8: 88 97 40 04 orcc %i5, %g4, %g4
400183ac: 12 80 00 05 bne 400183c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204><== ALWAYS TAKEN
400183b0: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
400183b4: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
400183b8: 10 80 00 03 b 400183c4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
400183bc: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
400183c0: c8 22 60 1c st %g4, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
400183c4: 03 00 08 00 sethi %hi(0x200000), %g1
400183c8: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
400183cc: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
400183d0: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
400183d4: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
400183d8: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400183dc: 7f ff e7 4d call 40012110 <fat_file_size>
400183e0: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
400183e4: ba 92 20 00 orcc %o0, 0, %i5
400183e8: 02 80 00 04 be 400183f8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x23c><== ALWAYS TAKEN
400183ec: d2 07 bf bc ld [ %fp + -68 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
400183f0: 10 80 00 19 b 40018454 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
400183f4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
400183f8: 87 2c 60 10 sll %l1, 0x10, %g3
400183fc: 03 00 00 3f sethi %hi(0xfc00), %g1
40018400: 95 30 e0 18 srl %g3, 0x18, %o2
40018404: 82 10 63 ff or %g1, 0x3ff, %g1
40018408: 87 30 e0 08 srl %g3, 8, %g3
4001840c: 86 08 c0 01 and %g3, %g1, %g3
40018410: 85 2c 20 10 sll %l0, 0x10, %g2
40018414: 94 12 80 03 or %o2, %g3, %o2
40018418: 87 30 a0 18 srl %g2, 0x18, %g3
4001841c: 85 30 a0 08 srl %g2, 8, %g2
40018420: 82 08 80 01 and %g2, %g1, %g1
40018424: 82 10 c0 01 or %g3, %g1, %g1
40018428: 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,
4001842c: 90 10 00 18 mov %i0, %o0
40018430: 94 12 80 01 or %o2, %g1, %o2
40018434: 96 10 00 1a mov %i2, %o3
40018438: 7f ff ff 00 call 40018038 <msdos_find_node_by_cluster_num_in_fat_file>
4001843c: 98 10 00 1b mov %i3, %o4
40018440: d2 07 bf bc ld [ %fp + -68 ], %o1
40018444: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
40018448: 80 a7 60 00 cmp %i5, 0
4001844c: 02 80 00 05 be 40018460 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a4><== ALWAYS TAKEN
40018450: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
40018454: 7f ff e5 98 call 40011ab4 <fat_file_close> <== NOT EXECUTED
40018458: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001845c: 30 80 00 05 b,a 40018470 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NOT EXECUTED
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
40018460: 7f ff e5 95 call 40011ab4 <fat_file_close>
40018464: 01 00 00 00 nop
40018468: ba 10 00 08 mov %o0, %i5
return rc;
}
4001846c: b0 10 00 1d mov %i5, %i0
40018470: 81 c7 e0 08 ret
40018474: 81 e8 00 00 restore
40018478 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
40018478: 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,
4001847c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40018480: 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
)
{
40018484: 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,
40018488: 9a 10 00 1c mov %i4, %o5
4001848c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40018490: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
40018494: 94 10 00 19 mov %i1, %o2
40018498: 96 10 00 1a mov %i2, %o3
4001849c: 7f ff fc 8c call 400176cc <msdos_find_name_in_fat_file>
400184a0: 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))
400184a4: 03 00 00 1f sethi %hi(0x7c00), %g1
400184a8: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
400184ac: 80 a2 00 01 cmp %o0, %g1
400184b0: 02 80 00 05 be 400184c4 <msdos_get_name_node+0x4c>
400184b4: b8 10 00 08 mov %o0, %i4
400184b8: 80 a2 20 00 cmp %o0, 0
400184bc: 12 80 00 2d bne 40018570 <msdos_get_name_node+0xf8>
400184c0: 01 00 00 00 nop
return rc;
if (!create_node)
400184c4: 80 a6 60 00 cmp %i1, 0
400184c8: 12 80 00 2a bne 40018570 <msdos_get_name_node+0xf8>
400184cc: 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)
400184d0: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
400184d4: 80 a7 00 01 cmp %i4, %g1
400184d8: 02 80 00 26 be 40018570 <msdos_get_name_node+0xf8>
400184dc: 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)
400184e0: 12 80 00 24 bne 40018570 <msdos_get_name_node+0xf8> <== NEVER TAKEN
400184e4: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
400184e8: 13 10 00 ad sethi %hi(0x4002b400), %o1
400184ec: 94 10 20 02 mov 2, %o2
400184f0: 40 00 10 0e call 4001c528 <strncmp>
400184f4: 92 12 60 80 or %o1, 0x80, %o1
400184f8: 80 a2 20 00 cmp %o0, 0
400184fc: 12 80 00 1d bne 40018570 <msdos_get_name_node+0xf8>
40018500: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
40018504: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
40018508: c8 14 20 14 lduh [ %l0 + 0x14 ], %g4
4001850c: 87 28 e0 10 sll %g3, 0x10, %g3
40018510: 89 29 20 10 sll %g4, 0x10, %g4
40018514: 83 30 e0 18 srl %g3, 0x18, %g1
40018518: b3 31 20 18 srl %g4, 0x18, %i1
4001851c: 89 31 20 08 srl %g4, 8, %g4
40018520: 84 10 a3 ff or %g2, 0x3ff, %g2
40018524: 87 30 e0 08 srl %g3, 8, %g3
40018528: 88 09 00 02 and %g4, %g2, %g4
4001852c: 84 08 c0 02 and %g3, %g2, %g2
40018530: b2 16 40 04 or %i1, %g4, %i1
40018534: 82 10 40 02 or %g1, %g2, %g1
40018538: b3 2e 60 10 sll %i1, 0x10, %i1
/* are we right under root dir ? */
if (dotdot_cln == 0)
4001853c: b2 96 40 01 orcc %i1, %g1, %i1
40018540: 12 80 00 08 bne 40018560 <msdos_get_name_node+0xe8>
40018544: 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;
40018548: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001854c: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40018550: 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;
40018554: 82 10 20 01 mov 1, %g1
40018558: 10 80 00 06 b 40018570 <msdos_get_name_node+0xf8>
4001855c: c2 27 40 00 st %g1, [ %i5 ]
}
else
{
rc =
40018560: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
40018564: b4 10 00 1d mov %i5, %i2
40018568: 7f ff ff 15 call 400181bc <msdos_get_dotdot_dir_info_cluster_num_and_offset>
4001856c: 97 e8 00 10 restore %g0, %l0, %o3
}
}
}
}
return rc;
}
40018570: 81 c7 e0 08 ret
40018574: 91 e8 00 1c restore %g0, %i4, %o0
4000dd50 <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
)
{
4000dd50: 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));
4000dd54: 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;
4000dd58: 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));
4000dd5c: 7f ff db 31 call 40004a20 <calloc>
4000dd60: 92 10 20 a4 mov 0xa4, %o1
if (!fs_info)
4000dd64: ba 92 20 00 orcc %o0, 0, %i5
4000dd68: 32 80 00 03 bne,a 4000dd74 <msdos_initialize_support+0x24><== ALWAYS TAKEN
4000dd6c: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
4000dd70: 30 80 00 45 b,a 4000de84 <msdos_initialize_support+0x134><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
4000dd74: 40 00 12 b1 call 40012838 <fat_init_volume_info>
4000dd78: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
4000dd7c: b8 92 20 00 orcc %o0, 0, %i4
4000dd80: 12 80 00 12 bne 4000ddc8 <msdos_initialize_support+0x78> <== NEVER TAKEN
4000dd84: 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;
4000dd88: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4000dd8c: 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;
4000dd90: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
4000dd94: f4 27 60 98 st %i2, [ %i5 + 0x98 ]
fs_info->directory_handlers = directory_handlers;
4000dd98: 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;
4000dd9c: 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;
4000dda0: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
4000dda4: 90 10 00 1d mov %i5, %o0
4000dda8: 92 07 bf f0 add %fp, -16, %o1
4000ddac: 40 00 0e 2c call 4001165c <fat_file_open>
4000ddb0: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
4000ddb4: b8 92 20 00 orcc %o0, 0, %i4
4000ddb8: 02 80 00 08 be 4000ddd8 <msdos_initialize_support+0x88> <== ALWAYS TAKEN
4000ddbc: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_shutdown_drive(&fs_info->fat);
4000ddc0: 40 00 14 c2 call 400130c8 <fat_shutdown_drive> <== NOT EXECUTED
4000ddc4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000ddc8: 7f ff db 4e call 40004b00 <free> <== NOT EXECUTED
4000ddcc: 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;
}
4000ddd0: 81 c7 e0 08 ret <== NOT EXECUTED
4000ddd4: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4000ddd8: 03 00 08 00 sethi %hi(0x200000), %g1
4000dddc: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000dde0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
4000dde4: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000dde8: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
4000ddec: 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 )
4000ddf0: 80 a0 60 00 cmp %g1, 0
4000ddf4: 12 80 00 09 bne 4000de18 <msdos_initialize_support+0xc8>
4000ddf8: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4000ddfc: 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 :
4000de00: 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) ?
4000de04: 80 a2 00 01 cmp %o0, %g1
4000de08: 1a 80 00 13 bcc 4000de54 <msdos_initialize_support+0x104>
4000de0c: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
4000de10: 10 80 00 11 b 4000de54 <msdos_initialize_support+0x104>
4000de14: 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);
4000de18: 40 00 10 be call 40012110 <fat_file_size>
4000de1c: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
4000de20: b4 92 20 00 orcc %o0, 0, %i2
4000de24: 22 80 00 0c be,a 4000de54 <msdos_initialize_support+0x104><== ALWAYS TAKEN
4000de28: d0 17 60 06 lduh [ %i5 + 6 ], %o0
{
fat_file_close(&fs_info->fat, fat_fd);
4000de2c: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000de30: 40 00 0f 21 call 40011ab4 <fat_file_close> <== NOT EXECUTED
4000de34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000de38: 40 00 14 a4 call 400130c8 <fat_shutdown_drive> <== NOT EXECUTED
4000de3c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000de40: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000de44: 7f ff db 2f call 40004b00 <free> <== NOT EXECUTED
4000de48: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
4000de4c: 81 c7 e0 08 ret <== NOT EXECUTED
4000de50: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
4000de54: 7f ff da f3 call 40004a20 <calloc>
4000de58: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
4000de5c: 80 a2 20 00 cmp %o0, 0
4000de60: 12 80 00 0f bne 4000de9c <msdos_initialize_support+0x14c> <== ALWAYS TAKEN
4000de64: d0 27 60 a0 st %o0, [ %i5 + 0xa0 ]
{
fat_file_close(&fs_info->fat, fat_fd);
4000de68: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000de6c: 40 00 0f 12 call 40011ab4 <fat_file_close> <== NOT EXECUTED
4000de70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000de74: 40 00 14 95 call 400130c8 <fat_shutdown_drive> <== NOT EXECUTED
4000de78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000de7c: 7f ff db 21 call 40004b00 <free> <== NOT EXECUTED
4000de80: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4000de84: 40 00 32 92 call 4001a8cc <__errno> <== NOT EXECUTED
4000de88: 01 00 00 00 nop <== NOT EXECUTED
4000de8c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
4000de90: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000de94: 10 80 00 1b b 4000df00 <msdos_initialize_support+0x1b0> <== NOT EXECUTED
4000de98: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
4000de9c: 92 10 20 01 mov 1, %o1
4000dea0: 90 10 20 03 mov 3, %o0
4000dea4: 94 10 20 10 mov 0x10, %o2
4000dea8: 96 10 20 00 clr %o3
4000deac: 7f ff eb 91 call 40008cf0 <rtems_semaphore_create>
4000deb0: 98 07 60 9c add %i5, 0x9c, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
4000deb4: 80 a2 20 00 cmp %o0, 0
4000deb8: 02 80 00 0e be 4000def0 <msdos_initialize_support+0x1a0> <== ALWAYS TAKEN
4000debc: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
4000dec0: 40 00 0e fd call 40011ab4 <fat_file_close> <== NOT EXECUTED
4000dec4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000dec8: 40 00 14 80 call 400130c8 <fat_shutdown_drive> <== NOT EXECUTED
4000decc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
4000ded0: 7f ff db 0c call 40004b00 <free> <== NOT EXECUTED
4000ded4: d0 07 60 a0 ld [ %i5 + 0xa0 ], %o0 <== NOT EXECUTED
free(fs_info);
4000ded8: 7f ff db 0a call 40004b00 <free> <== NOT EXECUTED
4000dedc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4000dee0: 40 00 32 7b call 4001a8cc <__errno> <== NOT EXECUTED
4000dee4: 01 00 00 00 nop <== NOT EXECUTED
4000dee8: 10 bf ff ea b 4000de90 <msdos_initialize_support+0x140> <== NOT EXECUTED
4000deec: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
4000def0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000def4: d2 20 60 08 st %o1, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
4000def8: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->ops = op_table;
4000defc: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
4000df00: b0 10 00 1c mov %i4, %i0
4000df04: 81 c7 e0 08 ret
4000df08: 81 e8 00 00 restore
4000dd1c <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000dd1c: 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,
4000dd20: 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(
4000dd24: 92 10 20 00 clr %o1
4000dd28: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
4000dd2c: 7f ff ec 8e call 40008f64 <rtems_semaphore_obtain>
4000dd30: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
4000dd34: 80 a2 20 00 cmp %o0, 0
4000dd38: 02 80 00 04 be 4000dd48 <msdos_lock+0x2c> <== ALWAYS TAKEN
4000dd3c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
4000dd40: 7f ff ee 62 call 400096c8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000dd44: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
4000dd48: 81 c7 e0 08 ret
4000dd4c: 81 e8 00 00 restore
40017024 <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)
{
40017024: 9d e3 bf 98 save %sp, -104, %sp
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
40017028: 92 10 20 20 mov 0x20, %o1
4001702c: 90 10 00 1a mov %i2, %o0
40017030: 40 00 11 09 call 4001b454 <memset>
40017034: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
40017038: c2 4e 00 00 ldsb [ %i0 ], %g1
4001703c: 80 a0 60 2e cmp %g1, 0x2e
40017040: 12 80 00 23 bne 400170cc <msdos_long_to_short+0xa8>
40017044: 84 10 20 00 clr %g2
40017048: 80 a6 60 01 cmp %i1, 1
4001704c: 32 80 00 04 bne,a 4001705c <msdos_long_to_short+0x38>
40017050: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
40017054: 10 80 00 0a b 4001707c <msdos_long_to_short+0x58>
40017058: 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))
4001705c: 80 a0 60 2e cmp %g1, 0x2e
40017060: 12 80 00 1c bne 400170d0 <msdos_long_to_short+0xac> <== NEVER TAKEN
40017064: 80 a0 80 19 cmp %g2, %i1
40017068: 80 a6 60 02 cmp %i1, 2
4001706c: 12 80 00 19 bne 400170d0 <msdos_long_to_short+0xac> <== NEVER TAKEN
40017070: 80 a0 80 19 cmp %g2, %i1
{
sfn[0] = sfn[1] = '.';
40017074: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
40017078: 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;
4001707c: 10 80 00 72 b 40017244 <msdos_long_to_short+0x220>
40017080: 82 10 20 01 mov 1, %g1
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40017084: 80 a0 60 2e cmp %g1, 0x2e
40017088: 22 80 00 11 be,a 400170cc <msdos_long_to_short+0xa8> <== NEVER TAKEN
4001708c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40017090: 80 a0 60 20 cmp %g1, 0x20
40017094: 22 80 00 0e be,a 400170cc <msdos_long_to_short+0xa8>
40017098: 84 00 a0 01 inc %g2
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
4001709c: 03 10 00 b0 sethi %hi(0x4002c000), %g1
400170a0: c2 00 61 14 ld [ %g1 + 0x114 ], %g1 ! 4002c114 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400170a4: 2d 10 00 ad sethi %hi(0x4002b400), %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400170a8: 2f 10 00 ad sethi %hi(0x4002b400), %l7
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
400170ac: c2 27 bf fc st %g1, [ %fp + -4 ]
400170b0: b8 10 20 00 clr %i4
400170b4: a2 10 3f ff mov -1, %l1
400170b8: a4 10 20 00 clr %l2
400170bc: a6 10 20 00 clr %l3
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400170c0: ac 15 a2 b0 or %l6, 0x2b0, %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400170c4: 10 80 00 45 b 400171d8 <msdos_long_to_short+0x1b4>
400170c8: ae 15 e2 b8 or %l7, 0x2b8, %l7
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
400170cc: 80 a0 80 19 cmp %g2, %i1
400170d0: 26 bf ff ed bl,a 40017084 <msdos_long_to_short+0x60> <== ALWAYS TAKEN
400170d4: c2 4e 00 02 ldsb [ %i0 + %g2 ], %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
400170d8: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
400170dc: 12 bf ff f0 bne 4001709c <msdos_long_to_short+0x78> <== NOT EXECUTED
400170e0: 82 10 20 00 clr %g1 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
400170e4: 81 c7 e0 08 ret <== NOT EXECUTED
400170e8: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
400170ec: 80 a0 00 01 cmp %g0, %g1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400170f0: 90 10 00 16 mov %l6, %o0
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
400170f4: a8 60 3f ff subx %g0, -1, %l4
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400170f8: 92 10 00 1b mov %i3, %o1
400170fc: 40 00 14 1a call 4001c164 <strchr>
40017100: aa 10 00 14 mov %l4, %l5
40017104: 80 a2 20 00 cmp %o0, 0
40017108: 12 80 00 12 bne 40017150 <msdos_long_to_short+0x12c>
4001710c: ba 10 20 02 mov 2, %i5
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
40017110: 80 8d 20 ff btst 0xff, %l4
40017114: 12 80 00 0e bne 4001714c <msdos_long_to_short+0x128>
40017118: c2 07 bf fc ld [ %fp + -4 ], %g1
4001711c: 84 0c 20 ff and %l0, 0xff, %g2
40017120: 84 00 40 02 add %g1, %g2, %g2
40017124: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
40017128: 80 88 a0 07 btst 7, %g2
4001712c: 12 80 00 09 bne 40017150 <msdos_long_to_short+0x12c>
40017130: ba 10 20 01 mov 1, %i5
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
40017134: 90 10 00 17 mov %l7, %o0
40017138: 40 00 14 0b call 4001c164 <strchr>
4001713c: 92 10 00 1b mov %i3, %o1
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
40017140: 80 a0 00 08 cmp %g0, %o0
40017144: 10 80 00 03 b 40017150 <msdos_long_to_short+0x12c>
40017148: ba 40 20 00 addx %g0, 0, %i5
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
4001714c: ba 10 20 01 mov 1, %i5
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
40017150: 80 8f 60 01 btst 1, %i5
40017154: 02 80 00 2f be 40017210 <msdos_long_to_short+0x1ec>
40017158: 80 a4 7f ff cmp %l1, -1
return type;
if (dot_at >= 0)
4001715c: 02 80 00 0a be 40017184 <msdos_long_to_short+0x160>
40017160: 80 8d 60 ff btst 0xff, %l5
{
if (is_dot || ((count - dot_at) > 3))
40017164: 32 80 00 2e bne,a 4001721c <msdos_long_to_short+0x1f8>
40017168: ba 10 20 02 mov 2, %i5
4001716c: 82 27 00 11 sub %i4, %l1, %g1
40017170: 80 a0 60 03 cmp %g1, 3
40017174: 24 80 00 0d ble,a 400171a8 <msdos_long_to_short+0x184> <== ALWAYS TAKEN
40017178: 82 04 3f bf add %l0, -65, %g1
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
4001717c: 10 80 00 28 b 4001721c <msdos_long_to_short+0x1f8> <== NOT EXECUTED
40017180: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
40017184: 80 a5 20 00 cmp %l4, 0
40017188: 12 80 00 05 bne 4001719c <msdos_long_to_short+0x178>
4001718c: 80 8d 60 ff btst 0xff, %l5
40017190: 80 a7 20 08 cmp %i4, 8
40017194: 02 80 00 28 be 40017234 <msdos_long_to_short+0x210>
40017198: 80 8d 60 ff btst 0xff, %l5
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
4001719c: 32 80 00 0e bne,a 400171d4 <msdos_long_to_short+0x1b0>
400171a0: a2 10 00 1c mov %i4, %l1
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
400171a4: 82 04 3f bf add %l0, -65, %g1
400171a8: 82 08 60 ff and %g1, 0xff, %g1
400171ac: 80 a0 60 19 cmp %g1, 0x19
400171b0: 28 80 00 09 bleu,a 400171d4 <msdos_long_to_short+0x1b0>
400171b4: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
400171b8: a0 04 3f 9f add %l0, -97, %l0
400171bc: a0 0c 20 ff and %l0, 0xff, %l0
400171c0: 80 a4 20 19 cmp %l0, 0x19
400171c4: 28 80 00 04 bleu,a 400171d4 <msdos_long_to_short+0x1b0>
400171c8: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
400171cc: 10 80 00 03 b 400171d8 <msdos_long_to_short+0x1b4>
400171d0: b8 07 20 01 inc %i4
400171d4: b8 07 20 01 inc %i4
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
400171d8: f6 4e 00 1c ldsb [ %i0 + %i4 ], %i3
400171dc: 80 a6 e0 00 cmp %i3, 0
400171e0: 02 80 00 05 be 400171f4 <msdos_long_to_short+0x1d0>
400171e4: e0 0e 00 1c ldub [ %i0 + %i4 ], %l0
400171e8: 80 a7 00 19 cmp %i4, %i1
400171ec: 06 bf ff c0 bl 400170ec <msdos_long_to_short+0xc8>
400171f0: 82 1e e0 2e xor %i3, 0x2e, %g1
count++;
name++;
}
if (lowercase && uppercase)
400171f4: 80 8c e0 ff btst 0xff, %l3
400171f8: 02 80 00 11 be 4001723c <msdos_long_to_short+0x218>
400171fc: 80 8c a0 ff btst 0xff, %l2
40017200: 22 80 00 07 be,a 4001721c <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
40017204: ba 10 20 01 mov 1, %i5
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
40017208: 10 80 00 05 b 4001721c <msdos_long_to_short+0x1f8> <== NOT EXECUTED
4001720c: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
40017210: 82 97 60 00 orcc %i5, 0, %g1
40017214: 22 80 00 0d be,a 40017248 <msdos_long_to_short+0x224> <== NEVER TAKEN
40017218: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
4001721c: 90 10 00 18 mov %i0, %o0
40017220: 92 10 00 19 mov %i1, %o1
40017224: 40 00 0a 88 call 40019c44 <msdos_filename_unix2dos>
40017228: 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;
4001722c: 10 80 00 06 b 40017244 <msdos_long_to_short+0x220>
40017230: 82 10 00 1d mov %i5, %g1
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
40017234: 10 bf ff fa b 4001721c <msdos_long_to_short+0x1f8>
40017238: ba 10 20 02 mov 2, %i5
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
4001723c: 10 bf ff f8 b 4001721c <msdos_long_to_short+0x1f8>
40017240: ba 10 20 01 mov 1, %i5
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
40017244: b0 10 00 01 mov %g1, %i0
40017248: 81 c7 e0 08 ret
4001724c: 81 e8 00 00 restore
4000df0c <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000df0c: 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))
4000df10: 05 00 00 3c sethi %hi(0xf000), %g2
4000df14: 03 00 00 10 sethi %hi(0x4000), %g1
4000df18: 84 0e c0 02 and %i3, %g2, %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000df1c: 88 10 00 19 mov %i1, %g4
4000df20: 86 10 00 1a mov %i2, %g3
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4000df24: 80 a0 80 01 cmp %g2, %g1
4000df28: 02 80 00 07 be 4000df44 <msdos_mknod+0x38>
4000df2c: b8 10 00 1b mov %i3, %i4
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
4000df30: 3b 00 00 20 sethi %hi(0x8000), %i5
4000df34: 80 a0 80 1d cmp %g2, %i5
4000df38: 02 80 00 04 be 4000df48 <msdos_mknod+0x3c> <== ALWAYS TAKEN
4000df3c: b2 10 20 04 mov 4, %i1
4000df40: 30 80 00 06 b,a 4000df58 <msdos_mknod+0x4c> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
4000df44: 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);
4000df48: b4 10 00 04 mov %g4, %i2
4000df4c: b6 10 00 03 mov %g3, %i3
4000df50: 40 00 22 d3 call 40016a9c <msdos_creat_node>
4000df54: 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);
4000df58: 40 00 32 5d call 4001a8cc <__errno> <== NOT EXECUTED
4000df5c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000df60: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000df64: 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;
}
4000df68: 81 c7 e0 08 ret <== NOT EXECUTED
4000df6c: 81 e8 00 00 restore <== NOT EXECUTED
4000df7c <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
)
{
4000df7c: 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;
4000df80: 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,
4000df84: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000df88: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000df8c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000df90: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000df94: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
4000df98: 40 00 22 c1 call 40016a9c <msdos_creat_node> <== NOT EXECUTED
4000df9c: 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)
4000dfa0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000dfa4: 12 80 00 05 bne 4000dfb8 <msdos_rename+0x3c> <== NOT EXECUTED
4000dfa8: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4000dfac: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
4000dfb0: 40 00 25 2e call 40017468 <msdos_set_first_char4file_name><== NOT EXECUTED
4000dfb4: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
4000dfb8: 81 c7 e0 08 ret <== NOT EXECUTED
4000dfbc: 81 e8 00 00 restore <== NOT EXECUTED
4000dfc0 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
4000dfc0: 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;
4000dfc4: 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;
4000dfc8: 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)
4000dfcc: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000dfd0: 80 a0 a0 00 cmp %g2, 0
4000dfd4: 12 80 00 19 bne 4000e038 <msdos_rmnod+0x78>
4000dfd8: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
4000dfdc: 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);
4000dfe0: 92 10 00 1d mov %i5, %o1
4000dfe4: 40 00 25 6e call 4001759c <msdos_dir_is_empty>
4000dfe8: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
4000dfec: b0 92 20 00 orcc %o0, 0, %i0
4000dff0: 12 80 00 1a bne 4000e058 <msdos_rmnod+0x98> <== NEVER TAKEN
4000dff4: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
4000dff8: 80 a0 60 00 cmp %g1, 0
4000dffc: 32 80 00 06 bne,a 4000e014 <msdos_rmnod+0x54>
4000e000: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
4000e004: 40 00 32 32 call 4001a8cc <__errno>
4000e008: 01 00 00 00 nop
4000e00c: 10 80 00 08 b 4000e02c <msdos_rmnod+0x6c>
4000e010: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
4000e014: 80 a0 60 01 cmp %g1, 1
4000e018: 28 80 00 08 bleu,a 4000e038 <msdos_rmnod+0x78> <== ALWAYS TAKEN
4000e01c: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
4000e020: 40 00 32 2b call 4001a8cc <__errno> <== NOT EXECUTED
4000e024: 01 00 00 00 nop <== NOT EXECUTED
4000e028: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
4000e02c: c2 22 00 00 st %g1, [ %o0 ]
4000e030: 81 c7 e0 08 ret
4000e034: 91 e8 3f ff restore %g0, -1, %o0
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
4000e038: 92 07 60 20 add %i5, 0x20, %o1
4000e03c: 40 00 25 0b call 40017468 <msdos_set_first_char4file_name>
4000e040: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
4000e044: b0 92 20 00 orcc %o0, 0, %i0
4000e048: 12 80 00 04 bne 4000e058 <msdos_rmnod+0x98> <== NEVER TAKEN
4000e04c: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
4000e050: 40 00 10 1c call 400120c0 <fat_file_mark_removed>
4000e054: 92 10 00 1d mov %i5, %o1
return rc;
}
4000e058: 81 c7 e0 08 ret
4000e05c: 81 e8 00 00 restore
40017250 <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
)
{
40017250: 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);
40017254: 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;
40017258: 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);
4001725c: 94 07 bf fc add %fp, -4, %o2
40017260: 40 00 09 de call 400199d8 <msdos_date_unix2dos>
40017264: 92 07 bf fe add %fp, -2, %o1
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40017268: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
4001726c: 7f ff ff 60 call 40016fec <fat_cluster_num_to_sector_num>
40017270: 90 10 00 1d mov %i5, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40017274: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40017278: f8 17 40 00 lduh [ %i5 ], %i4
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
4001727c: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40017280: b8 07 3f ff add %i4, -1, %i4
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40017284: b7 30 40 1b srl %g1, %i3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40017288: b8 0f 00 01 and %i4, %g1, %i4
time_val = CT_LE_W(time_val);
4001728c: 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);
40017290: b6 02 00 1b add %o0, %i3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
40017294: 83 28 60 10 sll %g1, 0x10, %g1
40017298: 85 30 60 08 srl %g1, 8, %g2
4001729c: 83 30 60 18 srl %g1, 0x18, %g1
400172a0: 82 10 80 01 or %g2, %g1, %g1
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
400172a4: 92 10 00 1b mov %i3, %o1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
400172a8: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
400172ac: 94 07 20 16 add %i4, 0x16, %o2
400172b0: 96 10 20 02 mov 2, %o3
400172b4: 98 07 bf fc add %fp, -4, %o4
400172b8: 7f ff ec a7 call 40012554 <fat_sector_write>
400172bc: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
400172c0: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400172c4: 92 10 00 1b mov %i3, %o1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
400172c8: 83 28 60 10 sll %g1, 0x10, %g1
400172cc: 85 30 60 08 srl %g1, 8, %g2
400172d0: 83 30 60 18 srl %g1, 0x18, %g1
400172d4: 82 10 80 01 or %g2, %g1, %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400172d8: 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);
400172dc: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400172e0: 96 10 20 02 mov 2, %o3
400172e4: 98 07 bf fe add %fp, -2, %o4
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
400172e8: b4 10 00 08 mov %o0, %i2
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400172ec: 7f ff ec 9a call 40012554 <fat_sector_write>
400172f0: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
400172f4: 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,
400172f8: b2 10 00 08 mov %o0, %i1
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
400172fc: 94 07 20 12 add %i4, 0x12, %o2
40017300: 90 10 00 1d mov %i5, %o0
40017304: 96 10 20 02 mov 2, %o3
40017308: 7f ff ec 93 call 40012554 <fat_sector_write>
4001730c: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
40017310: 80 a6 60 00 cmp %i1, 0
40017314: 06 80 00 04 bl 40017324 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
40017318: 80 a6 a0 00 cmp %i2, 0
4001731c: 16 80 00 04 bge 4001732c <msdos_set_dir_wrt_time_and_date+0xdc><== ALWAYS TAKEN
40017320: 80 a2 20 00 cmp %o0, 0
return -1;
40017324: 81 c7 e0 08 ret <== NOT EXECUTED
40017328: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
4001732c: 06 bf ff fe bl 40017324 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
40017330: 01 00 00 00 nop
return -1;
return RC_OK;
}
40017334: 81 c7 e0 08 ret
40017338: 91 e8 20 00 restore %g0, 0, %o0
40017468 <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
)
{
40017468: 9d e3 bf 90 save %sp, -112, %sp
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
4001746c: c2 06 60 08 ld [ %i1 + 8 ], %g1
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40017470: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
40017474: c2 27 bf f0 st %g1, [ %fp + -16 ]
40017478: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fat_pos_t end = dir_pos->sname;
4001747c: 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;
40017480: c2 27 bf f4 st %g1, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
40017484: c2 06 60 04 ld [ %i1 + 4 ], %g1
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
40017488: f4 2f a0 4c stb %i2, [ %fp + 0x4c ]
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
4001748c: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40017490: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40017494: 80 a7 00 01 cmp %i4, %g1
40017498: 12 80 00 08 bne 400174b8 <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
4001749c: f8 27 bf f8 st %i4, [ %fp + -8 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
400174a0: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
400174a4: 80 88 60 03 btst 3, %g1
400174a8: 22 80 00 05 be,a 400174bc <msdos_set_first_char4file_name+0x54><== NEVER TAKEN
400174ac: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
400174b0: 10 80 00 03 b 400174bc <msdos_set_first_char4file_name+0x54>
400174b4: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
else
dir_block_size = fs_info->fat.vol.bpc;
400174b8: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
400174bc: c2 06 60 08 ld [ %i1 + 8 ], %g1
400174c0: 80 a0 7f ff cmp %g1, -1
400174c4: 12 80 00 07 bne 400174e0 <msdos_set_first_char4file_name+0x78>
400174c8: d2 07 bf f0 ld [ %fp + -16 ], %o1
start = dir_pos->sname;
400174cc: c2 06 40 00 ld [ %i1 ], %g1
400174d0: c2 27 bf f0 st %g1, [ %fp + -16 ]
400174d4: c2 06 60 04 ld [ %i1 + 4 ], %g1
400174d8: c2 27 bf f4 st %g1, [ %fp + -12 ]
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
400174dc: d2 07 bf f0 ld [ %fp + -16 ], %o1
400174e0: 7f ff fe c3 call 40016fec <fat_cluster_num_to_sector_num>
400174e4: 90 10 00 1d mov %i5, %o0
(start.ofs >> fs_info->fat.vol.sec_log2));
400174e8: c2 07 bf f4 ld [ %fp + -12 ], %g1
400174ec: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
400174f0: d4 17 40 00 lduh [ %i5 ], %o2
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
400174f4: 93 30 40 09 srl %g1, %o1, %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
400174f8: 94 02 bf ff add %o2, -1, %o2
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
400174fc: 92 02 00 09 add %o0, %o1, %o1
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40017500: 94 0a 80 01 and %o2, %g1, %o2
40017504: 90 10 00 1d mov %i5, %o0
40017508: 96 10 20 01 mov 1, %o3
4001750c: 7f ff ec 12 call 40012554 <fat_sector_write>
40017510: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
40017514: 80 a2 20 00 cmp %o0, 0
40017518: 06 80 00 1e bl 40017590 <msdos_set_first_char4file_name+0x128><== NEVER TAKEN
4001751c: d2 07 bf f0 ld [ %fp + -16 ], %o1
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
40017520: 80 a2 40 1c cmp %o1, %i4
40017524: 12 80 00 08 bne 40017544 <msdos_set_first_char4file_name+0xdc><== NEVER TAKEN
40017528: c2 07 bf f4 ld [ %fp + -12 ], %g1
4001752c: c4 07 bf fc ld [ %fp + -4 ], %g2
40017530: 80 a0 40 02 cmp %g1, %g2
40017534: 12 80 00 05 bne 40017548 <msdos_set_first_char4file_name+0xe0>
40017538: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
4001753c: 81 c7 e0 08 ret
40017540: 91 e8 20 00 restore %g0, 0, %o0
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40017544: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
40017548: 80 a0 40 1b cmp %g1, %i3
4001754c: 0a bf ff e4 bcs 400174dc <msdos_set_first_char4file_name+0x74><== ALWAYS TAKEN
40017550: c2 27 bf f4 st %g1, [ %fp + -12 ]
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40017554: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
40017558: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
4001755c: 12 80 00 06 bne 40017574 <msdos_set_first_char4file_name+0x10c><== NOT EXECUTED
40017560: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
40017564: 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) &&
40017568: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
4001756c: 12 bf ff f4 bne 4001753c <msdos_set_first_char4file_name+0xd4><== NOT EXECUTED
40017570: 01 00 00 00 nop <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
40017574: 40 00 04 e9 call 40018918 <fat_get_fat_cluster> <== NOT EXECUTED
40017578: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
4001757c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40017580: 12 80 00 05 bne 40017594 <msdos_set_first_char4file_name+0x12c><== NOT EXECUTED
40017584: 01 00 00 00 nop <== NOT EXECUTED
return rc;
start.ofs = 0;
40017588: 10 bf ff d5 b 400174dc <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
4001758c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
if (ret < 0)
return -1;
40017590: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
40017594: 81 c7 e0 08 ret <== NOT EXECUTED
40017598: 81 e8 00 00 restore <== NOT EXECUTED
4001733c <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
)
{
4001733c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40017340: fa 06 20 08 ld [ %i0 + 8 ], %i5
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40017344: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
40017348: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t le_cl_hi = 0;
4001734c: c0 37 bf fe clrh [ %fp + -2 ]
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40017350: 7f ff ff 27 call 40016fec <fat_cluster_num_to_sector_num>
40017354: 90 10 00 1d mov %i5, %o0
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
40017358: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
4001735c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40017360: 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);
40017364: f4 0f 60 02 ldub [ %i5 + 2 ], %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40017368: 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);
4001736c: b5 30 40 1a srl %g1, %i2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40017370: b6 0e c0 01 and %i3, %g1, %i3
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40017374: 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));
40017378: 83 2f 20 10 sll %i4, 0x10, %g1
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
4001737c: b2 16 63 ff or %i1, 0x3ff, %i1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40017380: 83 30 60 18 srl %g1, 0x18, %g1
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40017384: 84 0f 00 19 and %i4, %i1, %g2
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40017388: 85 28 a0 08 sll %g2, 8, %g2
4001738c: 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);
40017390: b4 02 00 1a add %o0, %i2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40017394: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec,
40017398: 92 10 00 1a mov %i2, %o1
4001739c: 94 06 e0 1a add %i3, 0x1a, %o2
400173a0: 96 10 20 02 mov 2, %o3
400173a4: 98 07 bf fc add %fp, -4, %o4
400173a8: 7f ff ec 6b call 40012554 <fat_sector_write>
400173ac: 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));
400173b0: 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,
400173b4: a0 10 00 08 mov %o0, %l0
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
400173b8: 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,
400173bc: 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));
400173c0: b3 2e 60 08 sll %i1, 8, %i1
400173c4: b9 37 20 08 srl %i4, 8, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
400173c8: 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));
400173cc: b8 16 40 1c or %i1, %i4, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
400173d0: 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));
400173d4: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec,
400173d8: 96 10 20 02 mov 2, %o3
400173dc: 7f ff ec 5e call 40012554 <fat_sector_write>
400173e0: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
400173e4: 80 a2 20 00 cmp %o0, 0
400173e8: 06 80 00 04 bl 400173f8 <msdos_set_first_cluster_num+0xbc><== NEVER TAKEN
400173ec: 80 a4 20 00 cmp %l0, 0
400173f0: 16 80 00 03 bge 400173fc <msdos_set_first_cluster_num+0xc0><== ALWAYS TAKEN
400173f4: b0 10 20 00 clr %i0
return -1;
400173f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
400173fc: 81 c7 e0 08 ret
40017400: 81 e8 00 00 restore
4000cca8 <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 )
{
4000cca8: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
4000ccac: 80 a6 20 00 cmp %i0, 0
4000ccb0: 02 80 00 07 be 4000cccc <msdos_set_sectors_per_cluster_from_request+0x24>
4000ccb4: ba 10 20 80 mov 0x80, %i5
4000ccb8: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000ccbc: 80 a0 60 00 cmp %g1, 0
4000ccc0: 32 80 00 03 bne,a 4000cccc <msdos_set_sectors_per_cluster_from_request+0x24>
4000ccc4: 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 )
{
4000ccc8: ba 10 20 80 mov 0x80, %i5
4000cccc: b0 10 3f ff mov -1, %i0
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for ( onebit = 128; onebit >= 1; onebit = onebit >> 1 ) {
if ( fmt_params->sectors_per_cluster >= onebit ) {
4000ccd0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000ccd4: 80 a0 40 1d cmp %g1, %i5
4000ccd8: 2a 80 00 0c bcs,a 4000cd08 <msdos_set_sectors_per_cluster_from_request+0x60>
4000ccdc: bb 37 60 01 srl %i5, 1, %i5
fmt_params->sectors_per_cluster = onebit;
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
4000cce0: 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;
4000cce4: fa 26 60 0c st %i5, [ %i1 + 0xc ]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
4000cce8: 7f ff d6 94 call 40002738 <.udiv>
4000ccec: 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
4000ccf0: 80 a7 40 08 cmp %i5, %o0
4000ccf4: 18 80 00 05 bgu 4000cd08 <msdos_set_sectors_per_cluster_from_request+0x60><== NEVER TAKEN
4000ccf8: bb 37 60 01 srl %i5, 1, %i5
<= 32768L / fmt_params->bytes_per_sector ) {
/* value is small enough so this value is ok */
onebit = 1;
4000ccfc: ba 10 20 01 mov 1, %i5
ret_val = 0;
4000cd00: b0 10 20 00 clr %i0
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for ( onebit = 128; onebit >= 1; onebit = onebit >> 1 ) {
4000cd04: bb 37 60 01 srl %i5, 1, %i5
4000cd08: 80 a7 60 00 cmp %i5, 0
4000cd0c: 32 bf ff f2 bne,a 4000ccd4 <msdos_set_sectors_per_cluster_from_request+0x2c>
4000cd10: c2 06 60 0c ld [ %i1 + 0xc ], %g1
ret_val = 0;
}
}
}
if (ret_val != 0) {
4000cd14: 80 a6 20 00 cmp %i0, 0
4000cd18: 02 80 00 06 be 4000cd30 <msdos_set_sectors_per_cluster_from_request+0x88><== ALWAYS TAKEN
4000cd1c: 01 00 00 00 nop
errno = EINVAL;
4000cd20: 40 00 36 eb call 4001a8cc <__errno> <== NOT EXECUTED
4000cd24: 01 00 00 00 nop <== NOT EXECUTED
4000cd28: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
4000cd2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return ret_val;
}
4000cd30: 81 c7 e0 08 ret
4000cd34: 81 e8 00 00 restore
4001878c <msdos_sync>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
4001878c: 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;
40018790: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
40018794: 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;
40018798: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001879c: 94 10 20 00 clr %o2
400187a0: 7f ff c1 f1 call 40008f64 <rtems_semaphore_obtain>
400187a4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
400187a8: 80 a2 20 00 cmp %o0, 0
400187ac: 02 80 00 08 be 400187cc <msdos_sync+0x40> <== ALWAYS TAKEN
400187b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
400187b4: 40 00 08 46 call 4001a8cc <__errno> <== NOT EXECUTED
400187b8: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400187bc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400187c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400187c4: 81 c7 e0 08 ret <== NOT EXECUTED
400187c8: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_sync(&fs_info->fat);
400187cc: 7f ff ea 0b call 40012ff8 <fat_sync>
400187d0: 90 10 00 1d mov %i5, %o0
400187d4: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
400187d8: 7f ff c2 2c call 40009088 <rtems_semaphore_release>
400187dc: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
400187e0: 81 c7 e0 08 ret
400187e4: 81 e8 00 00 restore
4000dcf0 <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000dcf0: 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);
4000dcf4: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000dcf8: 7f ff ec e4 call 40009088 <rtems_semaphore_release>
4000dcfc: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
if (sc != RTEMS_SUCCESSFUL) {
4000dd00: 80 a2 20 00 cmp %o0, 0
4000dd04: 02 80 00 04 be 4000dd14 <msdos_unlock+0x24> <== ALWAYS TAKEN
4000dd08: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
4000dd0c: 7f ff ee 6f call 400096c8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000dd10: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
4000dd14: 81 c7 e0 08 ret
4000dd18: 81 e8 00 00 restore
40003af0 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
40003af0: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
40003af4: 03 10 00 76 sethi %hi(0x4001d800), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
40003af8: 80 a6 00 19 cmp %i0, %i1
40003afc: 02 80 00 03 be 40003b08 <newlib_delete_hook+0x18>
40003b00: fa 00 60 a8 ld [ %g1 + 0xa8 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
40003b04: fa 06 61 48 ld [ %i1 + 0x148 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
40003b08: 80 a7 60 00 cmp %i5, 0
40003b0c: 02 80 00 0b be 40003b38 <newlib_delete_hook+0x48> <== NEVER TAKEN
40003b10: 03 10 00 72 sethi %hi(0x4001c800), %g1
40003b14: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1 ! 4001cbf0 <_global_impure_ptr>
40003b18: 80 a7 40 01 cmp %i5, %g1
40003b1c: 02 80 00 07 be 40003b38 <newlib_delete_hook+0x48>
40003b20: 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);
40003b24: 90 10 00 1d mov %i5, %o0
40003b28: 40 00 2d de call 4000f2a0 <_fwalk>
40003b2c: 92 12 60 e4 or %o1, 0xe4, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
40003b30: 40 00 1b 44 call 4000a840 <_Workspace_Free>
40003b34: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
40003b38: 80 a6 00 19 cmp %i0, %i1
40003b3c: 12 80 00 04 bne 40003b4c <newlib_delete_hook+0x5c>
40003b40: c0 26 61 48 clr [ %i1 + 0x148 ]
_REENT = 0;
40003b44: 03 10 00 76 sethi %hi(0x4001d800), %g1
40003b48: c0 20 60 a8 clr [ %g1 + 0xa8 ] ! 4001d8a8 <_impure_ptr>
40003b4c: 81 c7 e0 08 ret
40003b50: 81 e8 00 00 restore
400038e4 <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
400038e4: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
400038e8: 40 00 2d 73 call 4000eeb4 <fileno>
400038ec: 90 10 00 18 mov %i0, %o0
400038f0: 80 a2 20 02 cmp %o0, 2
400038f4: 18 80 00 0e bgu 4000392c <newlib_free_buffers+0x48> <== NEVER TAKEN
400038f8: 01 00 00 00 nop
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
400038fc: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
40003900: 80 88 60 80 btst 0x80, %g1
40003904: 02 80 00 0c be 40003934 <newlib_free_buffers+0x50> <== ALWAYS TAKEN
40003908: 01 00 00 00 nop
free( fp->_bf._base );
4000390c: 7f ff fd b0 call 40002fcc <free> <== NOT EXECUTED
40003910: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
40003914: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40003918: 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;
4000391c: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40003920: 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;
40003924: 10 80 00 04 b 40003934 <newlib_free_buffers+0x50> <== NOT EXECUTED
40003928: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
4000392c: 40 00 2c a2 call 4000ebb4 <fclose> <== NOT EXECUTED
40003930: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
40003934: 81 c7 e0 08 ret
40003938: 91 e8 20 00 restore %g0, 0, %o0
40001ff0 <notify>:
}
void
notify (s)
char *s;
{
40001ff0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
40001ff4: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED
40001ff8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40001ffc: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
40002000: 40 00 66 8a call 4001ba28 <printf> <== NOT EXECUTED
40002004: 31 10 00 98 sethi %hi(0x40026000), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
40002008: 40 00 66 c9 call 4001bb2c <puts> <== NOT EXECUTED
4000200c: 91 ee 23 10 restore %i0, 0x310, %o0 <== NOT EXECUTED
40006558 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
40006558: 81 c3 e0 08 retl <== NOT EXECUTED
4000655c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006568 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40006568: 81 c3 e0 08 retl <== NOT EXECUTED
40006530 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
40006530: 81 c3 e0 08 retl <== NOT EXECUTED
40006534: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006550 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
40006550: 81 c3 e0 08 retl <== NOT EXECUTED
40006554: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006580 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
40006580: 81 c3 e0 08 retl <== NOT EXECUTED
40006584: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006588 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
40006588: 81 c3 e0 08 retl <== NOT EXECUTED
4000658c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006528 <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
40006528: 81 c3 e0 08 retl <== NOT EXECUTED
4000652c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
4000567c <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4000567c: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
40005680: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
40005684: 80 88 60 01 btst 1, %g1
40005688: 02 80 00 56 be 400057e0 <oproc+0x164> <== NEVER TAKEN
4000568c: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
40005690: 84 0e 20 ff and %i0, 0xff, %g2
40005694: 80 a0 a0 09 cmp %g2, 9
40005698: 22 80 00 2a be,a 40005740 <oproc+0xc4>
4000569c: c4 06 60 28 ld [ %i1 + 0x28 ], %g2
400056a0: 18 80 00 07 bgu 400056bc <oproc+0x40> <== ALWAYS TAKEN
400056a4: 80 a0 a0 0a cmp %g2, 0xa
400056a8: 80 a0 a0 08 cmp %g2, 8 <== NOT EXECUTED
400056ac: 12 80 00 36 bne 40005784 <oproc+0x108> <== NOT EXECUTED
400056b0: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
400056b4: 10 80 00 2f b 40005770 <oproc+0xf4> <== NOT EXECUTED
400056b8: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
400056bc: 02 80 00 06 be 400056d4 <oproc+0x58>
400056c0: 80 a0 a0 0d cmp %g2, 0xd
400056c4: 32 80 00 30 bne,a 40005784 <oproc+0x108> <== ALWAYS TAKEN
400056c8: 80 88 60 02 btst 2, %g1
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
400056cc: 10 80 00 0f b 40005708 <oproc+0x8c> <== NOT EXECUTED
400056d0: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
400056d4: 80 88 60 20 btst 0x20, %g1
400056d8: 32 80 00 02 bne,a 400056e0 <oproc+0x64> <== NEVER TAKEN
400056dc: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
400056e0: 80 88 60 04 btst 4, %g1
400056e4: 02 80 00 40 be 400057e4 <oproc+0x168> <== NEVER TAKEN
400056e8: 90 07 a0 44 add %fp, 0x44, %o0
rtems_termios_puts ("\r", 1, tty);
400056ec: 11 10 00 70 sethi %hi(0x4001c000), %o0
400056f0: 92 10 20 01 mov 1, %o1
400056f4: 90 12 22 80 or %o0, 0x280, %o0
400056f8: 7f ff ff 98 call 40005558 <rtems_termios_puts>
400056fc: 94 10 00 19 mov %i1, %o2
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
40005700: 10 80 00 38 b 400057e0 <oproc+0x164>
40005704: c0 26 60 28 clr [ %i1 + 0x28 ]
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
40005708: 02 80 00 06 be 40005720 <oproc+0xa4> <== NOT EXECUTED
4000570c: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40005710: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
40005714: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40005718: 02 80 00 36 be 400057f0 <oproc+0x174> <== NOT EXECUTED
4000571c: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
40005720: 22 80 00 30 be,a 400057e0 <oproc+0x164> <== NOT EXECUTED
40005724: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
40005728: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
4000572c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40005730: 02 80 00 2c be 400057e0 <oproc+0x164> <== NOT EXECUTED
40005734: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
40005738: 10 80 00 2a b 400057e0 <oproc+0x164> <== NOT EXECUTED
4000573c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
40005740: 92 10 20 08 mov 8, %o1
40005744: 86 08 a0 07 and %g2, 7, %g3
40005748: 92 22 40 03 sub %o1, %g3, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
4000574c: 07 00 00 06 sethi %hi(0x1800), %g3
40005750: 82 08 40 03 and %g1, %g3, %g1
40005754: 80 a0 40 03 cmp %g1, %g3
40005758: 82 00 80 09 add %g2, %o1, %g1
4000575c: 12 80 00 21 bne 400057e0 <oproc+0x164> <== NEVER TAKEN
40005760: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
40005764: 11 10 00 70 sethi %hi(0x4001c000), %o0
40005768: 10 80 00 20 b 400057e8 <oproc+0x16c>
4000576c: 90 12 22 88 or %o0, 0x288, %o0 ! 4001c288 <rtems_filesystem_default_pathconf+0x4c>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
40005770: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005774: 04 80 00 1b ble 400057e0 <oproc+0x164> <== NOT EXECUTED
40005778: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
if (!iscntrl(c))
tty->column++;
4000577c: 10 80 00 19 b 400057e0 <oproc+0x164> <== NOT EXECUTED
40005780: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
40005784: 02 80 00 0d be 400057b8 <oproc+0x13c> <== ALWAYS TAKEN
40005788: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1
c = toupper(c);
4000578c: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED
40005790: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 4001d8a0 <__ctype_ptr__><== NOT EXECUTED
40005794: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
40005798: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
4000579c: c2 08 60 01 ldub [ %g1 + 1 ], %g1 <== NOT EXECUTED
400057a0: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
400057a4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
400057a8: 22 80 00 02 be,a 400057b0 <oproc+0x134> <== NOT EXECUTED
400057ac: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
400057b0: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
400057b4: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1 <== NOT EXECUTED
400057b8: 05 10 00 76 sethi %hi(0x4001d800), %g2
400057bc: c4 00 a0 a0 ld [ %g2 + 0xa0 ], %g2 ! 4001d8a0 <__ctype_ptr__>
400057c0: 82 00 80 01 add %g2, %g1, %g1
400057c4: c2 08 60 01 ldub [ %g1 + 1 ], %g1
400057c8: 80 88 60 20 btst 0x20, %g1
400057cc: 12 80 00 06 bne 400057e4 <oproc+0x168> <== NEVER TAKEN
400057d0: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
400057d4: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
400057d8: 82 00 60 01 inc %g1
400057dc: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
400057e0: 90 07 a0 44 add %fp, 0x44, %o0
400057e4: 92 10 20 01 mov 1, %o1
400057e8: 7f ff ff 5c call 40005558 <rtems_termios_puts>
400057ec: 94 10 00 19 mov %i1, %o2
400057f0: 81 c7 e0 08 ret
400057f4: 81 e8 00 00 restore
40004200 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
40004200: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
40004204: 80 a6 20 00 cmp %i0, 0
40004208: 02 80 00 11 be 4000424c <partition_free+0x4c>
4000420c: 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));
40004210: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
40004214: 82 08 60 7f and %g1, 0x7f, %g1
40004218: 80 a0 60 05 cmp %g1, 5
4000421c: 22 80 00 04 be,a 4000422c <partition_free+0x2c> <== NEVER TAKEN
40004220: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
40004224: 40 00 03 84 call 40005034 <free>
40004228: 81 e8 00 00 restore
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
4000422c: 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]);
40004230: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
40004234: 7f ff ff f3 call 40004200 <partition_free> <== NOT EXECUTED
40004238: 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;
4000423c: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
40004240: 12 bf ff fc bne 40004230 <partition_free+0x30> <== NOT EXECUTED
40004244: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
40004248: 30 bf ff f7 b,a 40004224 <partition_free+0x24> <== NOT EXECUTED
4000424c: 81 c7 e0 08 ret
40004250: 81 e8 00 00 restore
40004538 <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)
{
40004538: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
4000453c: 92 10 20 00 clr %o1
40004540: 90 10 00 18 mov %i0, %o0
40004544: 40 00 06 54 call 40005e94 <open>
40004548: ba 10 20 19 mov 0x19, %i5
if (fd < 0)
4000454c: 80 a2 20 00 cmp %o0, 0
40004550: 06 80 00 6d bl 40004704 <partition_table_get+0x1cc> <== NEVER TAKEN
40004554: b8 10 00 08 mov %o0, %i4
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
40004558: 40 00 02 e1 call 400050dc <fstat>
4000455c: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
40004560: 80 a2 20 00 cmp %o0, 0
40004564: 12 80 00 66 bne 400046fc <partition_table_get+0x1c4> <== NEVER TAKEN
40004568: 90 06 60 08 add %i1, 8, %o0
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
4000456c: 92 10 00 18 mov %i0, %o1
40004570: 40 00 43 b5 call 40015444 <strncpy>
40004574: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
40004578: c4 1f bf d0 ldd [ %fp + -48 ], %g2
4000457c: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40004580: c4 07 bf f8 ld [ %fp + -8 ], %g2
40004584: 80 a0 a0 00 cmp %g2, 0
40004588: 02 80 00 03 be 40004594 <partition_table_get+0x5c> <== ALWAYS TAKEN
4000458c: 82 10 22 00 mov 0x200, %g1
40004590: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
40004594: 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;
40004598: 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);
4000459c: 90 10 00 1c mov %i4, %o0
400045a0: 92 10 20 00 clr %o1
400045a4: 94 10 20 00 clr %o2
400045a8: 96 10 20 00 clr %o3
400045ac: 40 00 03 bf call 400054a8 <lseek>
400045b0: ba 10 20 1b mov 0x1b, %i5
if (new_off != off) {
400045b4: 80 92 00 09 orcc %o0, %o1, %g0
400045b8: 12 80 00 09 bne 400045dc <partition_table_get+0xa4> <== NEVER TAKEN
400045bc: d0 07 bf b0 ld [ %fp + -80 ], %o0
400045c0: 90 10 00 1c mov %i4, %o0
400045c4: 92 10 20 00 clr %o1
400045c8: 7f ff ff 2e call 40004280 <get_sector.part.0>
400045cc: 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)
400045d0: ba 92 20 00 orcc %o0, 0, %i5
400045d4: 02 80 00 06 be 400045ec <partition_table_get+0xb4> <== ALWAYS TAKEN
400045d8: d0 07 bf b0 ld [ %fp + -80 ], %o0
{
if (sector)
400045dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400045e0: 02 80 00 47 be 400046fc <partition_table_get+0x1c4> <== NOT EXECUTED
400045e4: 01 00 00 00 nop <== NOT EXECUTED
400045e8: 30 80 00 19 b,a 4000464c <partition_table_get+0x114> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
400045ec: c4 0a 22 02 ldub [ %o0 + 0x202 ], %g2
400045f0: 80 a0 a0 55 cmp %g2, 0x55
400045f4: 12 80 00 06 bne 4000460c <partition_table_get+0xd4> <== NEVER TAKEN
400045f8: 82 10 20 00 clr %g1
400045fc: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
40004600: 82 18 60 aa xor %g1, 0xaa, %g1
40004604: 80 a0 00 01 cmp %g0, %g1
40004608: 82 60 3f ff subx %g0, -1, %g1
free(sector);
return rc;
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
4000460c: 80 a0 60 00 cmp %g1, 0
40004610: 32 80 00 05 bne,a 40004624 <partition_table_get+0xec> <== ALWAYS TAKEN
40004614: b0 02 21 c2 add %o0, 0x1c2, %i0
{
free(sector);
40004618: 40 00 02 87 call 40005034 <free> <== NOT EXECUTED
4000461c: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
40004620: 30 80 00 37 b,a 400046fc <partition_table_get+0x1c4> <== NOT EXECUTED
40004624: b4 10 00 19 mov %i1, %i2
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
40004628: b6 10 20 00 clr %i3
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
4000462c: 91 2e e0 04 sll %i3, 4, %o0
40004630: 92 07 bf b4 add %fp, -76, %o1
40004634: 7f ff ff 29 call 400042d8 <data_to_part_desc.part.1>
40004638: 90 06 00 08 add %i0, %o0, %o0
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
4000463c: ba 92 20 00 orcc %o0, 0, %i5
40004640: 02 80 00 06 be 40004658 <partition_table_get+0x120> <== ALWAYS TAKEN
40004644: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
40004648: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
4000464c: 40 00 02 7a call 40005034 <free> <== NOT EXECUTED
40004650: 01 00 00 00 nop <== NOT EXECUTED
40004654: 30 80 00 2a b,a 400046fc <partition_table_get+0x1c4> <== NOT EXECUTED
return rc;
}
if (part_desc != NULL)
40004658: 80 a0 60 00 cmp %g1, 0
4000465c: 02 80 00 0b be 40004688 <partition_table_get+0x150> <== NEVER TAKEN
40004660: 84 06 e0 01 add %i3, 1, %g2
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
40004664: c6 00 60 04 ld [ %g1 + 4 ], %g3
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
40004668: c4 28 60 02 stb %g2, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
4000466c: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
40004670: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
40004674: 84 00 c0 02 add %g3, %g2, %g2
40004678: 84 00 bf ff add %g2, -1, %g2
4000467c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
40004680: 10 80 00 03 b 4000468c <partition_table_get+0x154>
40004684: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
}
else
{
disk_desc->partitions[part_num] = NULL;
40004688: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
4000468c: b6 06 e0 01 inc %i3
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
40004690: 80 a6 e0 04 cmp %i3, 4
40004694: 12 bf ff e6 bne 4000462c <partition_table_get+0xf4>
40004698: b4 06 a0 04 add %i2, 4, %i2
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
4000469c: 40 00 02 66 call 40005034 <free>
400046a0: d0 07 bf b0 ld [ %fp + -80 ], %o0
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
400046a4: f6 26 60 24 st %i3, [ %i1 + 0x24 ]
400046a8: b6 10 20 00 clr %i3
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
400046ac: b4 06 40 1b add %i1, %i3, %i2
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
400046b0: d4 06 a0 28 ld [ %i2 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
400046b4: 80 a2 a0 00 cmp %o2, 0
400046b8: 02 80 00 0d be 400046ec <partition_table_get+0x1b4> <== NEVER TAKEN
400046bc: 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));
400046c0: 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))
400046c4: 82 08 60 7f and %g1, 0x7f, %g1
400046c8: 80 a0 60 05 cmp %g1, 5
400046cc: 32 80 00 09 bne,a 400046f0 <partition_table_get+0x1b8>
400046d0: b6 06 e0 04 add %i3, 4, %i3
{
read_extended_partition(fd, part_desc->start, part_desc);
400046d4: d2 02 a0 04 ld [ %o2 + 4 ], %o1
400046d8: 7f ff ff 31 call 4000439c <read_extended_partition>
400046dc: 90 10 00 1c mov %i4, %o0
free(part_desc);
400046e0: 40 00 02 55 call 40005034 <free>
400046e4: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
400046e8: c0 26 a0 28 clr [ %i2 + 0x28 ]
400046ec: b6 06 e0 04 add %i3, 4, %i3
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
400046f0: 80 a6 e0 10 cmp %i3, 0x10
400046f4: 12 bf ff ef bne 400046b0 <partition_table_get+0x178>
400046f8: b4 06 40 1b add %i1, %i3, %i2
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
400046fc: 40 00 02 2d call 40004fb0 <close>
40004700: 90 10 00 1c mov %i4, %o0
return rc;
}
40004704: 81 c7 e0 08 ret
40004708: 91 e8 00 1d restore %g0, %i5, %o0
400044c8 <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
400044c8: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
400044cc: 92 10 20 00 clr %o1
400044d0: 7f ff ff 6f call 4000428c <open>
400044d4: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
400044d8: 80 a2 3f ff cmp %o0, -1
400044dc: 02 80 00 09 be 40004500 <pathconf+0x38> <== ALWAYS TAKEN
400044e0: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
400044e4: 40 00 13 ac call 40009394 <fpathconf> <== NOT EXECUTED
400044e8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400044ec: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
400044f0: 40 00 13 7c call 400092e0 <close> <== NOT EXECUTED
400044f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
400044f8: 81 c7 e0 08 ret <== NOT EXECUTED
400044fc: 81 e8 00 00 restore <== NOT EXECUTED
}
40004500: 81 c7 e0 08 ret
40004504: 91 e8 3f ff restore %g0, -1, %o0
4000c2d0 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
4000c2d0: 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)
4000c2d4: 11 10 00 77 sethi %hi(0x4001dc00), %o0
4000c2d8: 92 10 21 ff mov 0x1ff, %o1
4000c2dc: 40 00 05 29 call 4000d780 <rtems_mkdir>
4000c2e0: 90 12 22 98 or %o0, 0x298, %o0
4000c2e4: 80 a2 20 00 cmp %o0, 0
4000c2e8: 12 80 00 47 bne 4000c404 <pipe_create+0x134>
4000c2ec: 03 00 00 19 sethi %hi(0x6400), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4000c2f0: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <PROM_START+0x666f>
4000c2f4: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c2f8: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000c2fc: d4 10 60 28 lduh [ %g1 + 0x28 ], %o2 ! 4001f028 <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);
4000c300: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
4000c304: 84 10 a1 70 or %g2, 0x170, %g2 ! 2f746d70 <RAM_SIZE+0x2f346d70>
4000c308: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
4000c30c: 86 10 e2 69 or %g3, 0x269, %g3 ! 2f2e6669 <RAM_SIZE+0x2eee6669>
4000c310: c4 3f bf f0 std %g2, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c314: 84 02 a0 01 add %o2, 1, %g2
4000c318: 90 07 bf fa add %fp, -6, %o0
4000c31c: c4 30 60 28 sth %g2, [ %g1 + 0x28 ]
4000c320: 95 2a a0 10 sll %o2, 0x10, %o2
4000c324: 13 10 00 77 sethi %hi(0x4001dc00), %o1
4000c328: 95 32 a0 10 srl %o2, 0x10, %o2
4000c32c: 40 00 11 f4 call 40010afc <sprintf>
4000c330: 92 12 62 a0 or %o1, 0x2a0, %o1
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4000c334: 90 07 bf f0 add %fp, -16, %o0
4000c338: 40 00 04 68 call 4000d4d8 <mkfifo>
4000c33c: 92 10 21 80 mov 0x180, %o1
4000c340: 80 a2 20 00 cmp %o0, 0
4000c344: 02 80 00 05 be 4000c358 <pipe_create+0x88> <== ALWAYS TAKEN
4000c348: 90 07 bf f0 add %fp, -16, %o0
if (errno != EEXIST){
4000c34c: 40 00 0f 1a call 4000ffb4 <__errno> <== NOT EXECUTED
4000c350: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000c354: 30 80 00 2d b,a 4000c408 <pipe_create+0x138> <== NOT EXECUTED
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
4000c358: 7f ff e0 13 call 400043a4 <open>
4000c35c: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
4000c360: 80 a2 20 00 cmp %o0, 0
4000c364: 16 80 00 06 bge 4000c37c <pipe_create+0xac>
4000c368: d0 26 00 00 st %o0, [ %i0 ]
err = errno;
4000c36c: 40 00 0f 12 call 4000ffb4 <__errno>
4000c370: 01 00 00 00 nop
4000c374: 10 80 00 1c b 4000c3e4 <pipe_create+0x114>
4000c378: fa 02 00 00 ld [ %o0 ], %i5
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
4000c37c: 03 10 00 7a sethi %hi(0x4001e800), %g1
4000c380: c4 00 60 24 ld [ %g1 + 0x24 ], %g2 ! 4001e824 <rtems_libio_number_iops>
4000c384: 80 a2 00 02 cmp %o0, %g2
4000c388: 1a 80 00 08 bcc 4000c3a8 <pipe_create+0xd8> <== NEVER TAKEN
4000c38c: 82 10 20 00 clr %g1
4000c390: 83 2a 20 03 sll %o0, 3, %g1
4000c394: 91 2a 20 06 sll %o0, 6, %o0
4000c398: 90 22 00 01 sub %o0, %g1, %o0
4000c39c: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000c3a0: c2 00 61 a4 ld [ %g1 + 0x1a4 ], %g1 ! 4001f1a4 <rtems_libio_iops>
4000c3a4: 82 00 40 08 add %g1, %o0, %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4000c3a8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000c3ac: 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;
4000c3b0: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000c3b4: 92 10 20 01 mov 1, %o1
4000c3b8: 7f ff df fb call 400043a4 <open>
4000c3bc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4000c3c0: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
4000c3c4: 80 a2 20 00 cmp %o0, 0
4000c3c8: 16 80 00 07 bge 4000c3e4 <pipe_create+0x114>
4000c3cc: ba 10 20 00 clr %i5
err = errno;
4000c3d0: 40 00 0e f9 call 4000ffb4 <__errno>
4000c3d4: 01 00 00 00 nop
4000c3d8: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
4000c3dc: 7f ff dc a6 call 40003674 <close>
4000c3e0: d0 06 00 00 ld [ %i0 ], %o0
}
unlink(fifopath);
4000c3e4: 7f ff eb 48 call 40007104 <unlink>
4000c3e8: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
4000c3ec: 80 a7 60 00 cmp %i5, 0
4000c3f0: 02 80 00 06 be 4000c408 <pipe_create+0x138>
4000c3f4: b0 10 20 00 clr %i0
rtems_set_errno_and_return_minus_one(err);
4000c3f8: 40 00 0e ef call 4000ffb4 <__errno>
4000c3fc: 01 00 00 00 nop
4000c400: fa 22 00 00 st %i5, [ %o0 ]
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
4000c404: b0 10 3f ff mov -1, %i0
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000c408: 81 c7 e0 08 ret
4000c40c: 81 e8 00 00 restore
4000d7f8 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4000d7f8: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
4000d7fc: 03 10 01 19 sethi %hi(0x40046400), %g1
4000d800: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <__end+0x22e7f>
4000d804: 80 a6 40 01 cmp %i1, %g1
4000d808: 12 80 00 11 bne 4000d84c <pipe_ioctl+0x54>
4000d80c: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
4000d810: 02 80 00 11 be 4000d854 <pipe_ioctl+0x5c>
4000d814: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
4000d818: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000d81c: 7f ff eb 39 call 40008500 <rtems_semaphore_obtain>
4000d820: 94 10 20 00 clr %o2
4000d824: 80 a2 20 00 cmp %o0, 0
4000d828: 12 80 00 0d bne 4000d85c <pipe_ioctl+0x64> <== NEVER TAKEN
4000d82c: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000d830: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
4000d834: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000d838: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
4000d83c: 7f ff eb 7a call 40008624 <rtems_semaphore_release>
4000d840: b0 10 20 00 clr %i0
return 0;
4000d844: 81 c7 e0 08 ret
4000d848: 81 e8 00 00 restore
}
return -EINVAL;
4000d84c: 81 c7 e0 08 ret
4000d850: 91 e8 3f ea restore %g0, -22, %o0
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4000d854: 81 c7 e0 08 ret
4000d858: 91 e8 3f f2 restore %g0, -14, %o0
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
4000d85c: 81 c7 e0 08 ret <== NOT EXECUTED
4000d860: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
4000d48c <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000d48c: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4000d490: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000d494: 92 10 20 00 clr %o1
4000d498: 94 10 20 00 clr %o2
4000d49c: 7f ff ec 19 call 40008500 <rtems_semaphore_obtain>
4000d4a0: ba 10 00 18 mov %i0, %i5
4000d4a4: 80 a2 20 00 cmp %o0, 0
4000d4a8: 32 80 00 5d bne,a 4000d61c <pipe_read+0x190> <== NEVER TAKEN
4000d4ac: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
4000d4b0: 10 80 00 4d b 4000d5e4 <pipe_read+0x158>
4000d4b4: b0 10 20 00 clr %i0
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4000d4b8: 80 a0 60 00 cmp %g1, 0
4000d4bc: 32 80 00 04 bne,a 4000d4cc <pipe_read+0x40>
4000d4c0: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4000d4c4: 10 80 00 4c b 4000d5f4 <pipe_read+0x168>
4000d4c8: b8 10 20 00 clr %i4
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000d4cc: 80 88 60 01 btst 1, %g1
4000d4d0: 32 80 00 49 bne,a 4000d5f4 <pipe_read+0x168>
4000d4d4: 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 ++;
4000d4d8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
4000d4dc: 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 ++;
4000d4e0: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000d4e4: 7f ff ec 50 call 40008624 <rtems_semaphore_release>
4000d4e8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
4000d4ec: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000d4f0: 40 00 05 43 call 4000e9fc <rtems_barrier_wait>
4000d4f4: 92 10 20 00 clr %o1
4000d4f8: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000d4fc: 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))
4000d500: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000d504: 92 10 20 00 clr %o1
4000d508: 94 10 20 00 clr %o2
4000d50c: 7f ff eb fd call 40008500 <rtems_semaphore_obtain>
4000d510: b8 0f 3f fc and %i4, -4, %i4
4000d514: 80 a2 20 00 cmp %o0, 0
4000d518: 12 80 00 3b bne 4000d604 <pipe_read+0x178> <== NEVER TAKEN
4000d51c: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4000d520: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000d524: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000d528: 12 80 00 33 bne 4000d5f4 <pipe_read+0x168> <== NEVER TAKEN
4000d52c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
4000d530: f8 07 60 0c ld [ %i5 + 0xc ], %i4
4000d534: 80 a7 20 00 cmp %i4, 0
4000d538: 22 bf ff e0 be,a 4000d4b8 <pipe_read+0x2c>
4000d53c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4000d540: 82 26 80 18 sub %i2, %i0, %g1
4000d544: 80 a7 00 01 cmp %i4, %g1
4000d548: 38 80 00 02 bgu,a 4000d550 <pipe_read+0xc4>
4000d54c: b8 10 00 01 mov %g1, %i4
chunk1 = pipe->Size - pipe->Start;
4000d550: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000d554: e0 07 60 04 ld [ %i5 + 4 ], %l0
4000d558: d2 07 40 00 ld [ %i5 ], %o1
4000d55c: a0 24 00 01 sub %l0, %g1, %l0
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000d560: 94 10 00 1c mov %i4, %o2
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
4000d564: 80 a7 00 10 cmp %i4, %l0
4000d568: 90 06 40 18 add %i1, %i0, %o0
4000d56c: 04 80 00 09 ble 4000d590 <pipe_read+0x104>
4000d570: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000d574: 40 00 10 54 call 400116c4 <memcpy>
4000d578: 94 10 00 10 mov %l0, %o2
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000d57c: 90 06 00 10 add %i0, %l0, %o0
4000d580: d2 07 40 00 ld [ %i5 ], %o1
4000d584: 90 06 40 08 add %i1, %o0, %o0
4000d588: 10 80 00 02 b 4000d590 <pipe_read+0x104>
4000d58c: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000d590: 40 00 10 4d call 400116c4 <memcpy>
4000d594: 01 00 00 00 nop
pipe->Start += chunk;
4000d598: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
4000d59c: d2 07 60 04 ld [ %i5 + 4 ], %o1
4000d5a0: 40 00 3f 72 call 4001d368 <.urem>
4000d5a4: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
4000d5a8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4000d5ac: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
4000d5b0: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4000d5b4: 80 a0 60 00 cmp %g1, 0
4000d5b8: 12 80 00 03 bne 4000d5c4 <pipe_read+0x138>
4000d5bc: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
4000d5c0: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
4000d5c4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000d5c8: 80 a0 60 00 cmp %g1, 0
4000d5cc: 22 80 00 06 be,a 4000d5e4 <pipe_read+0x158>
4000d5d0: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPWRITERS(pipe);
4000d5d4: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000d5d8: 40 00 04 f3 call 4000e9a4 <rtems_barrier_release>
4000d5dc: 92 07 bf fc add %fp, -4, %o1
read += chunk;
4000d5e0: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4000d5e4: 80 a6 00 1a cmp %i0, %i2
4000d5e8: 2a bf ff d3 bcs,a 4000d534 <pipe_read+0xa8>
4000d5ec: f8 07 60 0c ld [ %i5 + 0xc ], %i4
4000d5f0: b8 10 20 00 clr %i4
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4000d5f4: 7f ff ec 0c call 40008624 <rtems_semaphore_release>
4000d5f8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
4000d5fc: 10 80 00 04 b 4000d60c <pipe_read+0x180>
4000d600: 80 a6 20 00 cmp %i0, 0
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
4000d604: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
4000d608: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000d60c: 14 80 00 04 bg 4000d61c <pipe_read+0x190>
4000d610: 01 00 00 00 nop
return read;
return ret;
4000d614: 81 c7 e0 08 ret
4000d618: 91 e8 00 1c restore %g0, %i4, %o0
}
4000d61c: 81 c7 e0 08 ret
4000d620: 81 e8 00 00 restore
4000cf7c <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000cf7c: 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);
4000cf80: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4000cf84: 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)
4000cf88: 80 88 60 02 btst 2, %g1
4000cf8c: 02 80 00 05 be 4000cfa0 <pipe_release+0x24>
4000cf90: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
4000cf94: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000cf98: 84 00 bf ff add %g2, -1, %g2
4000cf9c: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000cfa0: 80 88 60 04 btst 4, %g1
4000cfa4: 02 80 00 05 be 4000cfb8 <pipe_release+0x3c>
4000cfa8: 01 00 00 00 nop
pipe->Writers --;
4000cfac: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000cfb0: 82 00 7f ff add %g1, -1, %g1
4000cfb4: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
4000cfb8: 7f ff ed 9b call 40008624 <rtems_semaphore_release>
4000cfbc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000cfc0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000cfc4: 80 a0 60 00 cmp %g1, 0
4000cfc8: 12 80 00 0d bne 4000cffc <pipe_release+0x80>
4000cfcc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000cfd0: 80 a0 60 00 cmp %g1, 0
4000cfd4: 12 80 00 06 bne 4000cfec <pipe_release+0x70>
4000cfd8: 80 a7 20 04 cmp %i4, 4
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
4000cfdc: 7f ff ff dd call 4000cf50 <pipe_free>
4000cfe0: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
4000cfe4: 10 80 00 0e b 4000d01c <pipe_release+0xa0>
4000cfe8: c0 26 00 00 clr [ %i0 ]
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000cfec: 02 80 00 05 be 4000d000 <pipe_release+0x84> <== NEVER TAKEN
4000cff0: 80 a0 60 00 cmp %g1, 0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4000cff4: 10 80 00 08 b 4000d014 <pipe_release+0x98>
4000cff8: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4000cffc: 80 a0 60 00 cmp %g1, 0
4000d000: 12 80 00 07 bne 4000d01c <pipe_release+0xa0> <== NEVER TAKEN
4000d004: 80 a7 20 02 cmp %i4, 2
4000d008: 02 80 00 06 be 4000d020 <pipe_release+0xa4> <== NEVER TAKEN
4000d00c: 03 10 00 8a sethi %hi(0x40022800), %g1
PIPE_WAKEUPREADERS(pipe);
4000d010: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000d014: 40 00 06 64 call 4000e9a4 <rtems_barrier_release>
4000d018: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000d01c: 03 10 00 8a sethi %hi(0x40022800), %g1
4000d020: 7f ff ed 81 call 40008624 <rtems_semaphore_release>
4000d024: d0 00 61 c8 ld [ %g1 + 0x1c8 ], %o0 ! 400229c8 <pipe_semaphore>
4000d028: 81 c7 e0 08 ret
4000d02c: 81 e8 00 00 restore
4000d624 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000d624: 9d e3 bf 98 save %sp, -104, %sp
4000d628: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000d62c: 80 a6 a0 00 cmp %i2, 0
4000d630: 02 80 00 70 be 4000d7f0 <pipe_write+0x1cc> <== NEVER TAKEN
4000d634: b0 10 20 00 clr %i0
return 0;
if (! PIPE_LOCK(pipe))
4000d638: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000d63c: 92 10 20 00 clr %o1
4000d640: 7f ff eb b0 call 40008500 <rtems_semaphore_obtain>
4000d644: 94 10 20 00 clr %o2
4000d648: 80 a2 20 00 cmp %o0, 0
4000d64c: 32 80 00 69 bne,a 4000d7f0 <pipe_write+0x1cc> <== NEVER TAKEN
4000d650: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
4000d654: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d658: 80 a0 60 00 cmp %g1, 0
4000d65c: 02 80 00 54 be 4000d7ac <pipe_write+0x188>
4000d660: b8 10 3f e0 mov -32, %i4
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4000d664: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000d668: 80 a6 80 01 cmp %i2, %g1
4000d66c: 18 80 00 03 bgu 4000d678 <pipe_write+0x54> <== NEVER TAKEN
4000d670: a2 10 20 01 mov 1, %l1
4000d674: a2 10 00 1a mov %i2, %l1
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
4000d678: 10 80 00 49 b 4000d79c <pipe_write+0x178>
4000d67c: b0 10 20 00 clr %i0
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
4000d680: 80 88 60 01 btst 1, %g1
4000d684: 32 80 00 4a bne,a 4000d7ac <pipe_write+0x188>
4000d688: 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 ++;
4000d68c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
4000d690: 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 ++;
4000d694: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000d698: 7f ff eb e3 call 40008624 <rtems_semaphore_release>
4000d69c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
4000d6a0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000d6a4: 40 00 04 d6 call 4000e9fc <rtems_barrier_wait>
4000d6a8: 92 10 20 00 clr %o1
4000d6ac: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000d6b0: 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))
4000d6b4: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000d6b8: 92 10 20 00 clr %o1
4000d6bc: 94 10 20 00 clr %o2
4000d6c0: 7f ff eb 90 call 40008500 <rtems_semaphore_obtain>
4000d6c4: b8 0f 3f fc and %i4, -4, %i4
4000d6c8: 80 a2 20 00 cmp %o0, 0
4000d6cc: 12 80 00 43 bne 4000d7d8 <pipe_write+0x1b4> <== NEVER TAKEN
4000d6d0: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4000d6d4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000d6d8: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000d6dc: 12 80 00 34 bne 4000d7ac <pipe_write+0x188> <== NEVER TAKEN
4000d6e0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
4000d6e4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d6e8: 80 a0 60 00 cmp %g1, 0
4000d6ec: 02 80 00 30 be 4000d7ac <pipe_write+0x188> <== NEVER TAKEN
4000d6f0: b8 10 3f e0 mov -32, %i4
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000d6f4: e0 07 60 04 ld [ %i5 + 4 ], %l0
4000d6f8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000d6fc: b8 24 00 01 sub %l0, %g1, %i4
4000d700: 80 a7 00 11 cmp %i4, %l1
4000d704: 2a bf ff df bcs,a 4000d680 <pipe_write+0x5c>
4000d708: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000d70c: 84 26 80 18 sub %i2, %i0, %g2
4000d710: 80 a7 00 02 cmp %i4, %g2
4000d714: 38 80 00 02 bgu,a 4000d71c <pipe_write+0xf8>
4000d718: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000d71c: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000d720: 92 10 00 10 mov %l0, %o1
4000d724: 40 00 3f 11 call 4001d368 <.urem>
4000d728: 90 00 40 08 add %g1, %o0, %o0
4000d72c: c2 07 40 00 ld [ %i5 ], %g1
4000d730: a0 24 00 08 sub %l0, %o0, %l0
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000d734: 94 10 00 1c mov %i4, %o2
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
4000d738: 80 a7 00 10 cmp %i4, %l0
4000d73c: 92 06 40 18 add %i1, %i0, %o1
4000d740: 04 80 00 09 ble 4000d764 <pipe_write+0x140>
4000d744: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000d748: 40 00 0f df call 400116c4 <memcpy>
4000d74c: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000d750: 92 04 00 18 add %l0, %i0, %o1
4000d754: d0 07 40 00 ld [ %i5 ], %o0
4000d758: 92 06 40 09 add %i1, %o1, %o1
4000d75c: 10 80 00 02 b 4000d764 <pipe_write+0x140>
4000d760: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000d764: 40 00 0f d8 call 400116c4 <memcpy>
4000d768: 01 00 00 00 nop
pipe->Length += chunk;
4000d76c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000d770: 82 00 40 1c add %g1, %i4, %g1
4000d774: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
4000d778: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000d77c: 80 a0 60 00 cmp %g1, 0
4000d780: 22 80 00 06 be,a 4000d798 <pipe_write+0x174>
4000d784: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPREADERS(pipe);
4000d788: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000d78c: 40 00 04 86 call 4000e9a4 <rtems_barrier_release>
4000d790: 92 07 bf fc add %fp, -4, %o1
written += chunk;
4000d794: b0 06 00 1c add %i0, %i4, %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
4000d798: a2 10 20 01 mov 1, %l1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
4000d79c: 80 a6 00 1a cmp %i0, %i2
4000d7a0: 2a bf ff d6 bcs,a 4000d6f8 <pipe_write+0xd4>
4000d7a4: e0 07 60 04 ld [ %i5 + 4 ], %l0
4000d7a8: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4000d7ac: 7f ff eb 9e call 40008624 <rtems_semaphore_release>
4000d7b0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
4000d7b4: 80 a7 3f e0 cmp %i4, -32
4000d7b8: 32 80 00 0a bne,a 4000d7e0 <pipe_write+0x1bc>
4000d7bc: 80 a6 20 00 cmp %i0, 0
kill(getpid(), SIGPIPE);
4000d7c0: 40 00 00 fe call 4000dbb8 <getpid>
4000d7c4: 01 00 00 00 nop
4000d7c8: 40 00 02 70 call 4000e188 <kill>
4000d7cc: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
4000d7d0: 10 80 00 04 b 4000d7e0 <pipe_write+0x1bc>
4000d7d4: 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;
4000d7d8: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000d7dc: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000d7e0: 14 80 00 04 bg 4000d7f0 <pipe_write+0x1cc>
4000d7e4: 01 00 00 00 nop
4000d7e8: 81 c7 e0 08 ret
4000d7ec: 91 e8 00 1c restore %g0, %i4, %o0
return written;
return ret;
}
4000d7f0: 81 c7 e0 08 ret
4000d7f4: 81 e8 00 00 restore
400081e8 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
400081e8: 05 10 00 94 sethi %hi(0x40025000), %g2
400081ec: 84 10 a0 90 or %g2, 0x90, %g2 ! 40025090 <rtems_malloc_statistics>
400081f0: c6 00 a0 08 ld [ %g2 + 8 ], %g3
400081f4: 86 00 e0 01 inc %g3
400081f8: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
400081fc: 84 02 7f ff add %o1, -1, %g2
40008200: 80 88 80 09 btst %g2, %o1
40008204: 12 80 00 07 bne 40008220 <posix_memalign+0x38> <== NEVER TAKEN
40008208: 80 a2 60 03 cmp %o1, 3
4000820c: 08 80 00 05 bleu 40008220 <posix_memalign+0x38>
40008210: 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 );
40008214: 82 13 c0 00 mov %o7, %g1
40008218: 40 00 00 85 call 4000842c <rtems_memalign>
4000821c: 9e 10 40 00 mov %g1, %o7
}
40008220: 81 c3 e0 08 retl
40008224: 90 10 20 16 mov 0x16, %o0
4000ba94 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4000ba94: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
4000ba98: 80 a0 60 00 cmp %g1, 0
4000ba9c: 02 80 00 0f be 4000bad8 <pthread_attr_setschedpolicy+0x44>
4000baa0: 90 10 20 16 mov 0x16, %o0
4000baa4: c4 00 40 00 ld [ %g1 ], %g2
4000baa8: 80 a0 a0 00 cmp %g2, 0
4000baac: 02 80 00 0b be 4000bad8 <pthread_attr_setschedpolicy+0x44>
4000bab0: 80 a2 60 04 cmp %o1, 4
return EINVAL;
switch ( policy ) {
4000bab4: 38 80 00 09 bgu,a 4000bad8 <pthread_attr_setschedpolicy+0x44>
4000bab8: 90 10 20 86 mov 0x86, %o0
4000babc: 84 10 20 01 mov 1, %g2
4000bac0: 85 28 80 09 sll %g2, %o1, %g2
4000bac4: 80 88 a0 17 btst 0x17, %g2
4000bac8: 22 80 00 04 be,a 4000bad8 <pthread_attr_setschedpolicy+0x44><== NEVER TAKEN
4000bacc: 90 10 20 86 mov 0x86, %o0 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4000bad0: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
4000bad4: 90 10 20 00 clr %o0
return 0;
default:
return ENOTSUP;
}
}
4000bad8: 81 c3 e0 08 retl
40006eec <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
40006eec: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
40006ef0: 80 a6 20 00 cmp %i0, 0
40006ef4: 12 80 00 04 bne 40006f04 <pthread_barrier_init+0x18>
40006ef8: 80 a6 a0 00 cmp %i2, 0
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
40006efc: 81 c7 e0 08 ret
40006f00: 91 e8 20 16 restore %g0, 0x16, %o0
* Error check parameters
*/
if ( !barrier )
return EINVAL;
if ( count == 0 )
40006f04: 22 80 00 1e be,a 40006f7c <pthread_barrier_init+0x90>
40006f08: b0 10 20 16 mov 0x16, %i0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
40006f0c: 80 a6 60 00 cmp %i1, 0
40006f10: 32 80 00 06 bne,a 40006f28 <pthread_barrier_init+0x3c>
40006f14: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
40006f18: 90 07 bf f8 add %fp, -8, %o0
40006f1c: 7f ff ff bc call 40006e0c <pthread_barrierattr_init>
40006f20: 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 )
40006f24: c2 06 40 00 ld [ %i1 ], %g1
40006f28: 80 a0 60 00 cmp %g1, 0
40006f2c: 22 80 00 14 be,a 40006f7c <pthread_barrier_init+0x90>
40006f30: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
40006f34: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006f38: 80 a0 60 00 cmp %g1, 0
40006f3c: 32 80 00 10 bne,a 40006f7c <pthread_barrier_init+0x90> <== NEVER TAKEN
40006f40: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40006f44: 03 10 00 5d sethi %hi(0x40017400), %g1
40006f48: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40017460 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
40006f4c: c0 27 bf f0 clr [ %fp + -16 ]
the_attributes.maximum_count = count;
40006f50: f4 27 bf f4 st %i2, [ %fp + -12 ]
++level;
40006f54: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40006f58: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
* 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 *)
40006f5c: 39 10 00 5d sethi %hi(0x40017400), %i4
40006f60: 40 00 08 68 call 40009100 <_Objects_Allocate>
40006f64: 90 17 23 e4 or %i4, 0x3e4, %o0 ! 400177e4 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
40006f68: ba 92 20 00 orcc %o0, 0, %i5
40006f6c: 12 80 00 06 bne 40006f84 <pthread_barrier_init+0x98>
40006f70: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
40006f74: 40 00 0d 2a call 4000a41c <_Thread_Enable_dispatch>
40006f78: b0 10 20 0b mov 0xb, %i0
40006f7c: 81 c7 e0 08 ret
40006f80: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
40006f84: 40 00 05 dc call 400086f4 <_CORE_barrier_Initialize>
40006f88: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40006f8c: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40006f90: b8 17 23 e4 or %i4, 0x3e4, %i4
40006f94: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40006f98: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40006f9c: 85 28 a0 02 sll %g2, 2, %g2
40006fa0: 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;
40006fa4: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
40006fa8: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40006fac: 40 00 0d 1c call 4000a41c <_Thread_Enable_dispatch>
40006fb0: b0 10 20 00 clr %i0
40006fb4: 81 c7 e0 08 ret
40006fb8: 81 e8 00 00 restore
400067dc <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
400067dc: 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 )
400067e0: 80 a6 20 00 cmp %i0, 0
400067e4: 02 80 00 12 be 4000682c <pthread_cleanup_push+0x50>
400067e8: 03 10 00 5e sethi %hi(0x40017800), %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;
400067ec: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 400179c0 <_Thread_Dispatch_disable_level>
++level;
400067f0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400067f4: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ]
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
400067f8: 40 00 11 99 call 4000ae5c <_Workspace_Allocate>
400067fc: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
40006800: 92 92 20 00 orcc %o0, 0, %o1
40006804: 02 80 00 08 be 40006824 <pthread_cleanup_push+0x48> <== NEVER TAKEN
40006808: 03 10 00 5f sethi %hi(0x40017c00), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
4000680c: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 40017ee0 <_Per_CPU_Information+0x10>
handler_stack = &thread_support->Cancellation_Handlers;
40006810: d0 00 61 50 ld [ %g1 + 0x150 ], %o0
handler->routine = routine;
40006814: f0 22 60 08 st %i0, [ %o1 + 8 ]
handler->arg = arg;
40006818: f2 22 60 0c st %i1, [ %o1 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
4000681c: 40 00 06 1e call 40008094 <_Chain_Append>
40006820: 90 02 20 e4 add %o0, 0xe4, %o0
}
_Thread_Enable_dispatch();
40006824: 40 00 0d 62 call 40009dac <_Thread_Enable_dispatch>
40006828: 81 e8 00 00 restore
4000682c: 81 c7 e0 08 ret
40006830: 81 e8 00 00 restore
400077bc <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
400077bc: 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;
400077c0: 80 a6 60 00 cmp %i1, 0
400077c4: 32 80 00 05 bne,a 400077d8 <pthread_cond_init+0x1c>
400077c8: c4 06 60 04 ld [ %i1 + 4 ], %g2
else the_attr = &_POSIX_Condition_variables_Default_attributes;
400077cc: 33 10 00 5c sethi %hi(0x40017000), %i1
400077d0: b2 16 60 b4 or %i1, 0xb4, %i1 ! 400170b4 <_POSIX_Condition_variables_Default_attributes>
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
400077d4: c4 06 60 04 ld [ %i1 + 4 ], %g2
400077d8: 80 a0 a0 01 cmp %g2, 1
400077dc: 02 80 00 25 be 40007870 <pthread_cond_init+0xb4> <== NEVER TAKEN
400077e0: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
400077e4: c4 06 40 00 ld [ %i1 ], %g2
400077e8: 80 a0 a0 00 cmp %g2, 0
400077ec: 02 80 00 21 be 40007870 <pthread_cond_init+0xb4>
400077f0: 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;
400077f4: 03 10 00 61 sethi %hi(0x40018400), %g1
400077f8: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 40018700 <_Thread_Dispatch_disable_level>
++level;
400077fc: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007800: c4 20 63 00 st %g2, [ %g1 + 0x300 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
40007804: 39 10 00 62 sethi %hi(0x40018800), %i4
40007808: 40 00 0a 11 call 4000a04c <_Objects_Allocate>
4000780c: 90 17 23 1c or %i4, 0x31c, %o0 ! 40018b1c <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
40007810: ba 92 20 00 orcc %o0, 0, %i5
40007814: 32 80 00 06 bne,a 4000782c <pthread_cond_init+0x70>
40007818: c2 06 60 04 ld [ %i1 + 4 ], %g1
_Thread_Enable_dispatch();
4000781c: 40 00 0e d3 call 4000b368 <_Thread_Enable_dispatch>
40007820: 01 00 00 00 nop
return ENOMEM;
40007824: 10 80 00 13 b 40007870 <pthread_cond_init+0xb4>
40007828: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
4000782c: 90 07 60 18 add %i5, 0x18, %o0
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
40007830: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
40007834: 92 10 20 00 clr %o1
40007838: 15 04 00 02 sethi %hi(0x10000800), %o2
4000783c: 96 10 20 74 mov 0x74, %o3
40007840: 40 00 10 c1 call 4000bb44 <_Thread_queue_Initialize>
40007844: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007848: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000784c: b8 17 23 1c or %i4, 0x31c, %i4
40007850: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007854: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007858: 85 28 a0 02 sll %g2, 2, %g2
4000785c: 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;
40007860: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
40007864: 40 00 0e c1 call 4000b368 <_Thread_Enable_dispatch>
40007868: c2 26 00 00 st %g1, [ %i0 ]
return 0;
4000786c: 82 10 20 00 clr %g1
}
40007870: 81 c7 e0 08 ret
40007874: 91 e8 00 01 restore %g0, %g1, %o0
4000761c <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
4000761c: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
40007620: 80 a0 60 00 cmp %g1, 0
40007624: 02 80 00 08 be 40007644 <pthread_condattr_destroy+0x28>
40007628: 90 10 20 16 mov 0x16, %o0
4000762c: c4 00 40 00 ld [ %g1 ], %g2
40007630: 80 a0 a0 00 cmp %g2, 0
40007634: 02 80 00 04 be 40007644 <pthread_condattr_destroy+0x28> <== NEVER TAKEN
40007638: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
4000763c: c0 20 40 00 clr [ %g1 ]
return 0;
40007640: 90 10 20 00 clr %o0
}
40007644: 81 c3 e0 08 retl
40006bb4 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
40006bb4: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
40006bb8: 80 a6 a0 00 cmp %i2, 0
40006bbc: 02 80 00 8c be 40006dec <pthread_create+0x238>
40006bc0: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40006bc4: 80 a6 60 00 cmp %i1, 0
40006bc8: 32 80 00 05 bne,a 40006bdc <pthread_create+0x28>
40006bcc: c2 06 40 00 ld [ %i1 ], %g1
40006bd0: 33 10 00 75 sethi %hi(0x4001d400), %i1
40006bd4: b2 16 60 8c or %i1, 0x8c, %i1 ! 4001d48c <_POSIX_Threads_Default_attributes>
if ( !the_attr->is_initialized )
40006bd8: c2 06 40 00 ld [ %i1 ], %g1
40006bdc: 80 a0 60 00 cmp %g1, 0
40006be0: 02 80 00 83 be 40006dec <pthread_create+0x238>
40006be4: ba 10 20 16 mov 0x16, %i5
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
40006be8: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006bec: 80 a0 60 00 cmp %g1, 0
40006bf0: 02 80 00 07 be 40006c0c <pthread_create+0x58>
40006bf4: 03 10 00 78 sethi %hi(0x4001e000), %g1
40006bf8: c4 06 60 08 ld [ %i1 + 8 ], %g2
40006bfc: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1
40006c00: 80 a0 80 01 cmp %g2, %g1
40006c04: 2a 80 00 7b bcs,a 40006df0 <pthread_create+0x23c>
40006c08: b0 10 00 1d mov %i5, %i0
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
40006c0c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40006c10: 80 a0 60 01 cmp %g1, 1
40006c14: 02 80 00 06 be 40006c2c <pthread_create+0x78>
40006c18: 80 a0 60 02 cmp %g1, 2
40006c1c: 32 80 00 74 bne,a 40006dec <pthread_create+0x238>
40006c20: ba 10 20 16 mov 0x16, %i5
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
40006c24: 10 80 00 09 b 40006c48 <pthread_create+0x94>
40006c28: e2 06 60 14 ld [ %i1 + 0x14 ], %l1
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40006c2c: 03 10 00 7c sethi %hi(0x4001f000), %g1
40006c30: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 4001f180 <_Per_CPU_Information+0x10>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
40006c34: 90 07 bf e4 add %fp, -28, %o0
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40006c38: d2 00 61 50 ld [ %g1 + 0x150 ], %o1
schedpolicy = api->schedpolicy;
40006c3c: e2 02 60 84 ld [ %o1 + 0x84 ], %l1
schedparam = api->schedparam;
40006c40: 10 80 00 04 b 40006c50 <pthread_create+0x9c>
40006c44: 92 02 60 88 add %o1, 0x88, %o1
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
40006c48: 90 07 bf e4 add %fp, -28, %o0
40006c4c: 92 06 60 18 add %i1, 0x18, %o1
40006c50: 40 00 23 ed call 4000fc04 <memcpy>
40006c54: 94 10 20 1c mov 0x1c, %o2
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
40006c58: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40006c5c: 80 a0 60 00 cmp %g1, 0
40006c60: 12 80 00 63 bne 40006dec <pthread_create+0x238>
40006c64: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
40006c68: 40 00 18 3c call 4000cd58 <_POSIX_Priority_Is_valid>
40006c6c: d0 07 bf e4 ld [ %fp + -28 ], %o0
40006c70: 80 8a 20 ff btst 0xff, %o0
40006c74: 02 80 00 5e be 40006dec <pthread_create+0x238> <== NEVER TAKEN
40006c78: 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);
40006c7c: 03 10 00 78 sethi %hi(0x4001e000), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
40006c80: e4 07 bf e4 ld [ %fp + -28 ], %l2
40006c84: e6 08 60 ac ldub [ %g1 + 0xac ], %l3
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
40006c88: 90 10 00 11 mov %l1, %o0
40006c8c: 92 07 bf e4 add %fp, -28, %o1
40006c90: 94 07 bf dc add %fp, -36, %o2
40006c94: 40 00 18 3c call 4000cd84 <_POSIX_Thread_Translate_sched_param>
40006c98: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
40006c9c: ba 92 20 00 orcc %o0, 0, %i5
40006ca0: 32 80 00 54 bne,a 40006df0 <pthread_create+0x23c>
40006ca4: b0 10 00 1d mov %i5, %i0
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
40006ca8: 39 10 00 7b sethi %hi(0x4001ec00), %i4
40006cac: 40 00 06 36 call 40008584 <_API_Mutex_Lock>
40006cb0: d0 07 20 e0 ld [ %i4 + 0xe0 ], %o0 ! 4001ece0 <_RTEMS_Allocator_Mutex>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
40006cb4: 11 10 00 7b sethi %hi(0x4001ec00), %o0
40006cb8: 40 00 08 d2 call 40009000 <_Objects_Allocate>
40006cbc: 90 12 22 64 or %o0, 0x264, %o0 ! 4001ee64 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
40006cc0: a0 92 20 00 orcc %o0, 0, %l0
40006cc4: 32 80 00 04 bne,a 40006cd4 <pthread_create+0x120>
40006cc8: c2 06 60 08 ld [ %i1 + 8 ], %g1
_RTEMS_Unlock_allocator();
40006ccc: 10 80 00 21 b 40006d50 <pthread_create+0x19c>
40006cd0: d0 07 20 e0 ld [ %i4 + 0xe0 ], %o0
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
40006cd4: 05 10 00 78 sethi %hi(0x4001e000), %g2
40006cd8: d6 00 a0 b0 ld [ %g2 + 0xb0 ], %o3 ! 4001e0b0 <rtems_minimum_stack_size>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
40006cdc: c0 27 bf d4 clr [ %fp + -44 ]
40006ce0: 97 2a e0 01 sll %o3, 1, %o3
40006ce4: 80 a2 c0 01 cmp %o3, %g1
40006ce8: 1a 80 00 03 bcc 40006cf4 <pthread_create+0x140>
40006cec: d4 06 60 04 ld [ %i1 + 4 ], %o2
40006cf0: 96 10 00 01 mov %g1, %o3
40006cf4: 82 10 20 01 mov 1, %g1
40006cf8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40006cfc: c2 07 bf dc ld [ %fp + -36 ], %g1
40006d00: 9a 0c e0 ff and %l3, 0xff, %o5
40006d04: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40006d08: c2 07 bf e0 ld [ %fp + -32 ], %g1
40006d0c: c0 23 a0 68 clr [ %sp + 0x68 ]
40006d10: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40006d14: 82 07 bf d4 add %fp, -44, %g1
40006d18: 39 10 00 7b sethi %hi(0x4001ec00), %i4
40006d1c: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
40006d20: 90 17 22 64 or %i4, 0x264, %o0
40006d24: 92 10 00 10 mov %l0, %o1
40006d28: 98 10 20 00 clr %o4
40006d2c: 40 00 0d b4 call 4000a3fc <_Thread_Initialize>
40006d30: 9a 23 40 12 sub %o5, %l2, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
40006d34: 80 8a 20 ff btst 0xff, %o0
40006d38: 12 80 00 0a bne 40006d60 <pthread_create+0x1ac>
40006d3c: 90 17 22 64 or %i4, 0x264, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
40006d40: 40 00 09 8f call 4000937c <_Objects_Free>
40006d44: 92 10 00 10 mov %l0, %o1
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
40006d48: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40006d4c: d0 00 60 e0 ld [ %g1 + 0xe0 ], %o0 ! 4001ece0 <_RTEMS_Allocator_Mutex>
40006d50: 40 00 06 22 call 400085d8 <_API_Mutex_Unlock>
40006d54: ba 10 20 0b mov 0xb, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
40006d58: 81 c7 e0 08 ret
40006d5c: 91 e8 00 1d restore %g0, %i5, %o0
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40006d60: f8 04 21 50 ld [ %l0 + 0x150 ], %i4
api->Attributes = *the_attr;
40006d64: 92 10 00 19 mov %i1, %o1
40006d68: 94 10 20 40 mov 0x40, %o2
40006d6c: 40 00 23 a6 call 4000fc04 <memcpy>
40006d70: 90 10 00 1c mov %i4, %o0
api->detachstate = the_attr->detachstate;
40006d74: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
40006d78: 92 07 bf e4 add %fp, -28, %o1
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
40006d7c: c2 27 20 40 st %g1, [ %i4 + 0x40 ]
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
40006d80: 94 10 20 1c mov 0x1c, %o2
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
40006d84: e2 27 20 84 st %l1, [ %i4 + 0x84 ]
api->schedparam = schedparam;
40006d88: 40 00 23 9f call 4000fc04 <memcpy>
40006d8c: 90 07 20 88 add %i4, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
40006d90: 90 10 00 10 mov %l0, %o0
40006d94: 92 10 20 01 mov 1, %o1
40006d98: 94 10 00 1a mov %i2, %o2
40006d9c: 96 10 00 1b mov %i3, %o3
40006da0: 40 00 0f d0 call 4000ace0 <_Thread_Start>
40006da4: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
40006da8: 80 a4 60 04 cmp %l1, 4
40006dac: 32 80 00 0a bne,a 40006dd4 <pthread_create+0x220>
40006db0: c2 04 20 08 ld [ %l0 + 8 ], %g1
_Watchdog_Insert_ticks(
40006db4: 40 00 0f f5 call 4000ad88 <_Timespec_To_ticks>
40006db8: 90 07 20 90 add %i4, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006dbc: 92 07 20 a8 add %i4, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006dc0: d0 27 20 b4 st %o0, [ %i4 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006dc4: 11 10 00 7b sethi %hi(0x4001ec00), %o0
40006dc8: 40 00 10 a5 call 4000b05c <_Watchdog_Insert>
40006dcc: 90 12 20 f8 or %o0, 0xf8, %o0 ! 4001ecf8 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
40006dd0: c2 04 20 08 ld [ %l0 + 8 ], %g1
40006dd4: c2 26 00 00 st %g1, [ %i0 ]
_RTEMS_Unlock_allocator();
40006dd8: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40006ddc: 40 00 05 ff call 400085d8 <_API_Mutex_Unlock>
40006de0: d0 00 60 e0 ld [ %g1 + 0xe0 ], %o0 ! 4001ece0 <_RTEMS_Allocator_Mutex>
return 0;
}
40006de4: 81 c7 e0 08 ret
40006de8: 91 e8 00 1d restore %g0, %i5, %o0
40006dec: b0 10 00 1d mov %i5, %i0
40006df0: 81 c7 e0 08 ret
40006df4: 81 e8 00 00 restore
4001b198 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
4001b198: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
4001b19c: 80 a6 60 00 cmp %i1, 0
4001b1a0: 32 80 00 03 bne,a 4001b1ac <pthread_kill+0x14>
4001b1a4: b8 06 7f ff add %i1, -1, %i4
4001b1a8: 30 80 00 04 b,a 4001b1b8 <pthread_kill+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001b1ac: 80 a7 20 1f cmp %i4, 0x1f
4001b1b0: 28 80 00 06 bleu,a 4001b1c8 <pthread_kill+0x30>
4001b1b4: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4001b1b8: 7f ff ce 2d call 4000ea6c <__errno>
4001b1bc: 01 00 00 00 nop
4001b1c0: 10 80 00 30 b 4001b280 <pthread_kill+0xe8>
4001b1c4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
the_thread = _Thread_Get( thread, &location );
4001b1c8: 7f ff b9 a2 call 40009850 <_Thread_Get>
4001b1cc: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4001b1d0: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b1d4: 80 a0 60 00 cmp %g1, 0
4001b1d8: 12 80 00 27 bne 4001b274 <pthread_kill+0xdc> <== NEVER TAKEN
4001b1dc: ba 10 00 08 mov %o0, %i5
4001b1e0: 11 10 00 75 sethi %hi(0x4001d400), %o0
4001b1e4: 7f ff b1 c6 call 400078fc <_API_extensions_Add_post_switch>
4001b1e8: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 4001d7e8 <_POSIX_signals_Post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
4001b1ec: 85 2e 60 02 sll %i1, 2, %g2
4001b1f0: 87 2e 60 04 sll %i1, 4, %g3
4001b1f4: 86 20 c0 02 sub %g3, %g2, %g3
4001b1f8: 05 10 00 79 sethi %hi(0x4001e400), %g2
4001b1fc: 84 10 a3 70 or %g2, 0x370, %g2 ! 4001e770 <_POSIX_signals_Vectors>
4001b200: 84 00 80 03 add %g2, %g3, %g2
4001b204: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4001b208: 80 a0 a0 01 cmp %g2, 1
4001b20c: 12 80 00 06 bne 4001b224 <pthread_kill+0x8c>
4001b210: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
_Thread_Enable_dispatch();
4001b214: 7f ff b9 83 call 40009820 <_Thread_Enable_dispatch>
4001b218: b0 10 20 00 clr %i0
4001b21c: 81 c7 e0 08 ret
4001b220: 81 e8 00 00 restore
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001b224: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
4001b228: b6 10 20 01 mov 1, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001b22c: 90 10 00 1d mov %i5, %o0
4001b230: b9 2e c0 1c sll %i3, %i4, %i4
4001b234: 92 10 00 19 mov %i1, %o1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001b238: b8 10 80 1c or %g2, %i4, %i4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001b23c: 94 10 20 00 clr %o2
4001b240: 7f ff ff 84 call 4001b050 <_POSIX_signals_Unblock_thread>
4001b244: f8 20 60 d4 st %i4, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001b248: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001b24c: 82 10 63 10 or %g1, 0x310, %g1 ! 4001e710 <_Per_CPU_Information>
4001b250: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001b254: 80 a0 a0 00 cmp %g2, 0
4001b258: 02 bf ff ef be 4001b214 <pthread_kill+0x7c>
4001b25c: 01 00 00 00 nop
4001b260: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001b264: 80 a7 40 02 cmp %i5, %g2
4001b268: 22 bf ff eb be,a 4001b214 <pthread_kill+0x7c>
4001b26c: f6 28 60 0c stb %i3, [ %g1 + 0xc ]
4001b270: 30 bf ff e9 b,a 4001b214 <pthread_kill+0x7c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
4001b274: 7f ff cd fe call 4000ea6c <__errno> <== NOT EXECUTED
4001b278: 01 00 00 00 nop <== NOT EXECUTED
4001b27c: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3> <== NOT EXECUTED
4001b280: c2 22 00 00 st %g1, [ %o0 ]
}
4001b284: 81 c7 e0 08 ret
4001b288: 91 e8 3f ff restore %g0, -1, %o0
40008d90 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
40008d90: 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 );
40008d94: 92 07 bf fc add %fp, -4, %o1
40008d98: 40 00 00 37 call 40008e74 <_POSIX_Absolute_timeout_to_ticks>
40008d9c: 90 10 00 19 mov %i1, %o0
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
40008da0: 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 )
40008da4: 82 1a 20 03 xor %o0, 3, %g1
40008da8: 80 a0 00 01 cmp %g0, %g1
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
40008dac: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
40008db0: b8 60 3f ff subx %g0, -1, %i4
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
40008db4: 90 10 00 18 mov %i0, %o0
40008db8: 7f ff ff b7 call 40008c94 <_POSIX_Mutex_Lock_support>
40008dbc: 92 10 00 1c mov %i4, %o1
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
40008dc0: 80 a7 20 00 cmp %i4, 0
40008dc4: 12 80 00 0c bne 40008df4 <pthread_mutex_timedlock+0x64>
40008dc8: b0 10 00 08 mov %o0, %i0
40008dcc: 80 a2 20 10 cmp %o0, 0x10
40008dd0: 12 80 00 09 bne 40008df4 <pthread_mutex_timedlock+0x64>
40008dd4: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40008dd8: 02 80 00 07 be 40008df4 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
40008ddc: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40008de0: ba 07 7f ff add %i5, -1, %i5
40008de4: 80 a7 60 01 cmp %i5, 1
40008de8: 18 80 00 03 bgu 40008df4 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
40008dec: b0 10 20 10 mov 0x10, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
40008df0: b0 10 20 74 mov 0x74, %i0
}
return lock_status;
}
40008df4: 81 c7 e0 08 ret
40008df8: 81 e8 00 00 restore
4000651c <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
4000651c: 82 10 00 08 mov %o0, %g1
if ( !attr )
40006520: 80 a0 60 00 cmp %g1, 0
40006524: 02 80 00 0b be 40006550 <pthread_mutexattr_gettype+0x34>
40006528: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
4000652c: c4 00 40 00 ld [ %g1 ], %g2
40006530: 80 a0 a0 00 cmp %g2, 0
40006534: 02 80 00 07 be 40006550 <pthread_mutexattr_gettype+0x34>
40006538: 80 a2 60 00 cmp %o1, 0
return EINVAL;
if ( !type )
4000653c: 02 80 00 05 be 40006550 <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
40006540: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
40006544: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
40006548: 90 10 20 00 clr %o0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
4000654c: c2 22 40 00 st %g1, [ %o1 ]
return 0;
}
40006550: 81 c3 e0 08 retl
40008948 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
40008948: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
4000894c: 80 a0 60 00 cmp %g1, 0
40008950: 02 80 00 0a be 40008978 <pthread_mutexattr_setpshared+0x30>
40008954: 90 10 20 16 mov 0x16, %o0
40008958: c4 00 40 00 ld [ %g1 ], %g2
4000895c: 80 a0 a0 00 cmp %g2, 0
40008960: 02 80 00 06 be 40008978 <pthread_mutexattr_setpshared+0x30>
40008964: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
40008968: 18 80 00 04 bgu 40008978 <pthread_mutexattr_setpshared+0x30><== 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;
40008974: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
40008978: 81 c3 e0 08 retl
40006588 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
40006588: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
4000658c: 80 a0 60 00 cmp %g1, 0
40006590: 02 80 00 0a be 400065b8 <pthread_mutexattr_settype+0x30>
40006594: 90 10 20 16 mov 0x16, %o0
40006598: c4 00 40 00 ld [ %g1 ], %g2
4000659c: 80 a0 a0 00 cmp %g2, 0
400065a0: 02 80 00 06 be 400065b8 <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
400065a4: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
400065a8: 18 80 00 04 bgu 400065b8 <pthread_mutexattr_settype+0x30>
400065ac: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
400065b0: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
400065b4: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
400065b8: 81 c3 e0 08 retl
4000723c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
4000723c: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
40007240: 80 a6 60 00 cmp %i1, 0
40007244: 02 80 00 1c be 400072b4 <pthread_once+0x78>
40007248: ba 10 00 18 mov %i0, %i5
4000724c: 80 a6 20 00 cmp %i0, 0
40007250: 22 80 00 17 be,a 400072ac <pthread_once+0x70>
40007254: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !once_control->init_executed ) {
40007258: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000725c: 80 a0 60 00 cmp %g1, 0
40007260: 12 80 00 13 bne 400072ac <pthread_once+0x70>
40007264: b0 10 20 00 clr %i0
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
40007268: 90 10 21 00 mov 0x100, %o0
4000726c: 92 10 21 00 mov 0x100, %o1
40007270: 40 00 03 0d call 40007ea4 <rtems_task_mode>
40007274: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
40007278: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000727c: 80 a0 60 00 cmp %g1, 0
40007280: 12 80 00 07 bne 4000729c <pthread_once+0x60> <== NEVER TAKEN
40007284: d0 07 bf fc ld [ %fp + -4 ], %o0
once_control->is_initialized = true;
40007288: 82 10 20 01 mov 1, %g1
4000728c: c2 27 40 00 st %g1, [ %i5 ]
once_control->init_executed = true;
(*init_routine)();
40007290: 9f c6 40 00 call %i1
40007294: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
40007298: d0 07 bf fc ld [ %fp + -4 ], %o0
4000729c: 92 10 21 00 mov 0x100, %o1
400072a0: 94 07 bf fc add %fp, -4, %o2
400072a4: 40 00 03 00 call 40007ea4 <rtems_task_mode>
400072a8: b0 10 20 00 clr %i0
400072ac: 81 c7 e0 08 ret
400072b0: 81 e8 00 00 restore
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
400072b4: b0 10 20 16 mov 0x16, %i0
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
400072b8: 81 c7 e0 08 ret
400072bc: 81 e8 00 00 restore
4000765c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
4000765c: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
40007660: 80 a6 20 00 cmp %i0, 0
40007664: 12 80 00 04 bne 40007674 <pthread_rwlock_init+0x18>
40007668: 80 a6 60 00 cmp %i1, 0
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
4000766c: 81 c7 e0 08 ret
40007670: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
40007674: 32 80 00 06 bne,a 4000768c <pthread_rwlock_init+0x30>
40007678: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
4000767c: 90 07 bf f8 add %fp, -8, %o0
40007680: 40 00 01 b0 call 40007d40 <pthread_rwlockattr_init>
40007684: 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 )
40007688: c2 06 40 00 ld [ %i1 ], %g1
4000768c: 80 a0 60 00 cmp %g1, 0
40007690: 22 80 00 13 be,a 400076dc <pthread_rwlock_init+0x80> <== NEVER TAKEN
40007694: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
40007698: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000769c: 80 a0 60 00 cmp %g1, 0
400076a0: 32 80 00 0f bne,a 400076dc <pthread_rwlock_init+0x80> <== NEVER TAKEN
400076a4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
400076a8: 03 10 00 8b sethi %hi(0x40022c00), %g1
400076ac: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 40022c10 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
400076b0: c0 27 bf f4 clr [ %fp + -12 ]
++level;
400076b4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400076b8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
* 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 *)
400076bc: 39 10 00 8b sethi %hi(0x40022c00), %i4
400076c0: 40 00 0a 7e call 4000a0b8 <_Objects_Allocate>
400076c4: 90 17 22 14 or %i4, 0x214, %o0 ! 40022e14 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
400076c8: ba 92 20 00 orcc %o0, 0, %i5
400076cc: 12 80 00 06 bne 400076e4 <pthread_rwlock_init+0x88>
400076d0: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
400076d4: 40 00 0f 79 call 4000b4b8 <_Thread_Enable_dispatch>
400076d8: b0 10 20 0b mov 0xb, %i0
400076dc: 81 c7 e0 08 ret
400076e0: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
400076e4: 40 00 08 dd call 40009a58 <_CORE_RWLock_Initialize>
400076e8: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400076ec: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400076f0: b8 17 22 14 or %i4, 0x214, %i4
400076f4: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400076f8: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400076fc: 85 28 a0 02 sll %g2, 2, %g2
40007700: 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;
40007704: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
40007708: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
4000770c: 40 00 0f 6b call 4000b4b8 <_Thread_Enable_dispatch>
40007710: b0 10 20 00 clr %i0
40007714: 81 c7 e0 08 ret
40007718: 81 e8 00 00 restore
40007d10 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40007d10: 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 )
40007d14: 80 a6 20 00 cmp %i0, 0
40007d18: 12 80 00 04 bne 40007d28 <pthread_rwlock_timedrdlock+0x18>
40007d1c: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
40007d20: 81 c7 e0 08 ret
40007d24: 91 e8 20 16 restore %g0, 0x16, %o0
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
40007d28: 40 00 18 ff call 4000e124 <_POSIX_Absolute_timeout_to_ticks>
40007d2c: 90 10 00 19 mov %i1, %o0
40007d30: d2 06 00 00 ld [ %i0 ], %o1
40007d34: ba 10 00 08 mov %o0, %i5
40007d38: 94 07 bf f8 add %fp, -8, %o2
40007d3c: 11 10 00 67 sethi %hi(0x40019c00), %o0
40007d40: 40 00 0b 1e call 4000a9b8 <_Objects_Get>
40007d44: 90 12 22 44 or %o0, 0x244, %o0 ! 40019e44 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40007d48: c2 07 bf f8 ld [ %fp + -8 ], %g1
40007d4c: 80 a0 60 00 cmp %g1, 0
40007d50: 32 80 00 21 bne,a 40007dd4 <pthread_rwlock_timedrdlock+0xc4>
40007d54: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
40007d58: d2 06 00 00 ld [ %i0 ], %o1
40007d5c: 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 )
40007d60: 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(
40007d64: 90 02 20 10 add %o0, 0x10, %o0
40007d68: 80 a0 00 01 cmp %g0, %g1
40007d6c: 98 10 20 00 clr %o4
40007d70: b8 60 3f ff subx %g0, -1, %i4
40007d74: 40 00 07 8c call 40009ba4 <_CORE_RWLock_Obtain_for_reading>
40007d78: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
40007d7c: 40 00 0e 90 call 4000b7bc <_Thread_Enable_dispatch>
40007d80: 01 00 00 00 nop
if ( !do_wait ) {
40007d84: 80 a7 20 00 cmp %i4, 0
40007d88: 12 80 00 0e bne 40007dc0 <pthread_rwlock_timedrdlock+0xb0>
40007d8c: 03 10 00 68 sethi %hi(0x4001a000), %g1
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
40007d90: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 ! 4001a1a0 <_Per_CPU_Information+0x10>
40007d94: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40007d98: 80 a0 60 02 cmp %g1, 2
40007d9c: 32 80 00 0a bne,a 40007dc4 <pthread_rwlock_timedrdlock+0xb4>
40007da0: 03 10 00 68 sethi %hi(0x4001a000), %g1
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40007da4: 80 a7 60 00 cmp %i5, 0
40007da8: 22 80 00 0b be,a 40007dd4 <pthread_rwlock_timedrdlock+0xc4><== NEVER TAKEN
40007dac: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40007db0: ba 07 7f ff add %i5, -1, %i5
40007db4: 80 a7 60 01 cmp %i5, 1
40007db8: 08 80 00 07 bleu 40007dd4 <pthread_rwlock_timedrdlock+0xc4><== ALWAYS TAKEN
40007dbc: b0 10 20 74 mov 0x74, %i0
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
40007dc0: 03 10 00 68 sethi %hi(0x4001a000), %g1
40007dc4: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 ! 4001a1a0 <_Per_CPU_Information+0x10>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
40007dc8: 40 00 00 38 call 40007ea8 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40007dcc: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
40007dd0: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
40007dd4: 81 c7 e0 08 ret
40007dd8: 81 e8 00 00 restore
40007ddc <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40007ddc: 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 )
40007de0: 80 a6 20 00 cmp %i0, 0
40007de4: 12 80 00 04 bne 40007df4 <pthread_rwlock_timedwrlock+0x18>
40007de8: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
40007dec: 81 c7 e0 08 ret
40007df0: 91 e8 20 16 restore %g0, 0x16, %o0
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
40007df4: 40 00 18 cc call 4000e124 <_POSIX_Absolute_timeout_to_ticks>
40007df8: 90 10 00 19 mov %i1, %o0
40007dfc: d2 06 00 00 ld [ %i0 ], %o1
40007e00: ba 10 00 08 mov %o0, %i5
40007e04: 94 07 bf f8 add %fp, -8, %o2
40007e08: 11 10 00 67 sethi %hi(0x40019c00), %o0
40007e0c: 40 00 0a eb call 4000a9b8 <_Objects_Get>
40007e10: 90 12 22 44 or %o0, 0x244, %o0 ! 40019e44 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40007e14: c2 07 bf f8 ld [ %fp + -8 ], %g1
40007e18: 80 a0 60 00 cmp %g1, 0
40007e1c: 32 80 00 21 bne,a 40007ea0 <pthread_rwlock_timedwrlock+0xc4>
40007e20: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
40007e24: d2 06 00 00 ld [ %i0 ], %o1
40007e28: 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 )
40007e2c: 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(
40007e30: 90 02 20 10 add %o0, 0x10, %o0
40007e34: 80 a0 00 01 cmp %g0, %g1
40007e38: 98 10 20 00 clr %o4
40007e3c: b8 60 3f ff subx %g0, -1, %i4
40007e40: 40 00 07 8c call 40009c70 <_CORE_RWLock_Obtain_for_writing>
40007e44: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
40007e48: 40 00 0e 5d call 4000b7bc <_Thread_Enable_dispatch>
40007e4c: 01 00 00 00 nop
if ( !do_wait &&
40007e50: 80 a7 20 00 cmp %i4, 0
40007e54: 12 80 00 0e bne 40007e8c <pthread_rwlock_timedwrlock+0xb0>
40007e58: 03 10 00 68 sethi %hi(0x4001a000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
40007e5c: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 ! 4001a1a0 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
40007e60: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40007e64: 80 a0 60 02 cmp %g1, 2
40007e68: 32 80 00 0a bne,a 40007e90 <pthread_rwlock_timedwrlock+0xb4>
40007e6c: 03 10 00 68 sethi %hi(0x4001a000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40007e70: 80 a7 60 00 cmp %i5, 0
40007e74: 22 80 00 0b be,a 40007ea0 <pthread_rwlock_timedwrlock+0xc4><== NEVER TAKEN
40007e78: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40007e7c: ba 07 7f ff add %i5, -1, %i5
40007e80: 80 a7 60 01 cmp %i5, 1
40007e84: 08 80 00 07 bleu 40007ea0 <pthread_rwlock_timedwrlock+0xc4><== ALWAYS TAKEN
40007e88: b0 10 20 74 mov 0x74, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
40007e8c: 03 10 00 68 sethi %hi(0x4001a000), %g1
40007e90: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 ! 4001a1a0 <_Per_CPU_Information+0x10>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
40007e94: 40 00 00 05 call 40007ea8 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40007e98: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
40007e9c: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
40007ea0: 81 c7 e0 08 ret
40007ea4: 81 e8 00 00 restore
40008634 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
40008634: 82 10 00 08 mov %o0, %g1
if ( !attr )
40008638: 80 a0 60 00 cmp %g1, 0
4000863c: 02 80 00 0a be 40008664 <pthread_rwlockattr_setpshared+0x30>
40008640: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
40008644: c4 00 40 00 ld [ %g1 ], %g2
40008648: 80 a0 a0 00 cmp %g2, 0
4000864c: 02 80 00 06 be 40008664 <pthread_rwlockattr_setpshared+0x30>
40008650: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
40008654: 18 80 00 04 bgu 40008664 <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
40008658: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
4000865c: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
40008660: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
40008664: 81 c3 e0 08 retl
4000965c <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
4000965c: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
40009660: 80 a6 a0 00 cmp %i2, 0
40009664: 02 80 00 40 be 40009764 <pthread_setschedparam+0x108>
40009668: b6 10 20 16 mov 0x16, %i3
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
4000966c: 90 10 00 19 mov %i1, %o0
40009670: 92 10 00 1a mov %i2, %o1
40009674: 94 07 bf f4 add %fp, -12, %o2
40009678: 40 00 16 c1 call 4000f17c <_POSIX_Thread_Translate_sched_param>
4000967c: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
40009680: b6 92 20 00 orcc %o0, 0, %i3
40009684: 32 80 00 39 bne,a 40009768 <pthread_setschedparam+0x10c>
40009688: b0 10 00 1b mov %i3, %i0
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
4000968c: 90 10 00 18 mov %i0, %o0
40009690: 40 00 0b f2 call 4000c658 <_Thread_Get>
40009694: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40009698: c2 07 bf fc ld [ %fp + -4 ], %g1
4000969c: 80 a0 60 00 cmp %g1, 0
400096a0: 12 80 00 30 bne 40009760 <pthread_setschedparam+0x104>
400096a4: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
400096a8: fa 02 21 50 ld [ %o0 + 0x150 ], %i5
if ( api->schedpolicy == SCHED_SPORADIC )
400096ac: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
400096b0: 80 a0 60 04 cmp %g1, 4
400096b4: 32 80 00 05 bne,a 400096c8 <pthread_setschedparam+0x6c>
400096b8: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
400096bc: 40 00 0f c9 call 4000d5e0 <_Watchdog_Remove>
400096c0: 90 07 60 a8 add %i5, 0xa8, %o0
api->schedpolicy = policy;
400096c4: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
api->schedparam = *param;
400096c8: 90 07 60 88 add %i5, 0x88, %o0
400096cc: 92 10 00 1a mov %i2, %o1
400096d0: 40 00 22 4b call 40011ffc <memcpy>
400096d4: 94 10 20 1c mov 0x1c, %o2
the_thread->budget_algorithm = budget_algorithm;
400096d8: c2 07 bf f4 ld [ %fp + -12 ], %g1
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
400096dc: 80 a6 60 00 cmp %i1, 0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
400096e0: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
the_thread->budget_callout = budget_callout;
400096e4: c2 07 bf f8 ld [ %fp + -8 ], %g1
switch ( api->schedpolicy ) {
400096e8: 06 80 00 1b bl 40009754 <pthread_setschedparam+0xf8> <== NEVER TAKEN
400096ec: c2 27 20 7c st %g1, [ %i4 + 0x7c ]
400096f0: 80 a6 60 02 cmp %i1, 2
400096f4: 04 80 00 07 ble 40009710 <pthread_setschedparam+0xb4>
400096f8: 03 10 00 6c sethi %hi(0x4001b000), %g1
400096fc: 80 a6 60 04 cmp %i1, 4
40009700: 12 80 00 15 bne 40009754 <pthread_setschedparam+0xf8> <== NEVER TAKEN
40009704: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
40009708: 10 80 00 0d b 4000973c <pthread_setschedparam+0xe0>
4000970c: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
40009710: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
40009714: 90 10 00 1c mov %i4, %o0
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
40009718: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
4000971c: 03 10 00 6a sethi %hi(0x4001a800), %g1
40009720: d2 08 60 2c ldub [ %g1 + 0x2c ], %o1 ! 4001a82c <rtems_maximum_priority>
40009724: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
40009728: 94 10 20 01 mov 1, %o2
4000972c: 92 22 40 01 sub %o1, %g1, %o1
40009730: 40 00 0a a4 call 4000c1c0 <_Thread_Change_priority>
40009734: d2 27 20 18 st %o1, [ %i4 + 0x18 ]
the_thread,
the_thread->real_priority,
true
);
break;
40009738: 30 80 00 07 b,a 40009754 <pthread_setschedparam+0xf8>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
_Watchdog_Remove( &api->Sporadic_timer );
4000973c: 90 07 60 a8 add %i5, 0xa8, %o0
40009740: 40 00 0f a8 call 4000d5e0 <_Watchdog_Remove>
40009744: c2 27 60 a4 st %g1, [ %i5 + 0xa4 ]
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
40009748: 90 10 20 00 clr %o0
4000974c: 7f ff ff 7e call 40009544 <_POSIX_Threads_Sporadic_budget_TSR>
40009750: 92 10 00 1c mov %i4, %o1
break;
}
_Thread_Enable_dispatch();
40009754: 40 00 0b b5 call 4000c628 <_Thread_Enable_dispatch>
40009758: b0 10 00 1b mov %i3, %i0
4000975c: 30 80 00 03 b,a 40009768 <pthread_setschedparam+0x10c>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
40009760: b6 10 20 03 mov 3, %i3
}
40009764: b0 10 00 1b mov %i3, %i0
40009768: 81 c7 e0 08 ret
4000976c: 81 e8 00 00 restore
40006f80 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
40006f80: 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() )
40006f84: 03 10 00 5f sethi %hi(0x40017c00), %g1
40006f88: 82 10 62 d0 or %g1, 0x2d0, %g1 ! 40017ed0 <_Per_CPU_Information>
40006f8c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40006f90: 80 a0 a0 00 cmp %g2, 0
40006f94: 12 80 00 16 bne 40006fec <pthread_testcancel+0x6c> <== NEVER TAKEN
40006f98: 05 10 00 5e sethi %hi(0x40017800), %g2
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40006f9c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40006fa0: c6 00 a1 c0 ld [ %g2 + 0x1c0 ], %g3
40006fa4: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
++level;
40006fa8: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
40006fac: c6 20 a1 c0 st %g3, [ %g2 + 0x1c0 ]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
40006fb0: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
40006fb4: 80 a0 a0 00 cmp %g2, 0
40006fb8: 12 80 00 05 bne 40006fcc <pthread_testcancel+0x4c> <== NEVER TAKEN
40006fbc: ba 10 20 00 clr %i5
40006fc0: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
40006fc4: 80 a0 00 01 cmp %g0, %g1
40006fc8: ba 40 20 00 addx %g0, 0, %i5
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
40006fcc: 40 00 0b 78 call 40009dac <_Thread_Enable_dispatch>
40006fd0: 01 00 00 00 nop
if ( cancel )
40006fd4: 80 8f 60 ff btst 0xff, %i5
40006fd8: 02 80 00 05 be 40006fec <pthread_testcancel+0x6c>
40006fdc: 03 10 00 5f sethi %hi(0x40017c00), %g1
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
40006fe0: f0 00 62 e0 ld [ %g1 + 0x2e0 ], %i0 ! 40017ee0 <_Per_CPU_Information+0x10>
40006fe4: 40 00 16 76 call 4000c9bc <_POSIX_Thread_Exit>
40006fe8: 93 e8 3f ff restore %g0, -1, %o1
40006fec: 81 c7 e0 08 ret
40006ff0: 81 e8 00 00 restore
4000bdc4 <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
4000bdc4: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
4000bdc8: 7f ff e1 e2 call 40004550 <malloc>
4000bdcc: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
4000bdd0: ba 92 20 00 orcc %o0, 0, %i5
4000bdd4: 02 80 00 16 be 4000be2c <ramdisk_allocate+0x68> <== NEVER TAKEN
4000bdd8: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
4000bddc: 32 80 00 0e bne,a 4000be14 <ramdisk_allocate+0x50>
4000bde0: c0 2f 60 0d clrb [ %i5 + 0xd ]
area_begin = calloc(media_block_count, media_block_size);
4000bde4: 90 10 00 1a mov %i2, %o0
4000bde8: 7f ff e0 61 call 40003f6c <calloc>
4000bdec: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
4000bdf0: b0 92 20 00 orcc %o0, 0, %i0
4000bdf4: 12 80 00 07 bne 4000be10 <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
4000bdf8: 82 10 20 01 mov 1, %g1
free(rd);
4000bdfc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000be00: 7f ff e0 93 call 4000404c <free> <== NOT EXECUTED
4000be04: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
4000be08: 81 c7 e0 08 ret <== NOT EXECUTED
4000be0c: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
4000be10: c2 2f 60 0d stb %g1, [ %i5 + 0xd ]
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
4000be14: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
4000be18: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = media_block_count;
4000be1c: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
4000be20: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
4000be24: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
4000be28: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
4000be2c: b0 10 00 1d mov %i5, %i0
4000be30: 81 c7 e0 08 ret
4000be34: 81 e8 00 00 restore
4000be38 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
4000be38: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
4000be3c: 80 a6 20 00 cmp %i0, 0
4000be40: 02 80 00 0a be 4000be68 <ramdisk_free+0x30> <== NEVER TAKEN
4000be44: 01 00 00 00 nop
if (rd->malloced) {
4000be48: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
4000be4c: 80 a0 60 00 cmp %g1, 0
4000be50: 02 80 00 04 be 4000be60 <ramdisk_free+0x28>
4000be54: 01 00 00 00 nop
free(rd->area);
4000be58: 7f ff e0 7d call 4000404c <free>
4000be5c: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
4000be60: 7f ff e0 7b call 4000404c <free>
4000be64: 81 e8 00 00 restore
4000be68: 81 c7 e0 08 ret <== NOT EXECUTED
4000be6c: 81 e8 00 00 restore <== NOT EXECUTED
4000cf80 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
4000cf80: 9d e3 bf 88 save %sp, -120, %sp
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
struct ramdisk *r;
rtems_status_code rc;
rc = rtems_disk_io_initialize();
4000cf84: 7f ff dc 3d call 40004078 <rtems_disk_io_initialize>
4000cf88: a8 10 00 18 mov %i0, %l4
if (rc != RTEMS_SUCCESSFUL)
4000cf8c: b0 92 20 00 orcc %o0, 0, %i0
4000cf90: 12 80 00 46 bne 4000d0a8 <ramdisk_initialize+0x128> <== NEVER TAKEN
4000cf94: 3b 10 00 94 sethi %hi(0x40025000), %i5
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
4000cf98: d0 07 63 4c ld [ %i5 + 0x34c ], %o0 ! 4002534c <rtems_ramdisk_configuration_size>
4000cf9c: 92 10 20 10 mov 0x10, %o1
4000cfa0: 7f ff df ed call 40004f54 <calloc>
4000cfa4: 33 10 00 94 sethi %hi(0x40025000), %i1
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000cfa8: a6 10 00 1d mov %i5, %l3
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000cfac: 39 0b d9 19 sethi %hi(0x2f646400), %i4
4000cfb0: 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,
4000cfb4: 2b 10 00 34 sethi %hi(0x4000d000), %l5
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
4000cfb8: b6 10 00 08 mov %o0, %i3
r->trace = false;
4000cfbc: c0 2a 20 0e clrb [ %o0 + 0xe ]
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
4000cfc0: b2 16 63 50 or %i1, 0x350, %i1
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000cfc4: b4 10 20 00 clr %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000cfc8: b8 17 21 76 or %i4, 0x176, %i4
4000cfcc: 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);
4000cfd0: b0 07 bf f0 add %fp, -16, %i0
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
4000cfd4: aa 15 60 b0 or %l5, 0xb0, %l5
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000cfd8: 10 80 00 2f b 4000d094 <ramdisk_initialize+0x114>
4000cfdc: a0 10 20 01 mov 1, %l0
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
4000cfe0: f4 2f bf f8 stb %i2, [ %fp + -8 ]
r->block_size = c->block_size;
4000cfe4: e4 06 40 00 ld [ %i1 ], %l2
r->block_num = c->block_num;
4000cfe8: e2 06 60 04 ld [ %i1 + 4 ], %l1
if (c->location == NULL)
4000cfec: c2 06 60 08 ld [ %i1 + 8 ], %g1
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
4000cff0: e4 26 c0 00 st %l2, [ %i3 ]
r->block_num = c->block_num;
if (c->location == NULL)
4000cff4: 80 a0 60 00 cmp %g1, 0
4000cff8: 12 80 00 0f bne 4000d034 <ramdisk_initialize+0xb4> <== NEVER TAKEN
4000cffc: e2 26 e0 04 st %l1, [ %i3 + 4 ]
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
4000d000: 92 10 00 12 mov %l2, %o1
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
4000d004: e0 2e e0 0d stb %l0, [ %i3 + 0xd ]
r->area = malloc(r->block_size * r->block_num);
4000d008: 40 00 4e 1e call 40020880 <.umul>
4000d00c: 90 10 00 11 mov %l1, %o0
4000d010: 7f ff e1 9a call 40005678 <malloc>
4000d014: 01 00 00 00 nop
if (r->area == NULL) /* No enough memory for this disk */
4000d018: 80 a2 20 00 cmp %o0, 0
4000d01c: 12 80 00 04 bne 4000d02c <ramdisk_initialize+0xac> <== ALWAYS TAKEN
4000d020: d0 26 e0 08 st %o0, [ %i3 + 8 ]
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
4000d024: 10 80 00 19 b 4000d088 <ramdisk_initialize+0x108> <== NOT EXECUTED
4000d028: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->initialized = false;
continue;
}
else
{
r->initialized = true;
4000d02c: 10 80 00 05 b 4000d040 <ramdisk_initialize+0xc0>
4000d030: e0 2e e0 0c stb %l0, [ %i3 + 0xc ]
}
}
else
{
r->malloced = false;
4000d034: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
4000d038: e0 2e e0 0c stb %l0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
4000d03c: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
4000d040: f0 23 a0 5c st %i0, [ %sp + 0x5c ]
4000d044: 90 10 00 14 mov %l4, %o0
4000d048: 92 10 00 1a mov %i2, %o1
4000d04c: 94 10 00 12 mov %l2, %o2
4000d050: 96 10 00 11 mov %l1, %o3
4000d054: 98 10 00 15 mov %l5, %o4
4000d058: 7f ff db 72 call 40003e20 <rtems_disk_create_phys>
4000d05c: 9a 10 00 1b mov %i3, %o5
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
4000d060: 80 a2 20 00 cmp %o0, 0
4000d064: 22 80 00 0a be,a 4000d08c <ramdisk_initialize+0x10c> <== ALWAYS TAKEN
4000d068: b4 06 a0 01 inc %i2
{
if (r->malloced)
4000d06c: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
4000d070: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d074: 22 80 00 05 be,a 4000d088 <ramdisk_initialize+0x108> <== NOT EXECUTED
4000d078: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
{
free(r->area);
4000d07c: 7f ff df ee call 40005034 <free> <== NOT EXECUTED
4000d080: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
4000d084: 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++)
4000d088: b4 06 a0 01 inc %i2 <== NOT EXECUTED
4000d08c: b2 06 60 0c add %i1, 0xc, %i1
4000d090: b6 06 e0 10 add %i3, 0x10, %i3
4000d094: c2 04 e3 4c ld [ %l3 + 0x34c ], %g1
4000d098: 80 a6 80 01 cmp %i2, %g1
4000d09c: 2a bf ff d1 bcs,a 4000cfe0 <ramdisk_initialize+0x60>
4000d0a0: f8 3f bf f0 std %i4, [ %fp + -16 ]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
4000d0a4: b0 10 20 00 clr %i0
}
4000d0a8: 81 c7 e0 08 ret
4000d0ac: 81 e8 00 00 restore
4000bc98 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000bc98: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000bc9c: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000bca0: ba 10 00 1a mov %i2, %i5
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000bca4: 84 10 a2 07 or %g2, 0x207, %g2
4000bca8: 80 a6 40 02 cmp %i1, %g2
4000bcac: 02 80 00 37 be 4000bd88 <ramdisk_ioctl+0xf0>
4000bcb0: f8 06 20 3c ld [ %i0 + 0x3c ], %i4
4000bcb4: 05 30 06 10 sethi %hi(0xc0184000), %g2
4000bcb8: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <LEON_REG+0x40184201>
4000bcbc: 80 a6 40 02 cmp %i1, %g2
4000bcc0: 12 80 00 39 bne 4000bda4 <ramdisk_ioctl+0x10c>
4000bcc4: 01 00 00 00 nop
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
4000bcc8: c2 06 80 00 ld [ %i2 ], %g1
4000bccc: 80 a0 60 00 cmp %g1, 0
4000bcd0: 02 80 00 07 be 4000bcec <ramdisk_ioctl+0x54>
4000bcd4: b6 06 a0 18 add %i2, 0x18, %i3
4000bcd8: 80 a0 60 01 cmp %g1, 1
4000bcdc: 12 80 00 34 bne 4000bdac <ramdisk_ioctl+0x114> <== NEVER TAKEN
4000bce0: 01 00 00 00 nop
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
4000bce4: 10 80 00 14 b 4000bd34 <ramdisk_ioctl+0x9c>
4000bce8: f2 07 20 08 ld [ %i4 + 8 ], %i1
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
4000bcec: f2 07 20 08 ld [ %i4 + 8 ], %i1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000bcf0: 10 80 00 0b b 4000bd1c <ramdisk_ioctl+0x84>
4000bcf4: 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);
4000bcf8: d2 07 00 00 ld [ %i4 ], %o1
4000bcfc: 40 00 29 ab call 400163a8 <.umul>
4000bd00: f0 06 e0 08 ld [ %i3 + 8 ], %i0
4000bd04: d4 06 e0 04 ld [ %i3 + 4 ], %o2
4000bd08: 92 06 40 08 add %i1, %o0, %o1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000bd0c: b4 06 a0 01 inc %i2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
4000bd10: 90 10 00 18 mov %i0, %o0
4000bd14: 40 00 1e 6b call 400136c0 <memcpy>
4000bd18: b6 06 e0 10 add %i3, 0x10, %i3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000bd1c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000bd20: 80 a6 80 01 cmp %i2, %g1
4000bd24: 2a bf ff f5 bcs,a 4000bcf8 <ramdisk_ioctl+0x60>
4000bd28: d0 06 c0 00 ld [ %i3 ], %o0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
4000bd2c: 10 80 00 11 b 4000bd70 <ramdisk_ioctl+0xd8>
4000bd30: c2 07 60 04 ld [ %i5 + 4 ], %g1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000bd34: 10 80 00 0a b 4000bd5c <ramdisk_ioctl+0xc4>
4000bd38: 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);
4000bd3c: d2 07 00 00 ld [ %i4 ], %o1
4000bd40: 40 00 29 9a call 400163a8 <.umul>
4000bd44: b4 06 a0 01 inc %i2
4000bd48: d2 06 e0 08 ld [ %i3 + 8 ], %o1
4000bd4c: d4 06 e0 04 ld [ %i3 + 4 ], %o2
4000bd50: 90 06 40 08 add %i1, %o0, %o0
4000bd54: 40 00 1e 5b call 400136c0 <memcpy>
4000bd58: b6 06 e0 10 add %i3, 0x10, %i3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000bd5c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000bd60: 80 a6 80 01 cmp %i2, %g1
4000bd64: 2a bf ff f6 bcs,a 4000bd3c <ramdisk_ioctl+0xa4>
4000bd68: d0 06 c0 00 ld [ %i3 ], %o0
4000bd6c: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000bd70: 90 10 00 1d mov %i5, %o0
4000bd74: 92 10 20 00 clr %o1
4000bd78: 9f c0 40 00 call %g1
4000bd7c: 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);
4000bd80: 81 c7 e0 08 ret
4000bd84: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
4000bd88: c2 0f 20 0f ldub [ %i4 + 0xf ], %g1
4000bd8c: 80 a0 60 00 cmp %g1, 0
4000bd90: 02 80 00 07 be 4000bdac <ramdisk_ioctl+0x114>
4000bd94: 01 00 00 00 nop
ramdisk_free(rd);
4000bd98: 40 00 00 28 call 4000be38 <ramdisk_free>
4000bd9c: 90 10 00 1c mov %i4, %o0
4000bda0: 30 80 00 03 b,a 4000bdac <ramdisk_ioctl+0x114>
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
4000bda4: 40 00 0a 01 call 4000e5a8 <rtems_blkdev_ioctl>
4000bda8: 81 e8 00 00 restore
break;
}
errno = EINVAL;
4000bdac: 40 00 1c 0e call 40012de4 <__errno>
4000bdb0: b0 10 3f ff mov -1, %i0
4000bdb4: 82 10 20 16 mov 0x16, %g1
4000bdb8: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
4000bdbc: 81 c7 e0 08 ret
4000bdc0: 81 e8 00 00 restore
4000be70 <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
4000be70: 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);
4000be74: 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;
4000be78: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
4000be7c: 13 10 00 63 sethi %hi(0x40018c00), %o1
4000be80: 94 07 bf fc add %fp, -4, %o2
4000be84: 92 12 62 80 or %o1, 0x280, %o1
4000be88: 7f ff f2 e7 call 40008a24 <rtems_io_register_driver>
4000be8c: a0 10 20 0d mov 0xd, %l0
if (sc != RTEMS_SUCCESSFUL) {
4000be90: 80 a2 20 00 cmp %o0, 0
4000be94: 32 80 00 20 bne,a 4000bf14 <ramdisk_register+0xa4> <== NEVER TAKEN
4000be98: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
4000be9c: 96 10 00 1a mov %i2, %o3
4000bea0: 92 10 00 18 mov %i0, %o1
4000bea4: 7f ff ff c8 call 4000bdc4 <ramdisk_allocate>
4000bea8: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
4000beac: b4 92 20 00 orcc %o0, 0, %i2
4000beb0: 12 80 00 04 bne 4000bec0 <ramdisk_register+0x50> <== ALWAYS TAKEN
4000beb4: fa 07 bf fc ld [ %fp + -4 ], %i5
rtems_io_unregister_driver(major);
4000beb8: 10 80 00 11 b 4000befc <ramdisk_register+0x8c> <== NOT EXECUTED
4000bebc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
4000bec0: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000bec4: 90 10 00 1d mov %i5, %o0
4000bec8: 92 10 20 00 clr %o1
4000becc: 94 10 00 18 mov %i0, %o2
4000bed0: 96 10 00 19 mov %i1, %o3
4000bed4: 19 10 00 2f sethi %hi(0x4000bc00), %o4
4000bed8: 9a 10 00 1a mov %i2, %o5
4000bedc: 7f ff dd 69 call 40003480 <rtems_disk_create_phys>
4000bee0: 98 13 20 98 or %o4, 0x98, %o4
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
4000bee4: 80 a2 20 00 cmp %o0, 0
4000bee8: 22 80 00 08 be,a 4000bf08 <ramdisk_register+0x98> <== ALWAYS TAKEN
4000beec: fa 27 00 00 st %i5, [ %i4 ]
ramdisk_free(rd);
4000bef0: 7f ff ff d2 call 4000be38 <ramdisk_free> <== NOT EXECUTED
4000bef4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
4000bef8: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
4000befc: 7f ff f3 29 call 40008ba0 <rtems_io_unregister_driver> <== NOT EXECUTED
4000bf00: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
4000bf04: 30 80 00 04 b,a 4000bf14 <ramdisk_register+0xa4> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
4000bf08: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
4000bf0c: a0 10 20 00 clr %l0
}
4000bf10: b0 10 00 10 mov %l0, %i0
4000bf14: 81 c7 e0 08 ret
4000bf18: 81 e8 00 00 restore
4000bf1c: 40 00 ce 00 call 4003f71c <__end+0x248dc> <== NOT EXECUTED
4000bf20: 40 00 cd a0 call 4003f5a0 <__end+0x24760> <== NOT EXECUTED
4000bf24: 40 00 cd b4 call 4003f5f4 <__end+0x247b4> <== NOT EXECUTED
4000bf28: 40 00 cd b4 call 4003f5f8 <__end+0x247b8> <== NOT EXECUTED
4000bf2c: 40 00 cd b4 call 4003f5fc <__end+0x247bc> <== NOT EXECUTED
4000bf30: 40 00 cd b4 call 4003f600 <__end+0x247c0> <== NOT EXECUTED
4000bf34: 40 00 cd 98 call 4003f594 <__end+0x24754> <== NOT EXECUTED
4000bf38: 40 00 cd c0 call 4003f638 <__end+0x247f8> <== NOT EXECUTED
4000bf3c: 40 00 cd c0 call 4003f63c <__end+0x247fc> <== NOT EXECUTED
4000bf40: 40 00 cd c0 call 4003f640 <__end+0x24800> <== NOT EXECUTED
4000bf44: 40 00 cd e0 call 4003f6c4 <__end+0x24884> <== NOT EXECUTED
4000bf48: 40 00 cc ec call 4003f2f8 <__end+0x244b8> <== NOT EXECUTED
4000bf4c: 40 00 cc ec call 4003f2fc <__end+0x244bc> <== NOT EXECUTED
4000bf50: 40 00 cd 0c call 4003f380 <__end+0x24540> <== NOT EXECUTED
4000bf54: 40 00 cd 0c call 4003f384 <__end+0x24544> <== NOT EXECUTED
4000bf58: 40 00 cd 0c call 4003f388 <__end+0x24548> <== NOT EXECUTED
4000bf5c: 40 00 cd 0c call 4003f38c <__end+0x2454c> <== NOT EXECUTED
4000bf60: 40 00 cc b8 call 4003f240 <__end+0x24400> <== NOT EXECUTED
4000bf64: 40 00 cd 18 call 4003f3c4 <__end+0x24584> <== NOT EXECUTED
4000bf68: 40 00 cd 18 call 4003f3c8 <__end+0x24588> <== NOT EXECUTED
4000bf6c: 40 00 cd 18 call 4003f3cc <__end+0x2458c> <== NOT EXECUTED
4000bf70: 40 00 e3 8c call 40044da0 <__end+0x29f60> <== NOT EXECUTED
4000bf74: 40 00 e3 8c call 40044da4 <__end+0x29f64> <== NOT EXECUTED
4000bf78: 40 00 e3 4c call 40044ca8 <__end+0x29e68> <== NOT EXECUTED
4000bf7c: 40 00 e3 7c call 40044d6c <__end+0x29f2c> <== NOT EXECUTED
4000bf80: 40 00 e3 7c call 40044d70 <__end+0x29f30> <== NOT EXECUTED
4000bf84: 40 00 e3 7c call 40044d74 <__end+0x29f34> <== NOT EXECUTED
4000bf88: 40 00 e3 8c call 40044db8 <__end+0x29f78> <== NOT EXECUTED
4000bf8c: 40 00 e3 44 call 40044c9c <__end+0x29e5c> <== NOT EXECUTED
4000bf90: 40 00 e3 3c call 40044c80 <__end+0x29e40> <== NOT EXECUTED
4000bf94: 40 00 e3 74 call 40044d64 <__end+0x29f24> <== NOT EXECUTED
4000bf98: 40 00 e3 8c call 40044dc8 <__end+0x29f88> <== NOT EXECUTED
4001aa6c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
4001aa6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001aa70: 03 10 00 75 sethi %hi(0x4001d400), %g1
4001aa74: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 4001d6e4 <rtems_libio_number_iops>
4001aa78: 80 a6 00 01 cmp %i0, %g1
4001aa7c: 1a 80 00 16 bcc 4001aad4 <read+0x68>
4001aa80: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
4001aa84: b1 2e 20 06 sll %i0, 6, %i0
4001aa88: b0 26 00 01 sub %i0, %g1, %i0
4001aa8c: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001aa90: d0 00 60 70 ld [ %g1 + 0x70 ], %o0 ! 4001e070 <rtems_libio_iops>
4001aa94: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001aa98: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001aa9c: 80 88 61 00 btst 0x100, %g1
4001aaa0: 02 80 00 0d be 4001aad4 <read+0x68>
4001aaa4: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001aaa8: 12 80 00 06 bne 4001aac0 <read+0x54> <== ALWAYS TAKEN
4001aaac: 80 a6 a0 00 cmp %i2, 0
4001aab0: 7f ff cf ef call 4000ea6c <__errno> <== NOT EXECUTED
4001aab4: 01 00 00 00 nop <== NOT EXECUTED
4001aab8: 10 80 00 0a b 4001aae0 <read+0x74> <== NOT EXECUTED
4001aabc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
4001aac0: 02 80 00 10 be 4001ab00 <read+0x94>
4001aac4: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001aac8: 80 88 60 02 btst 2, %g1
4001aacc: 32 80 00 08 bne,a 4001aaec <read+0x80>
4001aad0: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001aad4: 7f ff cf e6 call 4000ea6c <__errno>
4001aad8: 01 00 00 00 nop
4001aadc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4001aae0: c2 22 00 00 st %g1, [ %o0 ]
4001aae4: 81 c7 e0 08 ret
4001aae8: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
4001aaec: 92 10 00 19 mov %i1, %o1
4001aaf0: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001aaf4: 9f c0 40 00 call %g1
4001aaf8: 94 10 00 1a mov %i2, %o2
4001aafc: b0 10 00 08 mov %o0, %i0
}
4001ab00: 81 c7 e0 08 ret
4001ab04: 81 e8 00 00 restore
4000439c <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)
{
4000439c: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
400043a0: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t here;
uint8_t *data;
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
400043a4: 80 a6 a0 00 cmp %i2, 0
400043a8: 02 80 00 61 be 4000452c <read_extended_partition+0x190> <== NEVER TAKEN
400043ac: ba 10 20 19 mov 0x19, %i5
400043b0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
400043b4: 80 a0 60 00 cmp %g1, 0
400043b8: 02 80 00 5d be 4000452c <read_extended_partition+0x190> <== NEVER TAKEN
400043bc: 90 10 00 18 mov %i0, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
400043c0: f6 06 a0 04 ld [ %i2 + 4 ], %i3
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
400043c4: bb 2e e0 09 sll %i3, 9, %i5
new_off = lseek(fd, off, SEEK_SET);
400043c8: 92 10 20 00 clr %o1
400043cc: 94 10 00 1d mov %i5, %o2
400043d0: 40 00 04 36 call 400054a8 <lseek>
400043d4: 96 10 20 00 clr %o3
if (new_off != off) {
400043d8: 80 a2 20 00 cmp %o0, 0
400043dc: 32 80 00 0e bne,a 40004414 <read_extended_partition+0x78><== NEVER TAKEN
400043e0: ba 10 20 1b mov 0x1b, %i5 <== NOT EXECUTED
400043e4: 80 a2 40 1d cmp %o1, %i5
400043e8: 12 80 00 0b bne 40004414 <read_extended_partition+0x78> <== NEVER TAKEN
400043ec: ba 10 20 1b mov 0x1b, %i5
400043f0: 90 10 00 18 mov %i0, %o0
400043f4: 92 10 00 1b mov %i3, %o1
400043f8: 7f ff ff a2 call 40004280 <get_sector.part.0>
400043fc: 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)
40004400: ba 92 20 00 orcc %o0, 0, %i5
40004404: 02 80 00 09 be 40004428 <read_extended_partition+0x8c> <== ALWAYS TAKEN
40004408: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
if (sector)
4000440c: 10 80 00 04 b 4000441c <read_extended_partition+0x80> <== NOT EXECUTED
40004410: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004414: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
40004418: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000441c: 22 80 00 45 be,a 40004530 <read_extended_partition+0x194><== NOT EXECUTED
40004420: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40004424: 30 80 00 40 b,a 40004524 <read_extended_partition+0x188> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
40004428: c6 0a 22 02 ldub [ %o0 + 0x202 ], %g3
4000442c: 80 a0 e0 55 cmp %g3, 0x55
40004430: 12 80 00 06 bne 40004448 <read_extended_partition+0xac> <== NEVER TAKEN
40004434: 84 10 20 00 clr %g2
40004438: c4 0a 22 03 ldub [ %o0 + 0x203 ], %g2
4000443c: 84 18 a0 aa xor %g2, 0xaa, %g2
40004440: 80 a0 00 02 cmp %g0, %g2
40004444: 84 60 3f ff subx %g0, -1, %g2
if (sector)
free(sector);
return rc;
}
if (!msdos_signature_check(sector))
40004448: 80 a0 a0 00 cmp %g2, 0
4000444c: 12 80 00 06 bne 40004464 <read_extended_partition+0xc8> <== ALWAYS TAKEN
40004450: a0 02 21 d2 add %o0, 0x1d2, %l0
{
free(sector);
40004454: 40 00 02 f8 call 40005034 <free> <== NOT EXECUTED
40004458: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
}
free(sector);
return RTEMS_SUCCESSFUL;
}
4000445c: 81 c7 e0 08 ret <== NOT EXECUTED
40004460: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40004464: 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)
40004468: a2 06 a0 10 add %i2, 0x10, %l1
4000446c: 90 04 3f f0 add %l0, -16, %o0
40004470: 7f ff ff 9a call 400042d8 <data_to_part_desc.part.1>
40004474: 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)
40004478: ba 92 20 00 orcc %o0, 0, %i5
4000447c: 02 80 00 04 be 4000448c <read_extended_partition+0xf0> <== ALWAYS TAKEN
40004480: d4 07 bf fc ld [ %fp + -4 ], %o2
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
40004484: 10 80 00 28 b 40004524 <read_extended_partition+0x188> <== NOT EXECUTED
40004488: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
4000448c: 80 a2 a0 00 cmp %o2, 0
40004490: 22 80 00 21 be,a 40004514 <read_extended_partition+0x178>
40004494: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
40004498: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
4000449c: 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));
400044a0: 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;
400044a4: 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))
400044a8: 84 08 a0 7f and %g2, 0x7f, %g2
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
400044ac: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
if (is_extended(new_part_desc->sys_type))
400044b0: 80 a0 a0 05 cmp %g2, 5
400044b4: 12 80 00 0a bne 400044dc <read_extended_partition+0x140>
400044b8: c4 02 a0 04 ld [ %o2 + 4 ], %g2
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
400044bc: 84 00 80 19 add %g2, %i1, %g2
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
400044c0: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
400044c4: c4 22 a0 04 st %g2, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
400044c8: 90 10 00 18 mov %i0, %o0
400044cc: 7f ff ff b4 call 4000439c <read_extended_partition>
400044d0: 92 10 00 19 mov %i1, %o1
400044d4: 10 80 00 10 b 40004514 <read_extended_partition+0x178>
400044d8: b8 07 20 04 add %i4, 4, %i4
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
400044dc: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
400044e0: 88 00 e0 0a add %g3, 0xa, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
400044e4: 86 00 e0 01 inc %g3
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
400044e8: 89 29 20 02 sll %g4, 2, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
400044ec: c6 20 60 24 st %g3, [ %g1 + 0x24 ]
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
400044f0: d4 20 40 04 st %o2, [ %g1 + %g4 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
400044f4: 82 06 c0 02 add %i3, %g2, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
400044f8: c4 02 a0 08 ld [ %o2 + 8 ], %g2
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
400044fc: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40004500: 84 00 bf ff add %g2, -1, %g2
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
40004504: c6 2a a0 02 stb %g3, [ %o2 + 2 ]
new_part_desc->start += here;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40004508: 82 00 80 01 add %g2, %g1, %g1
4000450c: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
40004510: 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++)
40004514: 80 a7 00 11 cmp %i4, %l1
40004518: 12 bf ff d5 bne 4000446c <read_extended_partition+0xd0>
4000451c: a0 04 20 10 add %l0, 0x10, %l0
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
40004520: d0 07 bf f8 ld [ %fp + -8 ], %o0
40004524: 40 00 02 c4 call 40005034 <free>
40004528: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
4000452c: b0 10 00 1d mov %i5, %i0
40004530: 81 c7 e0 08 ret
40004534: 81 e8 00 00 restore
400047fc <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
400047fc: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
40004800: 03 10 00 5a sethi %hi(0x40016800), %g1
40004804: c2 00 63 84 ld [ %g1 + 0x384 ], %g1 ! 40016b84 <rtems_libio_number_iops>
40004808: 80 a6 00 01 cmp %i0, %g1
4000480c: 2a 80 00 03 bcs,a 40004818 <readv+0x1c>
40004810: 83 2e 20 03 sll %i0, 3, %g1
40004814: 30 80 00 0c b,a 40004844 <readv+0x48>
iop = rtems_libio_iop( fd );
40004818: b1 2e 20 06 sll %i0, 6, %i0
4000481c: b0 26 00 01 sub %i0, %g1, %i0
40004820: 03 10 00 5d sethi %hi(0x40017400), %g1
40004824: f8 00 60 dc ld [ %g1 + 0xdc ], %i4 ! 400174dc <rtems_libio_iops>
40004828: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
4000482c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40004830: 80 88 61 00 btst 0x100, %g1
40004834: 02 80 00 04 be 40004844 <readv+0x48>
40004838: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4000483c: 12 80 00 06 bne 40004854 <readv+0x58> <== ALWAYS TAKEN
40004840: 80 a6 60 00 cmp %i1, 0
40004844: 40 00 2a d9 call 4000f3a8 <__errno>
40004848: 01 00 00 00 nop
4000484c: 10 80 00 1a b 400048b4 <readv+0xb8>
40004850: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
40004854: 02 80 00 15 be 400048a8 <readv+0xac>
40004858: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
4000485c: 04 80 00 13 ble 400048a8 <readv+0xac>
40004860: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
40004864: 24 80 00 03 ble,a 40004870 <readv+0x74> <== ALWAYS TAKEN
40004868: b5 2e a0 03 sll %i2, 3, %i2
4000486c: 30 80 00 0f b,a 400048a8 <readv+0xac> <== NOT EXECUTED
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
40004870: 82 10 20 00 clr %g1
40004874: 84 10 20 01 mov 1, %g2
40004878: 10 80 00 03 b 40004884 <readv+0x88>
4000487c: 86 10 20 00 clr %g3
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
40004880: 86 10 00 1d mov %i5, %g3
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
40004884: c8 06 40 01 ld [ %i1 + %g1 ], %g4
40004888: 80 a1 20 00 cmp %g4, 0
4000488c: 02 80 00 07 be 400048a8 <readv+0xac>
40004890: 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;
40004894: c8 01 20 04 ld [ %g4 + 4 ], %g4
40004898: ba 01 00 03 add %g4, %g3, %i5
if ( total < old )
4000489c: 80 a7 40 03 cmp %i5, %g3
400048a0: 16 80 00 07 bge 400048bc <readv+0xc0>
400048a4: 80 a0 00 04 cmp %g0, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
400048a8: 40 00 2a c0 call 4000f3a8 <__errno>
400048ac: 01 00 00 00 nop
400048b0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
400048b4: 10 80 00 20 b 40004934 <readv+0x138>
400048b8: c2 22 00 00 st %g1, [ %o0 ]
400048bc: 82 00 60 08 add %g1, 8, %g1
if ( iov[v].iov_len )
all_zeros = false;
400048c0: 86 40 3f ff addx %g0, -1, %g3
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
400048c4: 80 a0 40 1a cmp %g1, %i2
400048c8: 12 bf ff ee bne 40004880 <readv+0x84>
400048cc: 84 08 80 03 and %g2, %g3, %g2
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
400048d0: 80 88 a0 ff btst 0xff, %g2
400048d4: 12 80 00 16 bne 4000492c <readv+0x130>
400048d8: b0 10 20 00 clr %i0
400048dc: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
400048e0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
400048e4: b6 06 40 1d add %i1, %i5, %i3
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
400048e8: c2 00 60 08 ld [ %g1 + 8 ], %g1
400048ec: d2 06 40 1d ld [ %i1 + %i5 ], %o1
400048f0: d4 06 e0 04 ld [ %i3 + 4 ], %o2
400048f4: 9f c0 40 00 call %g1
400048f8: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
400048fc: 80 a2 20 00 cmp %o0, 0
40004900: 26 80 00 0b bl,a 4000492c <readv+0x130> <== NEVER TAKEN
40004904: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
40004908: 32 80 00 02 bne,a 40004910 <readv+0x114> <== ALWAYS TAKEN
4000490c: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40004910: c2 06 e0 04 ld [ %i3 + 4 ], %g1
40004914: 80 a2 00 01 cmp %o0, %g1
40004918: 12 80 00 05 bne 4000492c <readv+0x130> <== NEVER TAKEN
4000491c: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40004920: 80 a7 40 1a cmp %i5, %i2
40004924: 32 bf ff f0 bne,a 400048e4 <readv+0xe8>
40004928: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000492c: 81 c7 e0 08 ret
40004930: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
40004934: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
40004938: 81 c7 e0 08 ret
4000493c: 81 e8 00 00 restore
4001ab64 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
4001ab64: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
4001ab68: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001ab6c: 82 10 60 80 or %g1, 0x80, %g1 ! 4001e080 <rtems_malloc_statistics>
4001ab70: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001ab74: 84 00 a0 01 inc %g2
4001ab78: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
4001ab7c: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001ab80: c2 00 63 08 ld [ %g1 + 0x308 ], %g1 ! 4001e708 <_System_state_Current>
4001ab84: 80 a0 60 03 cmp %g1, 3
4001ab88: 12 80 00 09 bne 4001abac <realloc+0x48>
4001ab8c: 80 a6 20 00 cmp %i0, 0
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
4001ab90: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001ab94: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 4001e200 <_Thread_Dispatch_disable_level>
4001ab98: 80 a0 60 00 cmp %g1, 0
4001ab9c: 02 80 00 38 be 4001ac7c <realloc+0x118> <== ALWAYS TAKEN
4001aba0: 03 10 00 79 sethi %hi(0x4001e400), %g1
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
4001aba4: 81 c7 e0 08 ret <== NOT EXECUTED
4001aba8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
/*
* Continue with realloc().
*/
if ( !ptr )
4001abac: 12 80 00 04 bne 4001abbc <realloc+0x58>
4001abb0: 80 a6 60 00 cmp %i1, 0
return malloc( size );
4001abb4: 7f ff a1 da call 4000331c <malloc>
4001abb8: 91 e8 00 19 restore %g0, %i1, %o0
if ( !size ) {
4001abbc: 12 80 00 06 bne 4001abd4 <realloc+0x70> <== ALWAYS TAKEN
4001abc0: 3b 10 00 75 sethi %hi(0x4001d400), %i5
free( ptr );
4001abc4: 7f ff a1 02 call 40002fcc <free> <== NOT EXECUTED
4001abc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
4001abcc: 81 c7 e0 08 ret <== NOT EXECUTED
4001abd0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if ( !size ) {
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
4001abd4: d0 07 62 a0 ld [ %i5 + 0x2a0 ], %o0
4001abd8: 92 10 00 18 mov %i0, %o1
4001abdc: 40 00 01 b0 call 4001b29c <_Protected_heap_Get_block_size>
4001abe0: 94 07 bf fc add %fp, -4, %o2
4001abe4: 80 8a 20 ff btst 0xff, %o0
4001abe8: 12 80 00 08 bne 4001ac08 <realloc+0xa4>
4001abec: d0 07 62 a0 ld [ %i5 + 0x2a0 ], %o0
errno = EINVAL;
4001abf0: 7f ff cf 9f call 4000ea6c <__errno>
4001abf4: 01 00 00 00 nop
4001abf8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4001abfc: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
4001ac00: 81 c7 e0 08 ret
4001ac04: 91 e8 20 00 restore %g0, 0, %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
4001ac08: 92 10 00 18 mov %i0, %o1
4001ac0c: 40 00 01 b2 call 4001b2d4 <_Protected_heap_Resize_block>
4001ac10: 94 10 00 19 mov %i1, %o2
4001ac14: 80 8a 20 ff btst 0xff, %o0
4001ac18: 12 80 00 1e bne 4001ac90 <realloc+0x12c>
4001ac1c: 01 00 00 00 nop
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
4001ac20: 7f ff a1 bf call 4000331c <malloc>
4001ac24: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001ac28: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001ac2c: 82 10 60 80 or %g1, 0x80, %g1 ! 4001e080 <rtems_malloc_statistics>
4001ac30: c4 00 60 04 ld [ %g1 + 4 ], %g2
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
4001ac34: ba 10 00 08 mov %o0, %i5
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001ac38: 84 00 bf ff add %g2, -1, %g2
if ( !new_area ) {
4001ac3c: 80 a2 20 00 cmp %o0, 0
4001ac40: 02 bf ff f0 be 4001ac00 <realloc+0x9c>
4001ac44: c4 20 60 04 st %g2, [ %g1 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
4001ac48: c2 07 bf fc ld [ %fp + -4 ], %g1
4001ac4c: 80 a6 40 01 cmp %i1, %g1
4001ac50: 08 80 00 03 bleu 4001ac5c <realloc+0xf8> <== NEVER TAKEN
4001ac54: 94 10 00 19 mov %i1, %o2
4001ac58: 94 10 00 01 mov %g1, %o2
4001ac5c: 92 10 00 18 mov %i0, %o1
4001ac60: 7f ff d1 d4 call 4000f3b0 <memcpy>
4001ac64: 90 10 00 1d mov %i5, %o0
free( ptr );
4001ac68: 90 10 00 18 mov %i0, %o0
4001ac6c: 7f ff a0 d8 call 40002fcc <free>
4001ac70: b0 10 00 1d mov %i5, %i0
4001ac74: 81 c7 e0 08 ret
4001ac78: 81 e8 00 00 restore
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
4001ac7c: c2 00 63 18 ld [ %g1 + 0x318 ], %g1
4001ac80: 80 a0 60 00 cmp %g1, 0
4001ac84: 02 bf ff ca be 4001abac <realloc+0x48> <== ALWAYS TAKEN
4001ac88: 80 a6 20 00 cmp %i0, 0
4001ac8c: 30 bf ff dd b,a 4001ac00 <realloc+0x9c> <== NOT EXECUTED
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
4001ac90: 81 c7 e0 08 ret
4001ac94: 81 e8 00 00 restore
40007484 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
40007484: 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);
40007488: 37 10 00 60 sethi %hi(0x40018000), %i3
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
4000748c: ba 10 00 18 mov %i0, %i5
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
40007490: 40 00 02 85 call 40007ea4 <pthread_mutex_lock>
40007494: 90 16 e2 74 or %i3, 0x274, %o0
if (result != 0) {
40007498: b0 92 20 00 orcc %o0, 0, %i0
4000749c: 02 80 00 06 be 400074b4 <rtems_aio_enqueue+0x30> <== ALWAYS TAKEN
400074a0: 01 00 00 00 nop
free (req);
400074a4: 7f ff ef 8f call 400032e0 <free> <== NOT EXECUTED
400074a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400074ac: 81 c7 e0 08 ret <== NOT EXECUTED
400074b0: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
400074b4: 40 00 04 90 call 400086f4 <pthread_self>
400074b8: b6 16 e2 74 or %i3, 0x274, %i3
400074bc: 92 07 bf e0 add %fp, -32, %o1
400074c0: 40 00 03 9d call 40008334 <pthread_getschedparam>
400074c4: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
400074c8: 40 00 04 8b call 400086f4 <pthread_self>
400074cc: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
400074d0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400074d4: c6 07 bf e4 ld [ %fp + -28 ], %g3
400074d8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
400074dc: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
400074e0: 84 20 c0 02 sub %g3, %g2, %g2
400074e4: c4 27 60 0c st %g2, [ %i5 + 0xc ]
req->policy = policy;
400074e8: c4 07 bf e0 ld [ %fp + -32 ], %g2
400074ec: c4 27 60 08 st %g2, [ %i5 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
400074f0: 84 10 20 77 mov 0x77, %g2
400074f4: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
400074f8: c4 06 e0 68 ld [ %i3 + 0x68 ], %g2
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
400074fc: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
40007500: 80 a0 a0 00 cmp %g2, 0
40007504: 12 80 00 2e bne 400075bc <rtems_aio_enqueue+0x138> <== NEVER TAKEN
40007508: d2 00 40 00 ld [ %g1 ], %o1
4000750c: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
40007510: 80 a0 60 04 cmp %g1, 4
40007514: 14 80 00 2b bg 400075c0 <rtems_aio_enqueue+0x13c>
40007518: 11 10 00 60 sethi %hi(0x40018000), %o0
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
4000751c: 90 06 e0 48 add %i3, 0x48, %o0
40007520: 7f ff ff 7d call 40007314 <rtems_aio_search_fd>
40007524: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
40007528: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
4000752c: b8 10 00 08 mov %o0, %i4
if (r_chain->new_fd == 1) {
40007530: 80 a0 60 01 cmp %g1, 1
40007534: 12 80 00 1d bne 400075a8 <rtems_aio_enqueue+0x124>
40007538: b4 02 20 08 add %o0, 8, %i2
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4000753c: 92 10 00 1d mov %i5, %o1
40007540: 40 00 09 03 call 4000994c <_Chain_Insert>
40007544: 90 10 00 1a mov %i2, %o0
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
40007548: 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;
4000754c: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40007550: 40 00 01 fd call 40007d44 <pthread_mutex_init>
40007554: 90 07 20 1c add %i4, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
40007558: 92 10 20 00 clr %o1
4000755c: 40 00 00 ff call 40007958 <pthread_cond_init>
40007560: 90 07 20 20 add %i4, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
40007564: 90 07 bf dc add %fp, -36, %o0
40007568: 92 06 e0 08 add %i3, 8, %o1
4000756c: 15 10 00 1b sethi %hi(0x40006c00), %o2
40007570: 96 10 00 1c mov %i4, %o3
40007574: 40 00 02 df call 400080f0 <pthread_create>
40007578: 94 12 a3 5c or %o2, 0x35c, %o2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
4000757c: ba 92 20 00 orcc %o0, 0, %i5
40007580: 22 80 00 07 be,a 4000759c <rtems_aio_enqueue+0x118> <== ALWAYS TAKEN
40007584: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
40007588: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000758c: 40 00 02 67 call 40007f28 <pthread_mutex_unlock> <== NOT EXECUTED
40007590: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40007594: 81 c7 e0 08 ret <== NOT EXECUTED
40007598: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
++aio_request_queue.active_threads;
4000759c: 82 00 60 01 inc %g1
400075a0: 10 80 00 3a b 40007688 <rtems_aio_enqueue+0x204>
400075a4: c2 26 e0 64 st %g1, [ %i3 + 0x64 ]
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
400075a8: b6 02 20 1c add %o0, 0x1c, %i3
400075ac: 40 00 02 3e call 40007ea4 <pthread_mutex_lock>
400075b0: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
400075b4: 10 80 00 0c b 400075e4 <rtems_aio_enqueue+0x160>
400075b8: 90 10 00 1a mov %i2, %o0
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
400075bc: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
400075c0: 94 10 20 00 clr %o2
400075c4: 7f ff ff 54 call 40007314 <rtems_aio_search_fd>
400075c8: 90 12 22 bc or %o0, 0x2bc, %o0
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
400075cc: b8 92 20 00 orcc %o0, 0, %i4
400075d0: 02 80 00 0d be 40007604 <rtems_aio_enqueue+0x180>
400075d4: b6 07 20 1c add %i4, 0x1c, %i3
{
pthread_mutex_lock (&r_chain->mutex);
400075d8: 40 00 02 33 call 40007ea4 <pthread_mutex_lock>
400075dc: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
400075e0: 90 07 20 08 add %i4, 8, %o0
400075e4: 7f ff fe fc call 400071d4 <rtems_aio_insert_prio>
400075e8: 92 10 00 1d mov %i5, %o1
pthread_cond_signal (&r_chain->cond);
400075ec: 40 00 01 0a call 40007a14 <pthread_cond_signal>
400075f0: 90 07 20 20 add %i4, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
400075f4: 40 00 02 4d call 40007f28 <pthread_mutex_unlock>
400075f8: 90 10 00 1b mov %i3, %o0
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
400075fc: 10 80 00 24 b 4000768c <rtems_aio_enqueue+0x208>
40007600: 11 10 00 60 sethi %hi(0x40018000), %o0
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
40007604: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40007608: 11 10 00 60 sethi %hi(0x40018000), %o0
4000760c: d2 00 40 00 ld [ %g1 ], %o1
40007610: 90 12 22 c8 or %o0, 0x2c8, %o0
40007614: 7f ff ff 40 call 40007314 <rtems_aio_search_fd>
40007618: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
4000761c: 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);
40007620: b8 10 00 08 mov %o0, %i4
40007624: 92 10 00 1d mov %i5, %o1
if (r_chain->new_fd == 1) {
40007628: 80 a0 60 01 cmp %g1, 1
4000762c: 12 80 00 0d bne 40007660 <rtems_aio_enqueue+0x1dc>
40007630: 90 02 20 08 add %o0, 8, %o0
40007634: 40 00 08 c6 call 4000994c <_Chain_Insert>
40007638: 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);
4000763c: 90 07 20 1c add %i4, 0x1c, %o0
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
40007640: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40007644: 40 00 01 c0 call 40007d44 <pthread_mutex_init>
40007648: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
4000764c: 90 07 20 20 add %i4, 0x20, %o0
40007650: 40 00 00 c2 call 40007958 <pthread_cond_init>
40007654: 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)
40007658: 10 80 00 05 b 4000766c <rtems_aio_enqueue+0x1e8>
4000765c: 11 10 00 60 sethi %hi(0x40018000), %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);
40007660: 7f ff fe dd call 400071d4 <rtems_aio_insert_prio>
40007664: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
40007668: 11 10 00 60 sethi %hi(0x40018000), %o0
4000766c: 90 12 22 74 or %o0, 0x274, %o0 ! 40018274 <aio_request_queue>
40007670: c2 02 20 68 ld [ %o0 + 0x68 ], %g1
40007674: 80 a0 60 00 cmp %g1, 0
40007678: 24 80 00 05 ble,a 4000768c <rtems_aio_enqueue+0x208> <== ALWAYS TAKEN
4000767c: 11 10 00 60 sethi %hi(0x40018000), %o0
pthread_cond_signal (&aio_request_queue.new_req);
40007680: 40 00 00 e5 call 40007a14 <pthread_cond_signal> <== NOT EXECUTED
40007684: 90 02 20 04 add %o0, 4, %o0 ! 40018004 <rtems_termios_linesw+0x60><== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
40007688: 11 10 00 60 sethi %hi(0x40018000), %o0
4000768c: 40 00 02 27 call 40007f28 <pthread_mutex_unlock>
40007690: 90 12 22 74 or %o0, 0x274, %o0 ! 40018274 <aio_request_queue>
return 0;
}
40007694: 81 c7 e0 08 ret
40007698: 81 e8 00 00 restore
40006f5c <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
40006f5c: 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);
40006f60: 3b 10 00 60 sethi %hi(0x40018000), %i5
40006f64: ba 17 62 74 or %i5, 0x274, %i5 ! 40018274 <aio_request_queue>
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40006f68: b4 07 60 58 add %i5, 0x58, %i2
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
40006f6c: b2 07 60 4c add %i5, 0x4c, %i1
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
40006f70: a0 07 60 04 add %i5, 4, %l0
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
40006f74: b6 06 20 1c add %i0, 0x1c, %i3
40006f78: 40 00 03 cb call 40007ea4 <pthread_mutex_lock>
40006f7c: 90 10 00 1b mov %i3, %o0
if (result != 0)
40006f80: 80 a2 20 00 cmp %o0, 0
40006f84: 12 80 00 91 bne 400071c8 <rtems_aio_handle+0x26c> <== NEVER TAKEN
40006f88: 82 06 20 0c add %i0, 0xc, %g1
40006f8c: f8 06 20 08 ld [ %i0 + 8 ], %i4
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
40006f90: 80 a7 00 01 cmp %i4, %g1
40006f94: 02 80 00 3b be 40007080 <rtems_aio_handle+0x124>
40006f98: 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);
40006f9c: 40 00 05 d6 call 400086f4 <pthread_self>
40006fa0: 01 00 00 00 nop
40006fa4: 92 07 bf d8 add %fp, -40, %o1
40006fa8: 40 00 04 e3 call 40008334 <pthread_getschedparam>
40006fac: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
40006fb0: c2 07 20 0c ld [ %i4 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
40006fb4: 40 00 05 d0 call 400086f4 <pthread_self>
40006fb8: c2 27 bf e4 st %g1, [ %fp + -28 ]
40006fbc: d2 07 20 08 ld [ %i4 + 8 ], %o1
40006fc0: 40 00 05 d1 call 40008704 <pthread_setschedparam>
40006fc4: 94 07 bf e4 add %fp, -28, %o2
40006fc8: 40 00 0a 48 call 400098e8 <_Chain_Extract>
40006fcc: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
40006fd0: 40 00 03 d6 call 40007f28 <pthread_mutex_unlock>
40006fd4: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
40006fd8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40006fdc: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
40006fe0: 80 a0 a0 02 cmp %g2, 2
40006fe4: 22 80 00 10 be,a 40007024 <rtems_aio_handle+0xc8>
40006fe8: c4 18 60 08 ldd [ %g1 + 8 ], %g2
40006fec: 80 a0 a0 03 cmp %g2, 3
40006ff0: 02 80 00 15 be 40007044 <rtems_aio_handle+0xe8> <== NEVER TAKEN
40006ff4: 80 a0 a0 01 cmp %g2, 1
40006ff8: 32 80 00 19 bne,a 4000705c <rtems_aio_handle+0x100> <== NEVER TAKEN
40006ffc: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
40007000: c4 18 60 08 ldd [ %g1 + 8 ], %g2
40007004: d0 00 40 00 ld [ %g1 ], %o0
40007008: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
4000700c: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
40007010: 96 10 00 02 mov %g2, %o3
40007014: 40 00 29 7f call 40011610 <pread>
40007018: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
4000701c: 10 80 00 0d b 40007050 <rtems_aio_handle+0xf4>
40007020: 80 a2 3f ff cmp %o0, -1
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
40007024: d0 00 40 00 ld [ %g1 ], %o0
40007028: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
4000702c: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
40007030: 96 10 00 02 mov %g2, %o3
40007034: 40 00 29 b5 call 40011708 <pwrite>
40007038: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
4000703c: 10 80 00 05 b 40007050 <rtems_aio_handle+0xf4>
40007040: 80 a2 3f ff cmp %o0, -1
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
40007044: 40 00 19 ef call 4000d800 <fsync> <== NOT EXECUTED
40007048: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
4000704c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
40007050: 32 80 00 09 bne,a 40007074 <rtems_aio_handle+0x118> <== ALWAYS TAKEN
40007054: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
req->aiocbp->return_value = -1;
40007058: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
4000705c: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
40007060: 40 00 26 80 call 40010a60 <__errno> <== NOT EXECUTED
40007064: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
40007068: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
4000706c: 10 bf ff c2 b 40006f74 <rtems_aio_handle+0x18> <== NOT EXECUTED
40007070: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
40007074: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
40007078: 10 bf ff bf b 40006f74 <rtems_aio_handle+0x18>
4000707c: c0 20 60 34 clr [ %g1 + 0x34 ]
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
40007080: 40 00 03 aa call 40007f28 <pthread_mutex_unlock>
40007084: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
40007088: 40 00 03 87 call 40007ea4 <pthread_mutex_lock>
4000708c: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_empty (chain))
40007090: c2 06 20 08 ld [ %i0 + 8 ], %g1
40007094: 80 a0 40 1c cmp %g1, %i4
40007098: 12 80 00 48 bne 400071b8 <rtems_aio_handle+0x25c> <== NEVER TAKEN
4000709c: 92 07 bf dc add %fp, -36, %o1
{
clock_gettime (CLOCK_REALTIME, &timeout);
400070a0: 40 00 01 c9 call 400077c4 <clock_gettime>
400070a4: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
400070a8: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
400070ac: 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;
400070b0: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
400070b4: b8 06 20 20 add %i0, 0x20, %i4
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
400070b8: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
400070bc: 90 10 00 1c mov %i4, %o0
400070c0: 92 10 00 1d mov %i5, %o1
400070c4: 40 00 02 71 call 40007a88 <pthread_cond_timedwait>
400070c8: 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) {
400070cc: 80 a2 20 74 cmp %o0, 0x74
400070d0: 12 80 00 3a bne 400071b8 <rtems_aio_handle+0x25c> <== NEVER TAKEN
400070d4: 01 00 00 00 nop
400070d8: 40 00 0a 04 call 400098e8 <_Chain_Extract>
400070dc: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
400070e0: 40 00 02 c4 call 40007bf0 <pthread_mutex_destroy>
400070e4: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
400070e8: 40 00 01 e5 call 4000787c <pthread_cond_destroy>
400070ec: 90 10 00 1c mov %i4, %o0
free (r_chain);
400070f0: 7f ff f0 7c call 400032e0 <free>
400070f4: 90 10 00 18 mov %i0, %o0
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
400070f8: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
400070fc: 80 a0 40 1a cmp %g1, %i2
40007100: 12 80 00 1b bne 4000716c <rtems_aio_handle+0x210>
40007104: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
40007108: 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;
4000710c: 82 00 60 01 inc %g1
40007110: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
--aio_request_queue.active_threads;
40007114: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
clock_gettime (CLOCK_REALTIME, &timeout);
40007118: 90 10 20 01 mov 1, %o0
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
4000711c: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
40007120: 40 00 01 a9 call 400077c4 <clock_gettime>
40007124: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
timeout.tv_sec += 3;
40007128: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
4000712c: 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;
40007130: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
40007134: 90 10 00 10 mov %l0, %o0
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
40007138: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
4000713c: 92 10 00 1d mov %i5, %o1
40007140: 40 00 02 52 call 40007a88 <pthread_cond_timedwait>
40007144: 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) {
40007148: 80 a2 20 74 cmp %o0, 0x74
4000714c: 12 80 00 08 bne 4000716c <rtems_aio_handle+0x210> <== NEVER TAKEN
40007150: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
40007154: 90 10 00 1d mov %i5, %o0
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
40007158: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
4000715c: 40 00 03 73 call 40007f28 <pthread_mutex_unlock>
40007160: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
40007164: 81 c7 e0 08 ret
40007168: 91 e8 20 00 restore %g0, 0, %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000716c: f0 07 60 54 ld [ %i5 + 0x54 ], %i0
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
40007170: 82 00 7f ff add %g1, -1, %g1
40007174: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
++aio_request_queue.active_threads;
40007178: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
4000717c: 90 10 00 18 mov %i0, %o0
40007180: 82 00 60 01 inc %g1
40007184: 40 00 09 d9 call 400098e8 <_Chain_Extract>
40007188: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
4000718c: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
40007190: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
40007194: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
40007198: 80 a0 c0 02 cmp %g3, %g2
4000719c: 16 80 00 04 bge 400071ac <rtems_aio_handle+0x250>
400071a0: 80 a0 40 19 cmp %g1, %i1
400071a4: 32 bf ff fc bne,a 40007194 <rtems_aio_handle+0x238> <== ALWAYS TAKEN
400071a8: c2 00 40 00 ld [ %g1 ], %g1
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
400071ac: d0 00 60 04 ld [ %g1 + 4 ], %o0
400071b0: 40 00 09 e7 call 4000994c <_Chain_Insert>
400071b4: 92 10 00 18 mov %i0, %o1
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
400071b8: 40 00 03 5c call 40007f28 <pthread_mutex_unlock>
400071bc: 90 10 00 1d mov %i5, %o0
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
400071c0: 10 bf ff 6e b 40006f78 <rtems_aio_handle+0x1c>
400071c4: b6 06 20 1c add %i0, 0x1c, %i3
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
400071c8: b0 10 20 00 clr %i0 <== NOT EXECUTED
400071cc: 81 c7 e0 08 ret <== NOT EXECUTED
400071d0: 81 e8 00 00 restore <== NOT EXECUTED
40007234 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
40007234: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
40007238: 3b 10 00 60 sethi %hi(0x40018000), %i5
4000723c: 40 00 03 93 call 40008088 <pthread_attr_init>
40007240: 90 17 62 7c or %i5, 0x27c, %o0 ! 4001827c <aio_request_queue+0x8>
if (result != 0)
40007244: b0 92 20 00 orcc %o0, 0, %i0
40007248: 12 80 00 31 bne 4000730c <rtems_aio_init+0xd8> <== NEVER TAKEN
4000724c: 90 17 62 7c or %i5, 0x27c, %o0
return result;
result =
40007250: 40 00 03 9a call 400080b8 <pthread_attr_setdetachstate>
40007254: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
40007258: 80 a2 20 00 cmp %o0, 0
4000725c: 22 80 00 05 be,a 40007270 <rtems_aio_init+0x3c> <== ALWAYS TAKEN
40007260: 11 10 00 60 sethi %hi(0x40018000), %o0
pthread_attr_destroy (&aio_request_queue.attr);
40007264: 40 00 03 7d call 40008058 <pthread_attr_destroy> <== NOT EXECUTED
40007268: 90 17 62 7c or %i5, 0x27c, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
4000726c: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
40007270: 92 10 20 00 clr %o1
40007274: 40 00 02 b4 call 40007d44 <pthread_mutex_init>
40007278: 90 12 22 74 or %o0, 0x274, %o0
if (result != 0)
4000727c: 80 a2 20 00 cmp %o0, 0
40007280: 22 80 00 06 be,a 40007298 <rtems_aio_init+0x64> <== ALWAYS TAKEN
40007284: 11 10 00 60 sethi %hi(0x40018000), %o0
pthread_attr_destroy (&aio_request_queue.attr);
40007288: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
4000728c: 40 00 03 73 call 40008058 <pthread_attr_destroy> <== NOT EXECUTED
40007290: 90 12 22 7c or %o0, 0x27c, %o0 ! 4001827c <aio_request_queue+0x8><== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
40007294: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
40007298: 92 10 20 00 clr %o1
4000729c: 40 00 01 af call 40007958 <pthread_cond_init>
400072a0: 90 12 22 78 or %o0, 0x278, %o0
if (result != 0) {
400072a4: b0 92 20 00 orcc %o0, 0, %i0
400072a8: 02 80 00 09 be 400072cc <rtems_aio_init+0x98> <== ALWAYS TAKEN
400072ac: 03 10 00 60 sethi %hi(0x40018000), %g1
pthread_mutex_destroy (&aio_request_queue.mutex);
400072b0: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
400072b4: 40 00 02 4f call 40007bf0 <pthread_mutex_destroy> <== NOT EXECUTED
400072b8: 90 12 22 74 or %o0, 0x274, %o0 ! 40018274 <aio_request_queue><== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
400072bc: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
400072c0: 40 00 03 66 call 40008058 <pthread_attr_destroy> <== NOT EXECUTED
400072c4: 90 12 22 7c or %o0, 0x27c, %o0 ! 4001827c <aio_request_queue+0x8><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400072c8: 03 10 00 60 sethi %hi(0x40018000), %g1 <== NOT EXECUTED
400072cc: 82 10 62 74 or %g1, 0x274, %g1 ! 40018274 <aio_request_queue>
400072d0: 84 00 60 4c add %g1, 0x4c, %g2
400072d4: c4 20 60 48 st %g2, [ %g1 + 0x48 ]
head->previous = NULL;
tail->previous = head;
400072d8: 84 00 60 48 add %g1, 0x48, %g2
400072dc: c4 20 60 50 st %g2, [ %g1 + 0x50 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400072e0: 84 00 60 58 add %g1, 0x58, %g2
400072e4: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
head->previous = NULL;
tail->previous = head;
400072e8: 84 00 60 54 add %g1, 0x54, %g2
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
400072ec: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
400072f0: c4 20 60 5c st %g2, [ %g1 + 0x5c ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
400072f4: c0 20 60 58 clr [ %g1 + 0x58 ]
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
400072f8: 05 00 00 2c sethi %hi(0xb000), %g2
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
400072fc: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
40007300: 84 10 a0 0b or %g2, 0xb, %g2
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
40007304: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
40007308: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
4000730c: 81 c7 e0 08 ret
40007310: 81 e8 00 00 restore
400071d4 <rtems_aio_insert_prio>:
400071d4: 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 );
400071d8: 86 02 20 04 add %o0, 4, %g3
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
400071dc: 80 a0 40 03 cmp %g1, %g3
400071e0: 02 80 00 0e be 40007218 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
400071e4: 84 10 00 09 mov %o1, %g2
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
400071e8: c8 00 60 14 ld [ %g1 + 0x14 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
400071ec: da 02 60 14 ld [ %o1 + 0x14 ], %o5
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
400071f0: c8 01 20 18 ld [ %g4 + 0x18 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
400071f4: 10 80 00 04 b 40007204 <rtems_aio_insert_prio+0x30>
400071f8: da 03 60 18 ld [ %o5 + 0x18 ], %o5
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
400071fc: c8 00 60 14 ld [ %g1 + 0x14 ], %g4 <== NOT EXECUTED
40007200: c8 01 20 18 ld [ %g4 + 0x18 ], %g4 <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
40007204: 80 a3 40 04 cmp %o5, %g4
40007208: 14 80 00 07 bg 40007224 <rtems_aio_insert_prio+0x50> <== NEVER TAKEN
4000720c: 80 a0 40 03 cmp %g1, %g3
40007210: d0 00 60 04 ld [ %g1 + 4 ], %o0
40007214: 92 10 00 02 mov %g2, %o1
40007218: 82 13 c0 00 mov %o7, %g1
4000721c: 40 00 09 cc call 4000994c <_Chain_Insert>
40007220: 9e 10 40 00 mov %g1, %o7
40007224: 32 bf ff f6 bne,a 400071fc <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
40007228: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000722c: 10 bf ff fa b 40007214 <rtems_aio_insert_prio+0x40> <== NOT EXECUTED
40007230: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
40007404 <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)
{
40007404: 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;
40007408: 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 );
4000740c: 82 06 20 04 add %i0, 4, %g1
if (rtems_chain_is_empty (chain))
40007410: 80 a7 40 01 cmp %i5, %g1
40007414: 12 80 00 09 bne 40007438 <rtems_aio_remove_req+0x34>
40007418: b0 10 20 02 mov 2, %i0
4000741c: 81 c7 e0 08 ret
40007420: 81 e8 00 00 restore
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
40007424: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
40007428: 32 80 00 05 bne,a 4000743c <rtems_aio_remove_req+0x38> <== NOT EXECUTED
4000742c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
40007430: 81 c7 e0 08 ret <== NOT EXECUTED
40007434: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
40007438: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4000743c: 80 a0 80 19 cmp %g2, %i1
40007440: 32 bf ff f9 bne,a 40007424 <rtems_aio_remove_req+0x20> <== NEVER TAKEN
40007444: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
40007448: 80 a7 40 01 cmp %i5, %g1
4000744c: 02 bf ff f4 be 4000741c <rtems_aio_remove_req+0x18> <== NEVER TAKEN
40007450: b0 10 20 01 mov 1, %i0
40007454: 40 00 09 25 call 400098e8 <_Chain_Extract>
40007458: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
4000745c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40007460: 84 10 20 8c mov 0x8c, %g2
40007464: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
40007468: 84 10 3f ff mov -1, %g2
free (current);
4000746c: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
40007470: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
40007474: 7f ff ef 9b call 400032e0 <free>
40007478: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
4000747c: 81 c7 e0 08 ret
40007480: 81 e8 00 00 restore
4000c724 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4000c724: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
4000c728: 3b 10 00 67 sethi %hi(0x40019c00), %i5
4000c72c: ba 17 63 74 or %i5, 0x374, %i5 ! 40019f74 <bdbuf_cache>
4000c730: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
4000c734: 80 a0 60 00 cmp %g1, 0
4000c738: 22 80 00 12 be,a 4000c780 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== ALWAYS TAKEN
4000c73c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000c740: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
4000c744: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
4000c748: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000c74c: 32 80 00 0d bne,a 4000c780 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== NOT EXECUTED
4000c750: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4000c754: 7f ff fe 4c call 4000c084 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000c758: 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);
4000c75c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000c760: 7f ff fe 28 call 4000c000 <rtems_bdbuf_lock> <== NOT EXECUTED
4000c764: 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,
4000c768: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000c76c: 7f ff fe 3c call 4000c05c <rtems_bdbuf_unlock> <== NOT EXECUTED
4000c770: 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 ();
4000c774: 7f ff fe 2f call 4000c030 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000c778: 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
4000c77c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
4000c780: 80 a0 60 05 cmp %g1, 5
4000c784: 22 80 00 06 be,a 4000c79c <rtems_bdbuf_add_to_modified_list_after_access+0x78>
4000c788: 03 10 00 61 sethi %hi(0x40018400), %g1
4000c78c: 80 a0 60 03 cmp %g1, 3
4000c790: 12 80 00 06 bne 4000c7a8 <rtems_bdbuf_add_to_modified_list_after_access+0x84>
4000c794: 82 10 20 07 mov 7, %g1
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
4000c798: 03 10 00 61 sethi %hi(0x40018400), %g1
4000c79c: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 40018658 <rtems_bdbuf_configuration+0x10>
4000c7a0: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000c7a4: 82 10 20 07 mov 7, %g1
4000c7a8: 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;
4000c7ac: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000c7b0: 82 10 63 74 or %g1, 0x374, %g1 ! 40019f74 <bdbuf_cache>
4000c7b4: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
the_node->next = tail;
4000c7b8: 86 00 60 50 add %g1, 0x50, %g3
tail->previous = the_node;
4000c7bc: f0 20 60 54 st %i0, [ %g1 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000c7c0: c6 26 00 00 st %g3, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
4000c7c4: f0 20 80 00 st %i0, [ %g2 ]
the_node->previous = old_last;
4000c7c8: c4 26 20 04 st %g2, [ %i0 + 4 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
4000c7cc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
4000c7d0: 80 a0 a0 00 cmp %g2, 0
4000c7d4: 22 80 00 04 be,a 4000c7e4 <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
4000c7d8: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000c7dc: 7f ff fe be call 4000c2d4 <rtems_bdbuf_wake>
4000c7e0: 91 e8 60 64 restore %g1, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
4000c7e4: 80 a0 60 00 cmp %g1, 0
4000c7e8: 02 80 00 04 be 4000c7f8 <rtems_bdbuf_add_to_modified_list_after_access+0xd4>
4000c7ec: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
4000c7f0: 7f ff fe 2b call 4000c09c <rtems_bdbuf_wake_swapper>
4000c7f4: 81 e8 00 00 restore
4000c7f8: 81 c7 e0 08 ret
4000c7fc: 81 e8 00 00 restore
4000c138 <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)
{
4000c138: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4000c13c: c2 06 00 00 ld [ %i0 ], %g1
4000c140: 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 ();
4000c144: 7f ff ff e2 call 4000c0cc <rtems_bdbuf_disable_preemption>
4000c148: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
4000c14c: 7f ff ff ce call 4000c084 <rtems_bdbuf_unlock_cache>
4000c150: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4000c154: d0 06 20 04 ld [ %i0 + 4 ], %o0
4000c158: 92 10 20 00 clr %o1
4000c15c: 7f ff f0 40 call 4000825c <rtems_semaphore_obtain>
4000c160: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
4000c164: 80 a2 20 06 cmp %o0, 6
4000c168: 12 80 00 04 bne 4000c178 <rtems_bdbuf_anonymous_wait+0x40><== ALWAYS TAKEN
4000c16c: 80 a2 20 0d cmp %o0, 0xd
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
4000c170: 10 80 00 04 b 4000c180 <rtems_bdbuf_anonymous_wait+0x48> <== NOT EXECUTED
4000c174: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
4000c178: 02 80 00 04 be 4000c188 <rtems_bdbuf_anonymous_wait+0x50> <== ALWAYS TAKEN
4000c17c: 90 10 20 02 mov 2, %o0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
4000c180: 7f ff ff 9b call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c184: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4000c188: 7f ff ff aa call 4000c030 <rtems_bdbuf_lock_cache>
4000c18c: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
4000c190: 7f ff ff dc call 4000c100 <rtems_bdbuf_restore_preemption>
4000c194: 90 10 00 1d mov %i5, %o0
--waiters->count;
4000c198: c2 06 00 00 ld [ %i0 ], %g1
4000c19c: 82 00 7f ff add %g1, -1, %g1
4000c1a0: c2 26 00 00 st %g1, [ %i0 ]
4000c1a4: 81 c7 e0 08 ret
4000c1a8: 81 e8 00 00 restore
4000c30c <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
4000c30c: 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 ?
4000c310: 03 10 00 61 sethi %hi(0x40018400), %g1
4000c314: d4 00 62 64 ld [ %g1 + 0x264 ], %o2 ! 40018664 <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
4000c318: 80 a2 a0 00 cmp %o2, 0
4000c31c: 12 80 00 03 bne 4000c328 <rtems_bdbuf_create_task.constprop.10+0x1c><== ALWAYS TAKEN
4000c320: 92 10 00 19 mov %i1, %o1
4000c324: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
4000c328: 80 a2 60 00 cmp %o1, 0
4000c32c: 22 80 00 02 be,a 4000c334 <rtems_bdbuf_create_task.constprop.10+0x28><== NEVER TAKEN
4000c330: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
4000c334: 90 10 00 18 mov %i0, %o0
4000c338: 96 10 24 00 mov 0x400, %o3
4000c33c: 98 10 20 00 clr %o4
4000c340: 7f ff f0 52 call 40008488 <rtems_task_create>
4000c344: 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)
4000c348: b0 92 20 00 orcc %o0, 0, %i0
4000c34c: 12 80 00 05 bne 4000c360 <rtems_bdbuf_create_task.constprop.10+0x54><== NEVER TAKEN
4000c350: b2 10 00 1a mov %i2, %i1
sc = rtems_task_start (*id, entry, arg);
4000c354: f0 07 00 00 ld [ %i4 ], %i0
4000c358: 7f ff f0 d9 call 400086bc <rtems_task_start>
4000c35c: 95 e8 00 1b restore %g0, %i3, %o2
return sc;
}
4000c360: 81 c7 e0 08 ret <== NOT EXECUTED
4000c364: 81 e8 00 00 restore <== NOT EXECUTED
4000c0cc <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
4000c0cc: 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);
4000c0d0: 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;
4000c0d4: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000c0d8: 92 10 21 00 mov 0x100, %o1
4000c0dc: 40 00 11 43 call 400105e8 <rtems_task_mode>
4000c0e0: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
4000c0e4: 80 a2 20 00 cmp %o0, 0
4000c0e8: 22 80 00 04 be,a 4000c0f8 <rtems_bdbuf_disable_preemption+0x2c><== ALWAYS TAKEN
4000c0ec: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
4000c0f0: 7f ff ff bf call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c0f4: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
return prev_mode;
}
4000c0f8: 81 c7 e0 08 ret
4000c0fc: 81 e8 00 00 restore
4000d64c <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)
{
4000d64c: 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) +
4000d650: 83 2e a0 04 sll %i2, 4, %g1
4000d654: 82 00 60 20 add %g1, 0x20, %g1
4000d658: 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;
4000d65c: 03 10 00 33 sethi %hi(0x4000cc00), %g1
4000d660: 82 10 63 78 or %g1, 0x378, %g1 ! 4000cf78 <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) +
4000d664: ba 03 a0 60 add %sp, 0x60, %i5
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
4000d668: f6 06 60 18 ld [ %i1 + 0x18 ], %i3
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
4000d66c: 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;
4000d670: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
4000d674: c2 27 60 04 st %g1, [ %i5 + 4 ]
req->io_task = rtems_task_self ();
4000d678: 40 00 0c 3a call 40010760 <rtems_task_self>
4000d67c: c0 27 40 00 clr [ %i5 ]
req->bufnum = 0;
4000d680: c0 27 60 10 clr [ %i5 + 0x10 ]
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
req->io_task = rtems_task_self ();
4000d684: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000d688: 82 10 20 09 mov 9, %g1
4000d68c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
req->io_task = rtems_task_self ();
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
4000d690: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
4000d694: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
4000d698: f6 27 60 18 st %i3, [ %i5 + 0x18 ]
req->bufs [0].length = block_size;
4000d69c: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
4000d6a0: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
4000d6a4: b8 10 00 1d mov %i5, %i4
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
4000d6a8: b2 10 20 01 mov 1, %i1
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
4000d6ac: 10 80 00 16 b 4000d704 <rtems_bdbuf_execute_read_request+0xb8>
4000d6b0: a4 10 20 09 mov 9, %l2
{
media_block += media_blocks_per_block;
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
4000d6b4: 90 10 00 18 mov %i0, %o0
4000d6b8: 92 10 00 1b mov %i3, %o1
4000d6bc: 7f ff fd 4d call 4000cbf0 <rtems_bdbuf_get_buffer_for_read_ahead>
4000d6c0: b8 07 20 10 add %i4, 0x10, %i4
if (bd == NULL)
4000d6c4: 80 a2 20 00 cmp %o0, 0
4000d6c8: 32 80 00 09 bne,a 4000d6ec <rtems_bdbuf_execute_read_request+0xa0><== ALWAYS TAKEN
4000d6cc: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4000d6d0: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
return rtems_bdbuf_execute_transfer_request (dd, req, true);
4000d6d4: 90 10 00 18 mov %i0, %o0
4000d6d8: 92 10 00 1d mov %i5, %o1
4000d6dc: 7f ff fe 2d call 4000cf90 <rtems_bdbuf_execute_transfer_request>
4000d6e0: 94 10 20 01 mov 1, %o2
4000d6e4: 81 c7 e0 08 ret
4000d6e8: 91 e8 00 08 restore %g0, %o0, %o0
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
4000d6ec: d0 27 20 24 st %o0, [ %i4 + 0x24 ]
req->bufs [transfer_index].block = media_block;
4000d6f0: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
req->bufs [transfer_index].length = block_size;
4000d6f4: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
req->bufs [transfer_index].buffer = bd->buffer;
4000d6f8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
4000d6fc: b2 06 60 01 inc %i1
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
4000d700: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
4000d704: 80 a6 40 1a cmp %i1, %i2
4000d708: 2a bf ff eb bcs,a 4000d6b4 <rtems_bdbuf_execute_read_request+0x68>
4000d70c: b6 06 c0 11 add %i3, %l1, %i3
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4000d710: 10 bf ff f1 b 4000d6d4 <rtems_bdbuf_execute_read_request+0x88>
4000d714: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
4000bfec <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
4000bfec: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
4000bff0: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
4000bff4: 7f ff f2 47 call 40008910 <rtems_fatal> <== NOT EXECUTED
4000bff8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000c048 <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
4000c048: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
4000c04c: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
4000c050: 7f ff ff e7 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c054: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
4000dd30 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000dd30: 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 ();
4000dd34: 7f ff f8 bf call 4000c030 <rtems_bdbuf_lock_cache>
4000dd38: 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)
4000dd3c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
4000dd40: 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)
4000dd44: 80 a6 40 01 cmp %i1, %g1
4000dd48: 1a 80 00 26 bcc 4000dde0 <rtems_bdbuf_get+0xb0> <== NEVER TAKEN
4000dd4c: b0 10 20 04 mov 4, %i0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
4000dd50: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000dd54: 80 a2 60 00 cmp %o1, 0
4000dd58: 26 80 00 04 bl,a 4000dd68 <rtems_bdbuf_get+0x38> <== NEVER TAKEN
4000dd5c: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000dd60: 10 80 00 09 b 4000dd84 <rtems_bdbuf_get+0x54>
4000dd64: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4000dd68: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000dd6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000dd70: 40 00 23 20 call 400169f0 <__muldi3> <== NOT EXECUTED
4000dd74: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000dd78: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
4000dd7c: 40 00 25 2e call 40017234 <__udivdi3> <== NOT EXECUTED
4000dd80: 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;
4000dd84: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4000dd88: 90 10 00 1d mov %i5, %o0
4000dd8c: 7f ff fb ac call 4000cc3c <rtems_bdbuf_get_buffer_for_access>
4000dd90: 92 02 40 01 add %o1, %g1, %o1
4000dd94: b8 10 00 08 mov %o0, %i4
switch (bd->state)
4000dd98: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000dd9c: 80 a2 20 02 cmp %o0, 2
4000dda0: 02 80 00 08 be 4000ddc0 <rtems_bdbuf_get+0x90>
4000dda4: 80 a2 20 07 cmp %o0, 7
4000dda8: 02 80 00 0a be 4000ddd0 <rtems_bdbuf_get+0xa0>
4000ddac: 80 a2 20 01 cmp %o0, 1
4000ddb0: 12 80 00 0a bne 4000ddd8 <rtems_bdbuf_get+0xa8> <== NEVER TAKEN
4000ddb4: 82 10 20 05 mov 5, %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ddb8: 10 80 00 04 b 4000ddc8 <rtems_bdbuf_get+0x98>
4000ddbc: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
4000ddc0: 82 10 20 03 mov 3, %g1
4000ddc4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
4000ddc8: 10 80 00 06 b 4000dde0 <rtems_bdbuf_get+0xb0>
4000ddcc: b0 10 20 00 clr %i0
4000ddd0: 10 bf ff fd b 4000ddc4 <rtems_bdbuf_get+0x94>
4000ddd4: 82 10 20 04 mov 4, %g1
* record of this so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
4000ddd8: 7f ff f8 9c call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000dddc: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000dde0: 7f ff f8 a9 call 4000c084 <rtems_bdbuf_unlock_cache>
4000dde4: 01 00 00 00 nop
*bd_ptr = bd;
4000dde8: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
4000ddec: 81 c7 e0 08 ret
4000ddf0: 81 e8 00 00 restore
4000cc3c <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
4000cc3c: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000cc40: 39 10 00 67 sethi %hi(0x40019c00), %i4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cc44: 35 10 00 2f sethi %hi(0x4000bc00), %i2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000cc48: b8 17 23 74 or %i4, 0x374, %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);
4000cc4c: a0 07 20 6c add %i4, 0x6c, %l0
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000cc50: a2 07 20 64 add %i4, 0x64, %l1
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000cc54: a4 07 20 5c add %i4, 0x5c, %l2
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000cc58: b6 07 20 74 add %i4, 0x74, %i3
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000cc5c: a6 07 20 50 add %i4, 0x50, %l3
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000cc60: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
4000cc64: 92 10 00 18 mov %i0, %o1
4000cc68: 7f ff fd 82 call 4000c270 <rtems_bdbuf_avl_search.isra.0>
4000cc6c: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
4000cc70: ba 92 20 00 orcc %o0, 0, %i5
4000cc74: 02 80 00 2f be 4000cd30 <rtems_bdbuf_get_buffer_for_access+0xf4>
4000cc78: 90 10 00 18 mov %i0, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
4000cc7c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
4000cc80: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000cc84: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
4000cc88: 80 a0 80 01 cmp %g2, %g1
4000cc8c: 02 80 00 35 be 4000cd60 <rtems_bdbuf_get_buffer_for_access+0x124>
4000cc90: a8 10 20 08 mov 8, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cc94: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000cc98: 80 a2 20 0a cmp %o0, 0xa
4000cc9c: 18 80 00 4f bgu 4000cdd8 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
4000cca0: 92 10 20 14 mov 0x14, %o1
4000cca4: 82 16 a3 44 or %i2, 0x344, %g1
4000cca8: 91 2a 20 02 sll %o0, 2, %o0
4000ccac: c2 00 40 08 ld [ %g1 + %o0 ], %g1
4000ccb0: 81 c0 40 00 jmp %g1
4000ccb4: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000ccb8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000ccbc: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ccc0: e8 27 60 20 st %l4, [ %i5 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
4000ccc4: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000ccc8: 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;
4000cccc: c2 07 20 60 ld [ %i4 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
4000ccd0: e4 27 40 00 st %l2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
4000ccd4: fa 27 20 60 st %i5, [ %i4 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
4000ccd8: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract_unprotected (&bd->link);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
4000ccdc: 7f ff fc f0 call 4000c09c <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
4000cce0: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cce4: 10 bf ff ed b 4000cc98 <rtems_bdbuf_get_buffer_for_access+0x5c><== NOT EXECUTED
4000cce8: d0 07 60 20 ld [ %i5 + 0x20 ], %o0 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
4000ccec: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000ccf0: 80 a0 60 00 cmp %g1, 0
4000ccf4: 02 80 00 3b be 4000cde0 <rtems_bdbuf_get_buffer_for_access+0x1a4><== NEVER TAKEN
4000ccf8: 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);
4000ccfc: 7f ff fd 0f call 4000c138 <rtems_bdbuf_anonymous_wait>
4000cd00: 90 10 00 1b mov %i3, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000cd04: 10 bf ff d8 b 4000cc64 <rtems_bdbuf_get_buffer_for_access+0x28>
4000cd08: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000cd0c: 90 10 00 1d mov %i5, %o0
4000cd10: 10 80 00 04 b 4000cd20 <rtems_bdbuf_get_buffer_for_access+0xe4>
4000cd14: 92 10 00 11 mov %l1, %o1
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000cd18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000cd1c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000cd20: 7f ff fd 23 call 4000c1ac <rtems_bdbuf_wait>
4000cd24: 01 00 00 00 nop
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cd28: 10 bf ff dc b 4000cc98 <rtems_bdbuf_get_buffer_for_access+0x5c>
4000cd2c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000cd30: 7f ff fe c7 call 4000c84c <rtems_bdbuf_get_buffer_from_lru_list>
4000cd34: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
4000cd38: ba 92 20 00 orcc %o0, 0, %i5
4000cd3c: 32 80 00 0a bne,a 4000cd64 <rtems_bdbuf_get_buffer_for_access+0x128>
4000cd40: 39 10 00 67 sethi %hi(0x40019c00), %i4
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000cd44: c2 07 20 4c ld [ %i4 + 0x4c ], %g1 ! 40019c4c <impure_data+0x334>
4000cd48: 80 a0 40 13 cmp %g1, %l3
4000cd4c: 02 bf ff ec be 4000ccfc <rtems_bdbuf_get_buffer_for_access+0xc0>
4000cd50: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
4000cd54: 7f ff fc d2 call 4000c09c <rtems_bdbuf_wake_swapper>
4000cd58: 01 00 00 00 nop
4000cd5c: 30 bf ff e8 b,a 4000ccfc <rtems_bdbuf_get_buffer_for_access+0xc0>
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000cd60: 39 10 00 67 sethi %hi(0x40019c00), %i4
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cd64: 37 10 00 2f sethi %hi(0x4000bc00), %i3
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000cd68: b8 17 23 e0 or %i4, 0x3e0, %i4
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000cd6c: b4 07 3f f8 add %i4, -8, %i2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cd70: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000cd74: 82 02 3f ff add %o0, -1, %g1
4000cd78: 80 a0 60 09 cmp %g1, 9
4000cd7c: 18 80 00 17 bgu 4000cdd8 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
4000cd80: 92 10 20 13 mov 0x13, %o1
4000cd84: 84 16 e3 1c or %i3, 0x31c, %g2
4000cd88: 83 28 60 02 sll %g1, 2, %g1
4000cd8c: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000cd90: 81 c0 40 00 jmp %g1
4000cd94: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (bd);
4000cd98: 7f ff fc 90 call 4000bfd8 <rtems_bdbuf_group_release>
4000cd9c: 90 10 00 1d mov %i5, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000cda0: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
4000cda4: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
4000cda8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000cdac: 10 80 00 15 b 4000ce00 <rtems_bdbuf_get_buffer_for_access+0x1c4>
4000cdb0: c4 20 40 00 st %g2, [ %g1 ]
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000cdb4: 90 10 00 1d mov %i5, %o0
4000cdb8: 10 80 00 04 b 4000cdc8 <rtems_bdbuf_get_buffer_for_access+0x18c>
4000cdbc: 92 10 00 1a mov %i2, %o1
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000cdc0: 90 10 00 1d mov %i5, %o0
4000cdc4: 92 10 00 1c mov %i4, %o1
4000cdc8: 7f ff fc f9 call 4000c1ac <rtems_bdbuf_wait>
4000cdcc: 01 00 00 00 nop
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000cdd0: 10 bf ff e9 b 4000cd74 <rtems_bdbuf_get_buffer_for_access+0x138>
4000cdd4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
4000cdd8: 7f ff fc 9c call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000cddc: 01 00 00 00 nop <== NOT EXECUTED
{
if (bd->group->bds_per_group != dd->bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000cde0: 7f ff fe 88 call 4000c800 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
4000cde4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000cde8: 7f ff fe 46 call 4000c700 <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
4000cdec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000cdf0: 7f ff fd 39 call 4000c2d4 <rtems_bdbuf_wake> <== NOT EXECUTED
4000cdf4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000cdf8: 10 bf ff 9b b 4000cc64 <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
4000cdfc: d0 07 20 3c ld [ %i4 + 0x3c ], %o0 <== NOT EXECUTED
}
}
while (bd == NULL);
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
4000ce00: 90 10 00 1d mov %i5, %o0
4000ce04: 7f ff fc 70 call 4000bfc4 <rtems_bdbuf_group_obtain>
4000ce08: b0 10 00 1d mov %i5, %i0
return bd;
}
4000ce0c: 81 c7 e0 08 ret
4000ce10: 81 e8 00 00 restore
4000cbf0 <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)
{
4000cbf0: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000cbf4: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000cbf8: d0 00 63 b0 ld [ %g1 + 0x3b0 ], %o0 ! 40019fb0 <bdbuf_cache+0x3c>
4000cbfc: 92 10 00 18 mov %i0, %o1
4000cc00: 94 10 00 19 mov %i1, %o2
4000cc04: 7f ff fd 9b call 4000c270 <rtems_bdbuf_avl_search.isra.0>
4000cc08: ba 10 20 00 clr %i5
if (bd == NULL)
4000cc0c: 80 a2 20 00 cmp %o0, 0
4000cc10: 12 80 00 09 bne 4000cc34 <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
4000cc14: 90 10 00 18 mov %i0, %o0
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000cc18: 7f ff ff 0d call 4000c84c <rtems_bdbuf_get_buffer_from_lru_list>
4000cc1c: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
4000cc20: ba 92 20 00 orcc %o0, 0, %i5
4000cc24: 02 80 00 04 be 4000cc34 <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
4000cc28: 01 00 00 00 nop
rtems_bdbuf_group_obtain (bd);
4000cc2c: 7f ff fc e6 call 4000bfc4 <rtems_bdbuf_group_obtain>
4000cc30: 01 00 00 00 nop
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
4000cc34: 81 c7 e0 08 ret
4000cc38: 91 e8 00 1d restore %g0, %i5, %o0
4000c84c <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)
{
4000c84c: 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;
4000c850: 25 10 00 67 sethi %hi(0x40019c00), %l2
4000c854: 90 14 a3 74 or %l2, 0x374, %o0 ! 40019f74 <bdbuf_cache>
4000c858: f8 02 20 40 ld [ %o0 + 0x40 ], %i4
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4000c85c: a2 02 20 44 add %o0, 0x44, %l1
4000c860: 10 80 00 de b 4000cbd8 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
4000c864: a6 02 20 74 add %o0, 0x74, %l3
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
4000c868: 80 a0 60 00 cmp %g1, 0
4000c86c: 32 80 00 db bne,a 4000cbd8 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
4000c870: f8 07 00 00 ld [ %i4 ], %i4
{
if (bd->group->bds_per_group == dd->bds_per_group)
4000c874: fa 07 20 28 ld [ %i4 + 0x28 ], %i5
4000c878: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
4000c87c: d2 07 60 08 ld [ %i5 + 8 ], %o1
4000c880: 80 a2 40 1b cmp %o1, %i3
4000c884: 32 80 00 06 bne,a 4000c89c <rtems_bdbuf_get_buffer_from_lru_list+0x50>
4000c888: c2 07 60 0c ld [ %i5 + 0xc ], %g1
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000c88c: 7f ff ff dd call 4000c800 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000c890: 90 10 00 1c mov %i4, %o0
4000c894: 10 80 00 30 b 4000c954 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
4000c898: 84 10 00 1c mov %i4, %g2
empty_bd = bd;
}
else if (bd->group->users == 0)
4000c89c: 80 a0 60 00 cmp %g1, 0
4000c8a0: 32 80 00 ce bne,a 4000cbd8 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
4000c8a4: f8 07 00 00 ld [ %i4 ], %i4
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
4000c8a8: d0 04 7f dc ld [ %l1 + -36 ], %o0
4000c8ac: 40 00 26 f9 call 40016490 <.udiv>
4000c8b0: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
for (b = 0, bd = group->bdbuf;
4000c8b4: a0 10 20 00 clr %l0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000c8b8: 83 2a 20 03 sll %o0, 3, %g1
4000c8bc: 91 2a 20 06 sll %o0, 6, %o0
4000c8c0: 10 80 00 05 b 4000c8d4 <rtems_bdbuf_get_buffer_from_lru_list+0x88>
4000c8c4: a8 22 00 01 sub %o0, %g1, %l4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000c8c8: 7f ff ff ce call 4000c800 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000c8cc: a0 04 20 01 inc %l0
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000c8d0: b4 06 80 14 add %i2, %l4, %i2
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4000c8d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000c8d8: 80 a4 00 01 cmp %l0, %g1
4000c8dc: 0a bf ff fb bcs 4000c8c8 <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
4000c8e0: 90 10 00 1a mov %i2, %o0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4000c8e4: 82 14 a3 74 or %l2, 0x374, %g1
4000c8e8: d0 00 60 20 ld [ %g1 + 0x20 ], %o0
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
4000c8ec: f6 27 60 08 st %i3, [ %i5 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4000c8f0: 40 00 26 e8 call 40016490 <.udiv>
4000c8f4: 92 10 00 1b mov %i3, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4000c8f8: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
4000c8fc: 83 2a 20 03 sll %o0, 3, %g1
4000c900: a1 2a 20 06 sll %o0, 6, %l0
4000c904: b6 10 20 01 mov 1, %i3
4000c908: a0 24 00 01 sub %l0, %g1, %l0
4000c90c: 10 80 00 05 b 4000c920 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
4000c910: b4 06 80 10 add %i2, %l0, %i2
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000c914: 7f ff ff 7b call 4000c700 <rtems_bdbuf_make_free_and_add_to_lru_list>
4000c918: b6 06 e0 01 inc %i3
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000c91c: b4 06 80 10 add %i2, %l0, %i2
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4000c920: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000c924: 80 a6 c0 01 cmp %i3, %g1
4000c928: 0a bf ff fb bcs 4000c914 <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
4000c92c: 90 10 00 1a mov %i2, %o0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
4000c930: 80 a6 e0 01 cmp %i3, 1
4000c934: 28 80 00 05 bleu,a 4000c948 <rtems_bdbuf_get_buffer_from_lru_list+0xfc>
4000c938: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000c93c: 7f ff fe 66 call 4000c2d4 <rtems_bdbuf_wake>
4000c940: 90 10 00 13 mov %l3, %o0
return group->bdbuf;
4000c944: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
4000c948: 80 a0 a0 00 cmp %g2, 0
4000c94c: 22 80 00 a3 be,a 4000cbd8 <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
4000c950: f8 07 00 00 ld [ %i4 ], %i4 <== NOT EXECUTED
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
4000c954: f0 20 a0 14 st %i0, [ %g2 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
4000c958: c0 20 a0 08 clr [ %g2 + 8 ]
bd->avl.right = NULL;
4000c95c: c0 20 a0 0c clr [ %g2 + 0xc ]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
4000c960: 07 10 00 67 sethi %hi(0x40019c00), %g3
4000c964: 86 10 e3 74 or %g3, 0x374, %g3 ! 40019f74 <bdbuf_cache>
4000c968: c2 00 e0 3c ld [ %g3 + 0x3c ], %g1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
4000c96c: f2 20 a0 18 st %i1, [ %g2 + 0x18 ]
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
4000c970: c0 20 a0 24 clr [ %g2 + 0x24 ]
rtems_bdbuf_buffer* p = *root;
rtems_bdbuf_buffer* q;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4000c974: ba 07 bf 80 add %fp, -128, %i5
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000c978: b8 10 3f ff mov -1, %i4
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4000c97c: 80 a0 60 00 cmp %g1, 0
4000c980: 12 80 00 1d bne 4000c9f4 <rtems_bdbuf_get_buffer_from_lru_list+0x1a8>
4000c984: b6 10 20 01 mov 1, %i3
{
*root = node;
4000c988: c4 20 e0 3c st %g2, [ %g3 + 0x3c ]
node->avl.left = NULL;
4000c98c: c0 20 a0 08 clr [ %g2 + 8 ]
node->avl.right = NULL;
4000c990: c0 20 a0 0c clr [ %g2 + 0xc ]
node->avl.bal = 0;
4000c994: 10 80 00 8e b 4000cbcc <rtems_bdbuf_get_buffer_from_lru_list+0x380>
4000c998: c0 28 a0 11 clrb [ %g2 + 0x11 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
4000c99c: 32 80 00 0f bne,a 4000c9d8 <rtems_bdbuf_get_buffer_from_lru_list+0x18c><== NEVER TAKEN
4000c9a0: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
4000c9a4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4000c9a8: 80 a0 c0 19 cmp %g3, %i1
4000c9ac: 1a 80 00 08 bcc 4000c9cc <rtems_bdbuf_get_buffer_from_lru_list+0x180>
4000c9b0: 01 00 00 00 nop
{
p->avl.cache = 1;
q = p->avl.right;
4000c9b4: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (q == NULL)
4000c9b8: 80 a0 e0 00 cmp %g3, 0
4000c9bc: 12 80 00 0c bne 4000c9ec <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
4000c9c0: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.right = q = node;
4000c9c4: 10 80 00 12 b 4000ca0c <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
4000c9c8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
break;
}
}
else if ((p->dd != dd) || (p->block != block))
4000c9cc: 02 80 00 7e be 4000cbc4 <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
4000c9d0: 01 00 00 00 nop
{
p->avl.cache = -1;
q = p->avl.left;
4000c9d4: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (q == NULL)
4000c9d8: 80 a0 e0 00 cmp %g3, 0
4000c9dc: 12 80 00 04 bne 4000c9ec <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
4000c9e0: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
4000c9e4: 10 80 00 0a b 4000ca0c <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
4000c9e8: c4 20 60 08 st %g2, [ %g1 + 8 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4000c9ec: ba 10 00 04 mov %g4, %i5
4000c9f0: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000c9f4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4000c9f8: c2 27 40 00 st %g1, [ %i5 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000c9fc: 80 a0 c0 18 cmp %g3, %i0
4000ca00: 0a bf ff ed bcs 4000c9b4 <rtems_bdbuf_get_buffer_from_lru_list+0x168><== NEVER TAKEN
4000ca04: 88 07 60 04 add %i5, 4, %g4
4000ca08: 30 bf ff e5 b,a 4000c99c <rtems_bdbuf_get_buffer_from_lru_list+0x150>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4000ca0c: c0 20 a0 0c clr [ %g2 + 0xc ]
4000ca10: c0 20 a0 08 clr [ %g2 + 8 ]
q->avl.bal = 0;
4000ca14: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
4000ca18: b8 10 20 01 mov 1, %i4
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000ca1c: b4 10 3f ff mov -1, %i2
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000ca20: 10 80 00 03 b 4000ca2c <rtems_bdbuf_get_buffer_from_lru_list+0x1e0>
4000ca24: b2 07 bf 80 add %fp, -128, %i1
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4000ca28: 82 10 00 04 mov %g4, %g1
{
if (p->avl.cache == -1)
4000ca2c: c8 48 60 10 ldsb [ %g1 + 0x10 ], %g4
4000ca30: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
4000ca34: 80 a1 3f ff cmp %g4, -1
{
switch (p->avl.bal)
4000ca38: 87 28 e0 18 sll %g3, 0x18, %g3
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
4000ca3c: 12 80 00 26 bne 4000cad4 <rtems_bdbuf_get_buffer_from_lru_list+0x288>
4000ca40: 87 38 e0 18 sra %g3, 0x18, %g3
{
switch (p->avl.bal)
4000ca44: 80 a0 e0 00 cmp %g3, 0
4000ca48: 22 80 00 4d be,a 4000cb7c <rtems_bdbuf_get_buffer_from_lru_list+0x330>
4000ca4c: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
4000ca50: 80 a0 e0 01 cmp %g3, 1
4000ca54: 02 80 00 28 be 4000caf4 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
4000ca58: 80 a0 ff ff cmp %g3, -1
4000ca5c: 32 80 00 49 bne,a 4000cb80 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
4000ca60: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
4000ca64: 10 80 00 02 b 4000ca6c <rtems_bdbuf_get_buffer_from_lru_list+0x220>
4000ca68: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (p1->avl.bal == -1) /* simple LL-turn */
4000ca6c: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
4000ca70: 80 a1 3f ff cmp %g4, -1
4000ca74: 12 80 00 05 bne 4000ca88 <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
4000ca78: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
4000ca7c: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
4000ca80: 10 80 00 26 b 4000cb18 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
4000ca84: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000ca88: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p1;
4000ca8c: c6 21 20 08 st %g3, [ %g4 + 8 ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000ca90: f0 20 e0 0c st %i0, [ %g3 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000ca94: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p;
4000ca98: c2 21 20 0c st %g1, [ %g4 + 0xc ]
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000ca9c: f0 20 60 08 st %i0, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4000caa0: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
4000caa4: 80 a6 3f ff cmp %i0, -1
4000caa8: 12 80 00 04 bne 4000cab8 <rtems_bdbuf_get_buffer_from_lru_list+0x26c>
4000caac: b6 10 00 04 mov %g4, %i3
4000cab0: 10 80 00 03 b 4000cabc <rtems_bdbuf_get_buffer_from_lru_list+0x270>
4000cab4: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
4000cab8: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000cabc: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000cac0: 80 a0 60 01 cmp %g1, 1
4000cac4: 32 80 00 2a bne,a 4000cb6c <rtems_bdbuf_get_buffer_from_lru_list+0x320>
4000cac8: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000cacc: 10 80 00 28 b 4000cb6c <rtems_bdbuf_get_buffer_from_lru_list+0x320>
4000cad0: f4 28 e0 11 stb %i2, [ %g3 + 0x11 ]
break;
}
}
else
{
switch (p->avl.bal)
4000cad4: 80 a0 e0 00 cmp %g3, 0
4000cad8: 22 80 00 29 be,a 4000cb7c <rtems_bdbuf_get_buffer_from_lru_list+0x330>
4000cadc: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
4000cae0: 80 a0 e0 01 cmp %g3, 1
4000cae4: 02 80 00 06 be 4000cafc <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
4000cae8: 80 a0 ff ff cmp %g3, -1
4000caec: 32 80 00 25 bne,a 4000cb80 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
4000caf0: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
4000caf4: 10 80 00 20 b 4000cb74 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
4000caf8: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
4000cafc: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (p1->avl.bal == 1) /* simple RR-turn */
4000cb00: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
4000cb04: 80 a1 20 01 cmp %g4, 1
4000cb08: 12 80 00 07 bne 4000cb24 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
4000cb0c: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
p->avl.right = p1->avl.left;
4000cb10: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
4000cb14: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.bal = 0;
4000cb18: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000cb1c: 10 80 00 14 b 4000cb6c <rtems_bdbuf_get_buffer_from_lru_list+0x320>
4000cb20: b6 10 00 03 mov %g3, %i3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000cb24: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p1;
4000cb28: c6 21 20 0c st %g3, [ %g4 + 0xc ]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000cb2c: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000cb30: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p;
4000cb34: c2 21 20 08 st %g1, [ %g4 + 8 ]
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000cb38: f0 20 60 0c st %i0, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000cb3c: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
4000cb40: 80 a6 20 01 cmp %i0, 1
4000cb44: 12 80 00 04 bne 4000cb54 <rtems_bdbuf_get_buffer_from_lru_list+0x308><== ALWAYS TAKEN
4000cb48: b6 10 00 04 mov %g4, %i3
4000cb4c: 10 80 00 03 b 4000cb58 <rtems_bdbuf_get_buffer_from_lru_list+0x30c><== NOT EXECUTED
4000cb50: f4 28 60 11 stb %i2, [ %g1 + 0x11 ] <== NOT EXECUTED
4000cb54: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4000cb58: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000cb5c: 80 a0 7f ff cmp %g1, -1
4000cb60: 32 80 00 03 bne,a 4000cb6c <rtems_bdbuf_get_buffer_from_lru_list+0x320><== ALWAYS TAKEN
4000cb64: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000cb68: f8 28 e0 11 stb %i4, [ %g3 + 0x11 ] <== NOT EXECUTED
p = p2;
}
p->avl.bal = 0;
4000cb6c: c0 2e e0 11 clrb [ %i3 + 0x11 ]
4000cb70: 82 10 00 1b mov %i3, %g1
modified = false;
4000cb74: 10 80 00 03 b 4000cb80 <rtems_bdbuf_get_buffer_from_lru_list+0x334>
4000cb78: 86 10 20 00 clr %g3
break;
}
}
else
{
switch (p->avl.bal)
4000cb7c: 86 10 20 01 mov 1, %g3
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000cb80: 80 a7 40 19 cmp %i5, %i1
4000cb84: 28 80 00 09 bleu,a 4000cba8 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
4000cb88: 07 10 00 67 sethi %hi(0x40019c00), %g3
{
p = *--buf_prev;
4000cb8c: c8 07 7f fc ld [ %i5 + -4 ], %g4
if (p->avl.cache == -1)
4000cb90: f6 49 20 10 ldsb [ %g4 + 0x10 ], %i3
4000cb94: 80 a6 ff ff cmp %i3, -1
4000cb98: 32 80 00 06 bne,a 4000cbb0 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000cb9c: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p->avl.left = q;
4000cba0: 10 80 00 04 b 4000cbb0 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000cba4: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.right = q;
}
}
else
{
*root = p;
4000cba8: 10 80 00 09 b 4000cbcc <rtems_bdbuf_get_buffer_from_lru_list+0x380>
4000cbac: c2 20 e3 b0 st %g1, [ %g3 + 0x3b0 ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4000cbb0: 80 88 e0 ff btst 0xff, %g3
4000cbb4: 12 bf ff 9d bne 4000ca28 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
4000cbb8: ba 07 7f fc add %i5, -4, %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000cbbc: 10 80 00 05 b 4000cbd0 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
4000cbc0: 82 10 20 01 mov 1, %g1
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RECYCLE);
4000cbc4: 7f ff fd 0a call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000cbc8: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000cbcc: 82 10 20 01 mov 1, %g1
4000cbd0: 10 80 00 06 b 4000cbe8 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
4000cbd4: c2 20 a0 20 st %g1, [ %g2 + 0x20 ]
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4000cbd8: 80 a7 00 11 cmp %i4, %l1
4000cbdc: 32 bf ff 23 bne,a 4000c868 <rtems_bdbuf_get_buffer_from_lru_list+0x1c>
4000cbe0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
}
node = rtems_chain_next (node);
}
return NULL;
4000cbe4: 84 10 20 00 clr %g2
}
4000cbe8: 81 c7 e0 08 ret
4000cbec: 91 e8 00 02 restore %g0, %g2, %o0
4000d8e8 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
4000d8e8: 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())
4000d8ec: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000d8f0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 ! 4001a828 <_Per_CPU_Information+0x8>
4000d8f4: 80 a0 60 00 cmp %g1, 0
4000d8f8: 12 80 00 16 bne 4000d950 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
4000d8fc: 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)
4000d900: 35 10 00 61 sethi %hi(0x40018400), %i2
4000d904: b4 16 a2 48 or %i2, 0x248, %i2 ! 40018648 <rtems_bdbuf_configuration>
4000d908: f2 06 a0 28 ld [ %i2 + 0x28 ], %i1
4000d90c: f8 06 a0 24 ld [ %i2 + 0x24 ], %i4
4000d910: 90 10 00 19 mov %i1, %o0
4000d914: 92 10 00 1c mov %i4, %o1
4000d918: 40 00 23 8a call 40016740 <.urem>
4000d91c: b0 10 20 0a mov 0xa, %i0
4000d920: 80 a2 20 00 cmp %o0, 0
4000d924: 12 80 01 01 bne 4000dd28 <rtems_bdbuf_init+0x440> <== NEVER TAKEN
4000d928: 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 ();
4000d92c: 7f ff f9 e8 call 4000c0cc <rtems_bdbuf_disable_preemption>
4000d930: 3b 10 00 67 sethi %hi(0x40019c00), %i5
if (bdbuf_cache.initialised)
4000d934: ba 17 63 74 or %i5, 0x374, %i5 ! 40019f74 <bdbuf_cache>
4000d938: c2 0f 60 95 ldub [ %i5 + 0x95 ], %g1
4000d93c: 80 a0 60 00 cmp %g1, 0
4000d940: 02 80 00 06 be 4000d958 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
4000d944: b6 10 00 08 mov %o0, %i3
{
rtems_bdbuf_restore_preemption (prev_mode);
4000d948: 7f ff f9 ee call 4000c100 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
4000d94c: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
4000d950: 81 c7 e0 08 ret <== NOT EXECUTED
4000d954: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4000d958: 92 10 20 00 clr %o1
4000d95c: 94 10 20 98 mov 0x98, %o2
4000d960: 40 00 17 95 call 400137b4 <memset>
4000d964: 90 10 00 1d mov %i5, %o0
bdbuf_cache.initialised = true;
4000d968: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
4000d96c: 90 10 00 1b mov %i3, %o0
4000d970: 7f ff f9 e4 call 4000c100 <rtems_bdbuf_restore_preemption>
4000d974: c2 2f 60 95 stb %g1, [ %i5 + 0x95 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d978: 82 07 60 0c add %i5, 0xc, %g1
4000d97c: c2 27 60 08 st %g1, [ %i5 + 8 ]
head->previous = NULL;
tail->previous = head;
4000d980: 82 07 60 08 add %i5, 8, %g1
4000d984: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d988: 82 07 60 44 add %i5, 0x44, %g1
4000d98c: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
head->previous = NULL;
tail->previous = head;
4000d990: 82 07 60 40 add %i5, 0x40, %g1
4000d994: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d998: 82 07 60 50 add %i5, 0x50, %g1
4000d99c: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
head->previous = NULL;
tail->previous = head;
4000d9a0: 82 07 60 4c add %i5, 0x4c, %g1
4000d9a4: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d9a8: 82 07 60 5c add %i5, 0x5c, %g1
4000d9ac: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
head->previous = NULL;
tail->previous = head;
4000d9b0: 82 07 60 58 add %i5, 0x58, %g1
4000d9b4: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d9b8: 82 07 60 8c add %i5, 0x8c, %g1
4000d9bc: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
head->previous = NULL;
tail->previous = head;
4000d9c0: 82 07 60 88 add %i5, 0x88, %g1
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
4000d9c4: c0 27 60 38 clr [ %i5 + 0x38 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4000d9c8: c0 27 60 0c clr [ %i5 + 0xc ]
4000d9cc: c0 27 60 44 clr [ %i5 + 0x44 ]
4000d9d0: c0 27 60 50 clr [ %i5 + 0x50 ]
4000d9d4: c0 27 60 5c clr [ %i5 + 0x5c ]
4000d9d8: c0 27 60 8c clr [ %i5 + 0x8c ]
tail->previous = head;
4000d9dc: c2 27 60 90 st %g1, [ %i5 + 0x90 ]
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4000d9e0: 37 10 91 10 sethi %hi(0x42444000), %i3
4000d9e4: 92 10 20 01 mov 1, %o1
4000d9e8: 90 16 e3 6c or %i3, 0x36c, %o0
4000d9ec: 94 10 20 54 mov 0x54, %o2
4000d9f0: 96 10 20 00 clr %o3
4000d9f4: 7f ff e9 7d call 40007fe8 <rtems_semaphore_create>
4000d9f8: 98 07 60 28 add %i5, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
4000d9fc: 80 a2 20 00 cmp %o0, 0
4000da00: 12 80 00 a3 bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000da04: 03 10 00 67 sethi %hi(0x40019c00), %g1
goto error;
rtems_bdbuf_lock_cache ();
4000da08: 7f ff f9 8a call 4000c030 <rtems_bdbuf_lock_cache>
4000da0c: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
4000da10: 90 16 e3 73 or %i3, 0x373, %o0
4000da14: 92 10 20 01 mov 1, %o1
4000da18: 94 10 20 54 mov 0x54, %o2
4000da1c: 96 10 20 00 clr %o3
4000da20: 7f ff e9 72 call 40007fe8 <rtems_semaphore_create>
4000da24: 98 07 60 2c add %i5, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
4000da28: 80 a2 20 00 cmp %o0, 0
4000da2c: 12 80 00 98 bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000da30: 03 10 00 67 sethi %hi(0x40019c00), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
4000da34: 90 16 e3 61 or %i3, 0x361, %o0
4000da38: 92 10 20 00 clr %o1
4000da3c: 94 10 20 24 mov 0x24, %o2
4000da40: 96 10 20 00 clr %o3
4000da44: 7f ff e9 69 call 40007fe8 <rtems_semaphore_create>
4000da48: 98 07 60 68 add %i5, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000da4c: 80 a2 20 00 cmp %o0, 0
4000da50: 12 80 00 8f bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000da54: 03 10 00 67 sethi %hi(0x40019c00), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
4000da58: 90 16 e3 74 or %i3, 0x374, %o0
4000da5c: 92 10 20 00 clr %o1
4000da60: 94 10 20 24 mov 0x24, %o2
4000da64: 96 10 20 00 clr %o3
4000da68: 7f ff e9 60 call 40007fe8 <rtems_semaphore_create>
4000da6c: 98 07 60 70 add %i5, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000da70: 80 a2 20 00 cmp %o0, 0
4000da74: 12 80 00 86 bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000da78: 03 10 00 67 sethi %hi(0x40019c00), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
4000da7c: 90 16 e3 62 or %i3, 0x362, %o0
4000da80: 92 10 20 00 clr %o1
4000da84: 94 10 20 24 mov 0x24, %o2
4000da88: 96 10 20 00 clr %o3
4000da8c: 7f ff e9 57 call 40007fe8 <rtems_semaphore_create>
4000da90: 98 07 60 78 add %i5, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000da94: 80 a2 20 00 cmp %o0, 0
4000da98: 12 80 00 7d bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000da9c: 03 10 00 67 sethi %hi(0x40019c00), %g1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4000daa0: d0 06 a0 20 ld [ %i2 + 0x20 ], %o0
4000daa4: 40 00 22 7b call 40016490 <.udiv>
4000daa8: 92 10 00 1c mov %i4, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
4000daac: 92 10 00 1c mov %i4, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4000dab0: b6 10 00 08 mov %o0, %i3
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
4000dab4: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
4000dab8: 40 00 22 76 call 40016490 <.udiv>
4000dabc: 90 10 00 19 mov %i1, %o0
4000dac0: 92 10 00 08 mov %o0, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
4000dac4: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000dac8: 40 00 22 72 call 40016490 <.udiv>
4000dacc: 90 10 00 1b mov %i3, %o0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000dad0: 92 10 00 1b mov %i3, %o1
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
4000dad4: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000dad8: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000dadc: 7f ff d9 24 call 40003f6c <calloc>
4000dae0: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4000dae4: 80 a2 20 00 cmp %o0, 0
4000dae8: 02 80 00 68 be 4000dc88 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
4000daec: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
4000daf0: 90 10 20 14 mov 0x14, %o0
4000daf4: 7f ff d9 1e call 40003f6c <calloc>
4000daf8: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4000dafc: 80 a2 20 00 cmp %o0, 0
4000db00: 02 80 00 62 be 4000dc88 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
4000db04: d0 27 60 80 st %o0, [ %i5 + 0x80 ]
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000db08: 92 10 00 1c mov %i4, %o1
4000db0c: 40 00 22 27 call 400163a8 <.umul>
4000db10: 90 10 00 1b mov %i3, %o0
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
4000db14: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000db18: 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,
4000db1c: 11 10 00 67 sethi %hi(0x40019c00), %o0
4000db20: 40 00 07 24 call 4000f7b0 <rtems_memalign>
4000db24: 90 12 23 8c or %o0, 0x38c, %o0 ! 40019f8c <bdbuf_cache+0x18>
4000db28: 80 a2 20 00 cmp %o0, 0
4000db2c: 12 80 00 58 bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000db30: 03 10 00 67 sethi %hi(0x40019c00), %g1
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4000db34: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000db38: 82 10 63 74 or %g1, 0x374, %g1 ! 40019f74 <bdbuf_cache>
4000db3c: f6 00 60 80 ld [ %g1 + 0x80 ], %i3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000db40: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4000db44: e4 00 60 20 ld [ %g1 + 0x20 ], %l2
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000db48: e0 00 60 18 ld [ %g1 + 0x18 ], %l0
b < bdbuf_cache.buffer_min_count;
4000db4c: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
4000db50: a8 04 bf ff add %l2, -1, %l4
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000db54: ba 10 00 1a mov %i2, %i5
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4000db58: b0 10 00 1b mov %i3, %i0
4000db5c: b2 10 20 00 clr %i1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000db60: a2 10 00 01 mov %g1, %l1
4000db64: 10 80 00 12 b 4000dbac <rtems_bdbuf_init+0x2c4>
4000db68: aa 00 60 44 add %g1, 0x44, %l5
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
bd->group = group;
4000db6c: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
bd->buffer = buffer;
4000db70: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
4000db74: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
the_node->next = tail;
4000db78: ea 27 40 00 st %l5, [ %i5 ]
tail->previous = the_node;
4000db7c: fa 24 60 48 st %i5, [ %l1 + 0x48 ]
old_last->next = the_node;
4000db80: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
4000db84: c2 27 60 04 st %g1, [ %i5 + 4 ]
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4000db88: 90 10 00 19 mov %i1, %o0
4000db8c: 40 00 22 ed call 40016740 <.urem>
4000db90: 92 10 00 12 mov %l2, %o1
4000db94: 80 a2 00 14 cmp %o0, %l4
4000db98: 22 80 00 02 be,a 4000dba0 <rtems_bdbuf_init+0x2b8>
4000db9c: b0 06 20 14 add %i0, 0x14, %i0
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
4000dba0: b2 06 60 01 inc %i1
4000dba4: ba 07 60 38 add %i5, 0x38, %i5
4000dba8: a0 04 00 1c add %l0, %i4, %l0
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4000dbac: 80 a6 40 13 cmp %i1, %l3
4000dbb0: 32 bf ff ef bne,a 4000db6c <rtems_bdbuf_init+0x284>
4000dbb4: c0 27 60 14 clr [ %i5 + 0x14 ]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
4000dbb8: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000dbbc: 82 10 63 74 or %g1, 0x374, %g1 ! 40019f74 <bdbuf_cache>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4000dbc0: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
4000dbc4: c6 00 60 7c ld [ %g1 + 0x7c ], %g3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
4000dbc8: 83 28 a0 03 sll %g2, 3, %g1
4000dbcc: 89 28 a0 06 sll %g2, 6, %g4
4000dbd0: 88 21 00 01 sub %g4, %g1, %g4
4000dbd4: 10 80 00 06 b 4000dbec <rtems_bdbuf_init+0x304>
4000dbd8: 82 10 20 00 clr %g1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4000dbdc: c4 26 e0 08 st %g2, [ %i3 + 8 ]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
4000dbe0: 82 00 60 01 inc %g1
group++,
4000dbe4: b6 06 e0 14 add %i3, 0x14, %i3
bd += bdbuf_cache.max_bds_per_group)
4000dbe8: b4 06 80 04 add %i2, %g4, %i2
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4000dbec: 80 a0 40 03 cmp %g1, %g3
4000dbf0: 32 bf ff fb bne,a 4000dbdc <rtems_bdbuf_init+0x2f4>
4000dbf4: f4 26 e0 10 st %i2, [ %i3 + 0x10 ]
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000dbf8: 35 10 00 61 sethi %hi(0x40018400), %i2
4000dbfc: b8 16 a2 48 or %i2, 0x248, %i4 ! 40018648 <rtems_bdbuf_configuration>
4000dc00: d2 07 20 08 ld [ %i4 + 8 ], %o1
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
4000dc04: 3b 10 00 67 sethi %hi(0x40019c00), %i5
4000dc08: b6 10 20 01 mov 1, %i3
4000dc0c: ba 17 63 74 or %i5, 0x374, %i5
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000dc10: 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;
4000dc14: f6 2f 60 04 stb %i3, [ %i5 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000dc18: 90 12 23 50 or %o0, 0x350, %o0
4000dc1c: 15 10 00 34 sethi %hi(0x4000d000), %o2
4000dc20: 96 10 20 00 clr %o3
4000dc24: 94 12 a2 a0 or %o2, 0x2a0, %o2
4000dc28: 7f ff f9 b9 call 4000c30c <rtems_bdbuf_create_task.constprop.10>
4000dc2c: 98 10 00 1d mov %i5, %o4
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
4000dc30: 80 a2 20 00 cmp %o0, 0
4000dc34: 12 80 00 16 bne 4000dc8c <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000dc38: 03 10 00 67 sethi %hi(0x40019c00), %g1
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
4000dc3c: c2 06 a2 48 ld [ %i2 + 0x248 ], %g1
4000dc40: 80 a0 60 00 cmp %g1, 0
4000dc44: 32 80 00 06 bne,a 4000dc5c <rtems_bdbuf_init+0x374>
4000dc48: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
goto error;
}
rtems_bdbuf_unlock_cache ();
4000dc4c: 7f ff f9 0e call 4000c084 <rtems_bdbuf_unlock_cache>
4000dc50: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000dc54: 81 c7 e0 08 ret
4000dc58: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
{
bdbuf_cache.read_ahead_enabled = true;
4000dc5c: f6 2f 60 94 stb %i3, [ %i5 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000dc60: 11 10 94 91 sethi %hi(0x42524400), %o0
4000dc64: 15 10 00 35 sethi %hi(0x4000d400), %o2
4000dc68: 90 12 20 41 or %o0, 0x41, %o0
4000dc6c: 94 12 a3 18 or %o2, 0x318, %o2
4000dc70: 96 10 20 00 clr %o3
4000dc74: 7f ff f9 a6 call 4000c30c <rtems_bdbuf_create_task.constprop.10>
4000dc78: 98 07 60 84 add %i5, 0x84, %o4
bdbuf_config.read_ahead_priority,
RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_read_ahead_task,
0,
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
4000dc7c: 80 a2 20 00 cmp %o0, 0
4000dc80: 02 bf ff f3 be 4000dc4c <rtems_bdbuf_init+0x364> <== ALWAYS TAKEN
4000dc84: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
4000dc88: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED
4000dc8c: d0 00 63 f8 ld [ %g1 + 0x3f8 ], %o0 ! 40019ff8 <bdbuf_cache+0x84><== NOT EXECUTED
4000dc90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dc94: 02 80 00 05 be 4000dca8 <rtems_bdbuf_init+0x3c0> <== NOT EXECUTED
4000dc98: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
4000dc9c: 7f ff ea 45 call 400085b0 <rtems_task_delete> <== NOT EXECUTED
4000dca0: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
4000dca4: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED
4000dca8: d0 00 63 74 ld [ %g1 + 0x374 ], %o0 ! 40019f74 <bdbuf_cache><== NOT EXECUTED
4000dcac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dcb0: 02 80 00 04 be 4000dcc0 <rtems_bdbuf_init+0x3d8> <== NOT EXECUTED
4000dcb4: 3b 10 00 67 sethi %hi(0x40019c00), %i5 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
4000dcb8: 7f ff ea 3e call 400085b0 <rtems_task_delete> <== NOT EXECUTED
4000dcbc: 01 00 00 00 nop <== NOT EXECUTED
free (bdbuf_cache.buffers);
4000dcc0: ba 17 63 74 or %i5, 0x374, %i5 <== NOT EXECUTED
4000dcc4: 7f ff d8 e2 call 4000404c <free> <== NOT EXECUTED
4000dcc8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
4000dccc: 7f ff d8 e0 call 4000404c <free> <== NOT EXECUTED
4000dcd0: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
4000dcd4: 7f ff d8 de call 4000404c <free> <== NOT EXECUTED
4000dcd8: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
4000dcdc: 7f ff e9 31 call 400081a0 <rtems_semaphore_delete> <== NOT EXECUTED
4000dce0: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
4000dce4: 7f ff e9 2f call 400081a0 <rtems_semaphore_delete> <== NOT EXECUTED
4000dce8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
4000dcec: 7f ff e9 2d call 400081a0 <rtems_semaphore_delete> <== NOT EXECUTED
4000dcf0: d0 07 60 70 ld [ %i5 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
4000dcf4: 7f ff e9 2b call 400081a0 <rtems_semaphore_delete> <== NOT EXECUTED
4000dcf8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
4000dcfc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
4000dd00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000dd04: 02 80 00 07 be 4000dd20 <rtems_bdbuf_init+0x438> <== NOT EXECUTED
4000dd08: 03 10 00 68 sethi %hi(0x4001a000), %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4000dd0c: 7f ff f8 de call 4000c084 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000dd10: 01 00 00 00 nop <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
4000dd14: 7f ff e9 23 call 400081a0 <rtems_semaphore_delete> <== NOT EXECUTED
4000dd18: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
4000dd1c: 03 10 00 68 sethi %hi(0x4001a000), %g1 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
4000dd20: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
4000dd24: c0 28 60 09 clrb [ %g1 + 9 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
4000dd28: 81 c7 e0 08 ret <== NOT EXECUTED
4000dd2c: 81 e8 00 00 restore <== NOT EXECUTED
4000c000 <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)
{
4000c000: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
4000c004: 92 10 20 00 clr %o1
4000c008: 90 10 00 18 mov %i0, %o0
4000c00c: 7f ff f0 94 call 4000825c <rtems_semaphore_obtain>
4000c010: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4000c014: 80 a2 20 00 cmp %o0, 0
4000c018: 02 80 00 04 be 4000c028 <rtems_bdbuf_lock+0x28> <== ALWAYS TAKEN
4000c01c: 01 00 00 00 nop
rtems_bdbuf_fatal (fatal_error_code);
4000c020: 7f ff ff f3 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c024: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000c028: 81 c7 e0 08 ret
4000c02c: 81 e8 00 00 restore
4000e2bc <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
4000e2bc: 9d e3 bf 10 save %sp, -240, %sp
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
4000e2c0: 82 07 bf 74 add %fp, -140, %g1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000e2c4: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
tail->previous = head;
4000e2c8: c2 27 bf 7c st %g1, [ %fp + -132 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000e2cc: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
4000e2d0: 7f ff f7 58 call 4000c030 <rtems_bdbuf_lock_cache>
4000e2d4: c0 27 bf 78 clr [ %fp + -136 ]
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
4000e2d8: 7f ff fd 5c call 4000d848 <rtems_bdbuf_read_ahead_cancel>
4000e2dc: 90 10 00 18 mov %i0, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000e2e0: 82 10 3f ff mov -1, %g1
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
4000e2e4: 11 10 00 67 sethi %hi(0x40019c00), %o0
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4000e2e8: 35 10 00 2f sethi %hi(0x4000bc00), %i2
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
4000e2ec: 90 12 23 74 or %o0, 0x374, %o0
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000e2f0: c2 26 20 6c st %g1, [ %i0 + 0x6c ]
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
4000e2f4: fa 02 20 3c ld [ %o0 + 0x3c ], %i5
*prev = NULL;
4000e2f8: c0 27 bf 80 clr [ %fp + -128 ]
static void
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
4000e2fc: b8 07 bf 80 add %fp, -128, %i4
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4000e300: b4 16 a3 70 or %i2, 0x370, %i2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e304: b2 10 20 06 mov 6, %i1
4000e308: a0 10 20 0a mov 0xa, %l0
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4000e30c: 10 80 00 3a b 4000e3f4 <rtems_bdbuf_purge_dev+0x138>
4000e310: a2 02 20 6c add %o0, 0x6c, %l1
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
4000e314: 80 a0 40 18 cmp %g1, %i0
4000e318: 32 80 00 1e bne,a 4000e390 <rtems_bdbuf_purge_dev+0xd4>
4000e31c: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
switch (cur->state)
4000e320: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000e324: 80 a0 60 0a cmp %g1, 0xa
4000e328: 18 80 00 17 bgu 4000e384 <rtems_bdbuf_purge_dev+0xc8> <== NEVER TAKEN
4000e32c: 83 28 60 02 sll %g1, 2, %g1
4000e330: c2 06 80 01 ld [ %i2 + %g1 ], %g1
4000e334: 81 c0 40 00 jmp %g1
4000e338: 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);
4000e33c: 7f ff f7 e6 call 4000c2d4 <rtems_bdbuf_wake>
4000e340: 90 10 00 11 mov %l1, %o0
/* Fall through */
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (cur);
4000e344: 7f ff f7 25 call 4000bfd8 <rtems_bdbuf_group_release>
4000e348: 90 10 00 1d mov %i5, %o0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000e34c: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000e350: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
next->previous = previous;
4000e354: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000e358: 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;
4000e35c: c2 07 bf 7c ld [ %fp + -132 ], %g1
the_node->next = tail;
4000e360: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
4000e364: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
4000e368: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
4000e36c: 10 80 00 08 b 4000e38c <rtems_bdbuf_purge_dev+0xd0>
4000e370: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e374: 10 80 00 06 b 4000e38c <rtems_bdbuf_purge_dev+0xd0>
4000e378: e0 27 60 20 st %l0, [ %i5 + 0x20 ]
4000e37c: 10 80 00 04 b 4000e38c <rtems_bdbuf_purge_dev+0xd0>
4000e380: f2 27 60 20 st %i1, [ %i5 + 0x20 ]
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
4000e384: 7f ff f7 1a call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e388: 90 10 20 17 mov 0x17, %o0 <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
4000e38c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e390: 80 a0 60 00 cmp %g1, 0
4000e394: 22 80 00 04 be,a 4000e3a4 <rtems_bdbuf_purge_dev+0xe8>
4000e398: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
4000e39c: 10 80 00 06 b 4000e3b4 <rtems_bdbuf_purge_dev+0xf8>
4000e3a0: fa 27 20 04 st %i5, [ %i4 + 4 ]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
4000e3a4: 80 a0 60 00 cmp %g1, 0
4000e3a8: 22 80 00 08 be,a 4000e3c8 <rtems_bdbuf_purge_dev+0x10c>
4000e3ac: c2 07 00 00 ld [ %i4 ], %g1
{
/* Right */
++prev;
*prev = cur;
4000e3b0: fa 27 20 04 st %i5, [ %i4 + 4 ]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
4000e3b4: 10 80 00 0f b 4000e3f0 <rtems_bdbuf_purge_dev+0x134>
4000e3b8: b8 07 20 04 add %i4, 4, %i4
while (*prev != NULL
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
{
/* Up */
cur = *prev;
--prev;
4000e3bc: b8 07 3f fc add %i4, -4, %i4
4000e3c0: ba 10 00 01 mov %g1, %i5
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
4000e3c4: c2 07 00 00 ld [ %i4 ], %g1
4000e3c8: 80 a0 60 00 cmp %g1, 0
4000e3cc: 22 80 00 0a be,a 4000e3f4 <rtems_bdbuf_purge_dev+0x138>
4000e3d0: ba 10 00 01 mov %g1, %i5
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
4000e3d4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000e3d8: 80 a7 40 02 cmp %i5, %g2
4000e3dc: 02 bf ff f8 be 4000e3bc <rtems_bdbuf_purge_dev+0x100>
4000e3e0: 80 a0 a0 00 cmp %g2, 0
4000e3e4: 22 bf ff f7 be,a 4000e3c0 <rtems_bdbuf_purge_dev+0x104>
4000e3e8: b8 07 3f fc add %i4, -4, %i4
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
4000e3ec: 82 10 00 02 mov %g2, %g1
4000e3f0: ba 10 00 01 mov %g1, %i5
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
4000e3f4: 80 a7 60 00 cmp %i5, 0
4000e3f8: 32 bf ff c7 bne,a 4000e314 <rtems_bdbuf_purge_dev+0x58>
4000e3fc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
4000e400: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e404: 10 80 00 0c b 4000e434 <rtems_bdbuf_purge_dev+0x178>
4000e408: b6 10 20 01 mov 1, %i3
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
4000e40c: 80 a0 60 00 cmp %g1, 0
4000e410: 22 80 00 02 be,a 4000e418 <rtems_bdbuf_purge_dev+0x15c>
4000e414: b8 10 20 01 mov 1, %i4
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4000e418: 80 a0 60 00 cmp %g1, 0
4000e41c: 12 80 00 06 bne 4000e434 <rtems_bdbuf_purge_dev+0x178>
4000e420: f6 27 60 20 st %i3, [ %i5 + 0x20 ]
{
rtems_bdbuf_remove_from_tree (bd);
4000e424: 7f ff f7 d1 call 4000c368 <rtems_bdbuf_remove_from_tree>
4000e428: 90 10 00 1d mov %i5, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000e42c: 7f ff f8 b5 call 4000c700 <rtems_bdbuf_make_free_and_add_to_lru_list>
4000e430: 90 10 00 1d mov %i5, %o0
4000e434: 7f ff f6 da call 4000bf9c <_Chain_Get_unprotected>
4000e438: 90 07 bf 74 add %fp, -140, %o0
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
4000e43c: ba 92 20 00 orcc %o0, 0, %i5
4000e440: 32 bf ff f3 bne,a 4000e40c <rtems_bdbuf_purge_dev+0x150>
4000e444: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
4000e448: 80 8f 20 ff btst 0xff, %i4
4000e44c: 02 80 00 04 be 4000e45c <rtems_bdbuf_purge_dev+0x1a0>
4000e450: 11 10 00 67 sethi %hi(0x40019c00), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000e454: 7f ff f7 a0 call 4000c2d4 <rtems_bdbuf_wake>
4000e458: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 40019fe8 <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 ();
4000e45c: 7f ff f7 0a call 4000c084 <rtems_bdbuf_unlock_cache>
4000e460: 01 00 00 00 nop
4000e464: 81 c7 e0 08 ret
4000e468: 81 e8 00 00 restore
4000ddf4 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000ddf4: 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 ();
4000ddf8: 7f ff f8 8e call 4000c030 <rtems_bdbuf_lock_cache>
4000ddfc: 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)
4000de00: 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;
4000de04: 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)
4000de08: 80 a6 40 01 cmp %i1, %g1
4000de0c: 1a 80 00 71 bcc 4000dfd0 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
4000de10: b0 10 20 04 mov 4, %i0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
4000de14: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000de18: 80 a2 60 00 cmp %o1, 0
4000de1c: 26 80 00 04 bl,a 4000de2c <rtems_bdbuf_read+0x38> <== NEVER TAKEN
4000de20: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000de24: 10 80 00 09 b 4000de48 <rtems_bdbuf_read+0x54>
4000de28: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4000de2c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000de30: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000de34: 40 00 22 ef call 400169f0 <__muldi3> <== NOT EXECUTED
4000de38: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000de3c: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
4000de40: 40 00 24 fd call 40017234 <__udivdi3> <== NOT EXECUTED
4000de44: 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;
4000de48: 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);
4000de4c: 90 10 00 1d mov %i5, %o0
4000de50: 7f ff fb 7b call 4000cc3c <rtems_bdbuf_get_buffer_for_access>
4000de54: 92 02 40 01 add %o1, %g1, %o1
4000de58: b8 10 00 08 mov %o0, %i4
switch (bd->state)
4000de5c: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000de60: 80 a2 20 02 cmp %o0, 2
4000de64: 02 80 00 08 be 4000de84 <rtems_bdbuf_read+0x90>
4000de68: 80 a2 20 07 cmp %o0, 7
4000de6c: 02 80 00 0b be 4000de98 <rtems_bdbuf_read+0xa4>
4000de70: 80 a2 20 01 cmp %o0, 1
4000de74: 12 80 00 2d bne 4000df28 <rtems_bdbuf_read+0x134> <== NEVER TAKEN
4000de78: 01 00 00 00 nop
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
4000de7c: 10 80 00 0e b 4000deb4 <rtems_bdbuf_read+0xc0>
4000de80: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
4000de84: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4000de88: 82 00 60 01 inc %g1
4000de8c: 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;
4000de90: 10 80 00 06 b 4000dea8 <rtems_bdbuf_read+0xb4>
4000de94: 82 10 20 03 mov 3, %g1
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
4000de98: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4000de9c: 82 00 60 01 inc %g1
4000dea0: 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;
4000dea4: 82 10 20 04 mov 4, %g1
4000dea8: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
4000deac: 10 80 00 21 b 4000df30 <rtems_bdbuf_read+0x13c>
4000deb0: b0 10 20 00 clr %i0
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
4000deb4: 82 00 60 01 inc %g1
4000deb8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
4000debc: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
4000dec0: 80 a0 40 19 cmp %g1, %i1
4000dec4: 02 80 00 09 be 4000dee8 <rtems_bdbuf_read+0xf4>
4000dec8: 90 10 00 1d mov %i5, %o0
{
rtems_bdbuf_read_ahead_cancel (dd);
4000decc: 7f ff fe 5f call 4000d848 <rtems_bdbuf_read_ahead_cancel>
4000ded0: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = block + 1;
4000ded4: 82 06 60 01 add %i1, 1, %g1
4000ded8: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
4000dedc: 82 06 60 02 add %i1, 2, %g1
4000dee0: 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);
4000dee4: 90 10 00 1d mov %i5, %o0
4000dee8: 92 10 00 1c mov %i4, %o1
4000deec: 7f ff fd d8 call 4000d64c <rtems_bdbuf_execute_read_request>
4000def0: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
4000def4: b0 92 20 00 orcc %o0, 0, %i0
4000def8: 32 80 00 0e bne,a 4000df30 <rtems_bdbuf_read+0x13c>
4000defc: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000df00: 82 10 20 03 mov 3, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000df04: c4 07 00 00 ld [ %i4 ], %g2
4000df08: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
previous = the_node->previous;
4000df0c: c2 07 20 04 ld [ %i4 + 4 ], %g1
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
rtems_chain_extract_unprotected (&bd->link);
rtems_bdbuf_group_obtain (bd);
4000df10: 90 10 00 1c mov %i4, %o0
next->previous = previous;
4000df14: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000df18: 7f ff f8 2b call 4000bfc4 <rtems_bdbuf_group_obtain>
4000df1c: c4 20 40 00 st %g2, [ %g1 ]
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
4000df20: 10 80 00 05 b 4000df34 <rtems_bdbuf_read+0x140>
4000df24: 03 10 00 67 sethi %hi(0x40019c00), %g1
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4000df28: 7f ff f8 48 call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000df2c: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
4000df30: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000df34: d0 00 63 f8 ld [ %g1 + 0x3f8 ], %o0 ! 40019ff8 <bdbuf_cache+0x84>
4000df38: 80 a2 20 00 cmp %o0, 0
4000df3c: 02 80 00 25 be 4000dfd0 <rtems_bdbuf_read+0x1dc>
4000df40: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
4000df44: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
4000df48: 80 a0 40 19 cmp %g1, %i1
4000df4c: 12 80 00 21 bne 4000dfd0 <rtems_bdbuf_read+0x1dc>
4000df50: 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);
4000df54: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
4000df58: 80 a0 a0 00 cmp %g2, 0
4000df5c: 12 80 00 05 bne 4000df70 <rtems_bdbuf_read+0x17c> <== NEVER TAKEN
4000df60: 82 10 20 00 clr %g1
4000df64: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
4000df68: 80 a0 00 01 cmp %g0, %g1
4000df6c: 82 60 3f ff subx %g0, -1, %g1
&& !rtems_bdbuf_is_read_ahead_active (dd))
4000df70: 80 a0 60 00 cmp %g1, 0
4000df74: 02 80 00 17 be 4000dfd0 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
4000df78: 03 10 00 67 sethi %hi(0x40019c00), %g1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000df7c: 82 10 63 74 or %g1, 0x374, %g1 ! 40019f74 <bdbuf_cache>
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
4000df80: c4 00 60 88 ld [ %g1 + 0x88 ], %g2
4000df84: 82 00 60 8c add %g1, 0x8c, %g1
4000df88: 80 a0 80 01 cmp %g2, %g1
4000df8c: 12 80 00 09 bne 4000dfb0 <rtems_bdbuf_read+0x1bc> <== NEVER TAKEN
4000df90: 03 10 00 67 sethi %hi(0x40019c00), %g1
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
4000df94: 7f ff e7 85 call 40007da8 <rtems_event_send>
4000df98: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
4000df9c: 80 a2 20 00 cmp %o0, 0
4000dfa0: 02 80 00 04 be 4000dfb0 <rtems_bdbuf_read+0x1bc> <== ALWAYS TAKEN
4000dfa4: 03 10 00 67 sethi %hi(0x40019c00), %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
4000dfa8: 7f ff f8 11 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000dfac: 90 10 20 07 mov 7, %o0 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000dfb0: 82 10 63 74 or %g1, 0x374, %g1
4000dfb4: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
4000dfb8: 86 07 60 64 add %i5, 0x64, %g3
the_node->next = tail;
4000dfbc: 88 00 60 8c add %g1, 0x8c, %g4
tail->previous = the_node;
4000dfc0: c6 20 60 90 st %g3, [ %g1 + 0x90 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000dfc4: c8 27 60 64 st %g4, [ %i5 + 0x64 ]
tail->previous = the_node;
old_last->next = the_node;
4000dfc8: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
4000dfcc: c4 27 60 68 st %g2, [ %i5 + 0x68 ]
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
4000dfd0: 7f ff f8 2d call 4000c084 <rtems_bdbuf_unlock_cache>
4000dfd4: 01 00 00 00 nop
*bd_ptr = bd;
4000dfd8: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
4000dfdc: 81 c7 e0 08 ret
4000dfe0: 81 e8 00 00 restore
4000d848 <rtems_bdbuf_read_ahead_cancel>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
4000d848: c2 02 20 64 ld [ %o0 + 0x64 ], %g1
4000d84c: 80 a0 60 00 cmp %g1, 0
4000d850: 12 80 00 05 bne 4000d864 <rtems_bdbuf_read_ahead_cancel+0x1c><== NEVER TAKEN
4000d854: 84 10 20 00 clr %g2
4000d858: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
4000d85c: 80 a0 00 02 cmp %g0, %g2
4000d860: 84 60 3f ff subx %g0, -1, %g2
}
static void
rtems_bdbuf_read_ahead_cancel (rtems_disk_device *dd)
{
if (rtems_bdbuf_is_read_ahead_active (dd))
4000d864: 80 a0 a0 00 cmp %g2, 0
4000d868: 12 80 00 07 bne 4000d884 <rtems_bdbuf_read_ahead_cancel+0x3c><== ALWAYS TAKEN
4000d86c: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000d870: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
next->previous = previous;
4000d874: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
4000d878: 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;
4000d87c: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED
4000d880: c0 22 20 64 clr [ %o0 + 0x64 ] <== NOT EXECUTED
4000d884: 81 c3 e0 08 retl
4000d718 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
4000d718: 9d e3 bf a0 save %sp, -96, %sp
4000d71c: 33 10 00 67 sethi %hi(0x40019c00), %i1
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
4000d720: 35 10 00 67 sethi %hi(0x40019c00), %i2
4000d724: b2 16 63 fc or %i1, 0x3fc, %i1
4000d728: 10 80 00 41 b 4000d82c <rtems_bdbuf_read_ahead_task+0x114>
4000d72c: 31 10 00 61 sethi %hi(0x40018400), %i0
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
4000d730: 7f ff fa ac call 4000c1e0 <rtems_bdbuf_wait_for_event>
4000d734: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
4000d738: 7f ff fa 3e call 4000c030 <rtems_bdbuf_lock_cache>
4000d73c: 01 00 00 00 nop
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
4000d740: 30 80 00 34 b,a 4000d810 <rtems_bdbuf_read_ahead_task+0xf8>
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
4000d744: c4 07 7f c4 ld [ %i5 + -60 ], %g2
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
rtems_blkdev_bnum media_block = 0;
4000d748: 92 10 20 00 clr %o1
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
4000d74c: 80 a7 00 02 cmp %i4, %g2
4000d750: 1a 80 00 11 bcc 4000d794 <rtems_bdbuf_read_ahead_task+0x7c>
4000d754: 82 10 20 04 mov 4, %g1
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
4000d758: d2 07 7f cc ld [ %i5 + -52 ], %o1
4000d75c: 80 a2 60 00 cmp %o1, 0
4000d760: 16 80 00 0a bge 4000d788 <rtems_bdbuf_read_ahead_task+0x70><== ALWAYS TAKEN
4000d764: 93 2f 00 09 sll %i4, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4000d768: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
4000d76c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000d770: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000d774: 40 00 24 9f call 400169f0 <__muldi3> <== NOT EXECUTED
4000d778: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000d77c: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
4000d780: 40 00 26 ad call 40017234 <__udivdi3> <== NOT EXECUTED
4000d784: 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;
4000d788: c2 07 7f b4 ld [ %i5 + -76 ], %g1
4000d78c: 92 02 40 01 add %o1, %g1, %o1
4000d790: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4000d794: c0 27 60 04 clr [ %i5 + 4 ]
rtems_status_code sc =
rtems_bdbuf_get_media_block (dd, block, &media_block);
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
4000d798: 80 a0 60 00 cmp %g1, 0
4000d79c: 12 80 00 1b bne 4000d808 <rtems_bdbuf_read_ahead_task+0xf0>
4000d7a0: c0 27 40 00 clr [ %i5 ]
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
4000d7a4: b6 07 7f 9c add %i5, -100, %i3
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
4000d7a8: 7f ff fd 12 call 4000cbf0 <rtems_bdbuf_get_buffer_for_read_ahead>
4000d7ac: 90 10 00 1b mov %i3, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
4000d7b0: 92 92 20 00 orcc %o0, 0, %o1
4000d7b4: 02 80 00 17 be 4000d810 <rtems_bdbuf_read_ahead_task+0xf8><== NEVER TAKEN
4000d7b8: c2 06 22 48 ld [ %i0 + 0x248 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
4000d7bc: d4 07 7f c4 ld [ %i5 + -60 ], %o2
4000d7c0: 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)
4000d7c4: 80 a2 80 01 cmp %o2, %g1
4000d7c8: 2a 80 00 09 bcs,a 4000d7ec <rtems_bdbuf_read_ahead_task+0xd4>
4000d7cc: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
4000d7d0: 85 30 60 01 srl %g1, 1, %g2
dd->read_ahead.next = block + transfer_count;
4000d7d4: 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;
4000d7d8: 84 00 80 1c add %g2, %i4, %g2
dd->read_ahead.next = block + transfer_count;
4000d7dc: b8 00 40 1c add %g1, %i4, %i4
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
4000d7e0: c4 27 60 08 st %g2, [ %i5 + 8 ]
dd->read_ahead.next = block + transfer_count;
4000d7e4: 10 80 00 03 b 4000d7f0 <rtems_bdbuf_read_ahead_task+0xd8>
4000d7e8: f8 27 60 0c st %i4, [ %i5 + 0xc ]
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000d7ec: c2 27 60 08 st %g1, [ %i5 + 8 ]
}
++dd->stats.read_ahead_transfers;
4000d7f0: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000d7f4: 90 10 00 1b mov %i3, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
4000d7f8: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000d7fc: 7f ff ff 94 call 4000d64c <rtems_bdbuf_execute_read_request>
4000d800: c2 27 7f e8 st %g1, [ %i5 + -24 ]
4000d804: 30 80 00 03 b,a 4000d810 <rtems_bdbuf_read_ahead_task+0xf8>
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000d808: 82 10 3f ff mov -1, %g1
4000d80c: c2 27 60 08 st %g1, [ %i5 + 8 ]
4000d810: 7f ff f9 e3 call 4000bf9c <_Chain_Get_unprotected>
4000d814: 90 10 00 19 mov %i1, %o0
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
4000d818: ba 92 20 00 orcc %o0, 0, %i5
4000d81c: 32 bf ff ca bne,a 4000d744 <rtems_bdbuf_read_ahead_task+0x2c>
4000d820: f8 07 60 0c ld [ %i5 + 0xc ], %i4
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
4000d824: 7f ff fa 18 call 4000c084 <rtems_bdbuf_unlock_cache>
4000d828: 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)
4000d82c: 82 16 a3 74 or %i2, 0x374, %g1
4000d830: c2 08 60 94 ldub [ %g1 + 0x94 ], %g1
4000d834: 80 a0 60 00 cmp %g1, 0
4000d838: 12 bf ff be bne 4000d730 <rtems_bdbuf_read_ahead_task+0x18><== ALWAYS TAKEN
4000d83c: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
4000d840: 7f ff eb 5c call 400085b0 <rtems_task_delete> <== NOT EXECUTED
4000d844: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000dfe4 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
4000dfe4: 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)
4000dfe8: 80 a6 20 00 cmp %i0, 0
4000dfec: 02 80 00 31 be 4000e0b0 <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
4000dff0: 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();
4000dff4: 7f ff f8 0f call 4000c030 <rtems_bdbuf_lock_cache>
4000dff8: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4000dffc: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000e000: 80 a2 20 04 cmp %o0, 4
4000e004: 02 80 00 22 be 4000e08c <rtems_bdbuf_release+0xa8>
4000e008: 01 00 00 00 nop
4000e00c: 18 80 00 06 bgu 4000e024 <rtems_bdbuf_release+0x40>
4000e010: 80 a2 20 06 cmp %o0, 6
4000e014: 80 a2 20 03 cmp %o0, 3
4000e018: 12 80 00 20 bne 4000e098 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
4000e01c: 01 00 00 00 nop
4000e020: 30 80 00 04 b,a 4000e030 <rtems_bdbuf_release+0x4c>
4000e024: 18 80 00 1d bgu 4000e098 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
4000e028: 01 00 00 00 nop
4000e02c: 30 80 00 15 b,a 4000e080 <rtems_bdbuf_release+0x9c>
}
static void
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
4000e030: 7f ff f7 ea call 4000bfd8 <rtems_bdbuf_group_release>
4000e034: 90 10 00 18 mov %i0, %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e038: 82 10 20 02 mov 2, %g1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000e03c: 11 10 00 67 sethi %hi(0x40019c00), %o0
4000e040: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
4000e044: 90 12 23 74 or %o0, 0x374, %o0
4000e048: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
4000e04c: 84 02 20 44 add %o0, 0x44, %g2
tail->previous = the_node;
4000e050: f0 22 20 48 st %i0, [ %o0 + 0x48 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000e054: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
4000e058: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
4000e05c: c2 26 20 04 st %g1, [ %i0 + 4 ]
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
4000e060: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000e064: 80 a0 60 00 cmp %g1, 0
4000e068: 22 80 00 03 be,a 4000e074 <rtems_bdbuf_release+0x90>
4000e06c: 90 02 20 74 add %o0, 0x74, %o0
4000e070: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000e074: 7f ff f8 98 call 4000c2d4 <rtems_bdbuf_wake>
4000e078: 01 00 00 00 nop
4000e07c: 30 80 00 09 b,a 4000e0a0 <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4000e080: 7f ff fe 03 call 4000d88c <rtems_bdbuf_discard_buffer_after_access>
4000e084: 90 10 00 18 mov %i0, %o0
break;
4000e088: 30 80 00 06 b,a 4000e0a0 <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4000e08c: 7f ff f9 a6 call 4000c724 <rtems_bdbuf_add_to_modified_list_after_access>
4000e090: 90 10 00 18 mov %i0, %o0
break;
4000e094: 30 80 00 03 b,a 4000e0a0 <rtems_bdbuf_release+0xbc>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
4000e098: 7f ff f7 ec call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e09c: 92 10 20 0e mov 0xe, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000e0a0: 7f ff f7 f9 call 4000c084 <rtems_bdbuf_unlock_cache>
4000e0a4: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000e0a8: 81 c7 e0 08 ret
4000e0ac: 81 e8 00 00 restore
}
4000e0b0: 81 c7 e0 08 ret <== NOT EXECUTED
4000e0b4: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
4000e0b8 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
4000e0b8: 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)
4000e0bc: 80 a6 20 00 cmp %i0, 0
4000e0c0: 02 80 00 19 be 4000e124 <rtems_bdbuf_release_modified+0x6c><== NEVER TAKEN
4000e0c4: 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();
4000e0c8: 7f ff f7 da call 4000c030 <rtems_bdbuf_lock_cache>
4000e0cc: 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)
4000e0d0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000e0d4: 80 a2 20 03 cmp %o0, 3
4000e0d8: 0a 80 00 0d bcs 4000e10c <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4000e0dc: 80 a2 20 05 cmp %o0, 5
4000e0e0: 08 80 00 05 bleu 4000e0f4 <rtems_bdbuf_release_modified+0x3c>
4000e0e4: 80 a2 20 06 cmp %o0, 6
4000e0e8: 12 80 00 09 bne 4000e10c <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4000e0ec: 01 00 00 00 nop
4000e0f0: 30 80 00 04 b,a 4000e100 <rtems_bdbuf_release_modified+0x48>
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4000e0f4: 7f ff f9 8c call 4000c724 <rtems_bdbuf_add_to_modified_list_after_access>
4000e0f8: 90 10 00 18 mov %i0, %o0
break;
4000e0fc: 30 80 00 06 b,a 4000e114 <rtems_bdbuf_release_modified+0x5c>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4000e100: 7f ff fd e3 call 4000d88c <rtems_bdbuf_discard_buffer_after_access>
4000e104: 90 10 00 18 mov %i0, %o0
break;
4000e108: 30 80 00 03 b,a 4000e114 <rtems_bdbuf_release_modified+0x5c>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
4000e10c: 7f ff f7 cf call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e110: 92 10 20 12 mov 0x12, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000e114: 7f ff f7 dc call 4000c084 <rtems_bdbuf_unlock_cache>
4000e118: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000e11c: 81 c7 e0 08 ret
4000e120: 81 e8 00 00 restore
}
4000e124: 81 c7 e0 08 ret <== NOT EXECUTED
4000e128: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
4000c368 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
4000c368: 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;
4000c36c: 03 10 00 67 sethi %hi(0x40019c00), %g1
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
4000c370: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
4000c374: f6 06 20 18 ld [ %i0 + 0x18 ], %i3
rtems_bdbuf_buffer* p = *root;
4000c378: fa 00 63 b0 ld [ %g1 + 0x3b0 ], %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));
4000c37c: 90 07 bf 80 add %fp, -128, %o0
4000c380: 92 10 20 00 clr %o1
4000c384: 40 00 1d 0c call 400137b4 <memset>
4000c388: 94 10 20 80 mov 0x80, %o2
rtems_bdbuf_buffer* r;
rtems_bdbuf_buffer* s;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4000c38c: 86 07 bf 80 add %fp, -128, %g3
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
4000c390: 84 10 20 01 mov 1, %g2
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000c394: 10 80 00 15 b 4000c3e8 <rtems_bdbuf_remove_from_tree+0x80>
4000c398: b4 10 3f ff mov -1, %i2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000c39c: fa 20 c0 00 st %i5, [ %g3 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000c3a0: 80 a0 40 1c cmp %g1, %i4
4000c3a4: 0a 80 00 09 bcs 4000c3c8 <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
4000c3a8: 88 00 e0 04 add %g3, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
4000c3ac: 80 a0 40 1c cmp %g1, %i4
4000c3b0: 32 80 00 0c bne,a 4000c3e0 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
4000c3b4: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ] <== NOT EXECUTED
4000c3b8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000c3bc: 80 a0 40 1b cmp %g1, %i3
4000c3c0: 1a 80 00 05 bcc 4000c3d4 <rtems_bdbuf_remove_from_tree+0x6c>
4000c3c4: 01 00 00 00 nop
{
p->avl.cache = 1;
4000c3c8: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ]
p = p->avl.right;
4000c3cc: 10 80 00 06 b 4000c3e4 <rtems_bdbuf_remove_from_tree+0x7c>
4000c3d0: fa 07 60 0c ld [ %i5 + 0xc ], %i5
}
else if ((p->dd != dd) || (p->block != block))
4000c3d4: 02 80 00 b9 be 4000c6b8 <rtems_bdbuf_remove_from_tree+0x350>
4000c3d8: 82 07 bf 80 add %fp, -128, %g1
{
p->avl.cache = -1;
4000c3dc: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ]
p = p->avl.left;
4000c3e0: fa 07 60 08 ld [ %i5 + 8 ], %i5
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000c3e4: 86 10 00 04 mov %g4, %g3
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
4000c3e8: 80 a7 60 00 cmp %i5, 0
4000c3ec: 32 bf ff ec bne,a 4000c39c <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
4000c3f0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
4000c3f4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
4000c3f8: 7f ff ff 14 call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000c3fc: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
4000c400: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000c404: 80 a0 60 00 cmp %g1, 0
4000c408: 32 80 00 08 bne,a 4000c428 <rtems_bdbuf_remove_from_tree+0xc0>
4000c40c: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
r = q->avl.left;
4000c410: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (r != NULL)
4000c414: 80 a0 60 00 cmp %g1, 0
4000c418: 32 80 00 27 bne,a 4000c4b4 <rtems_bdbuf_remove_from_tree+0x14c>
4000c41c: c0 28 60 11 clrb [ %g1 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
4000c420: 10 80 00 26 b 4000c4b8 <rtems_bdbuf_remove_from_tree+0x150>
4000c424: 80 a7 20 00 cmp %i4, 0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
4000c428: 80 a0 a0 00 cmp %g2, 0
4000c42c: 02 80 00 06 be 4000c444 <rtems_bdbuf_remove_from_tree+0xdc>
4000c430: 84 10 00 01 mov %g1, %g2
4000c434: b6 10 00 01 mov %g1, %i3
4000c438: 86 10 00 04 mov %g4, %g3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
4000c43c: 10 80 00 0f b 4000c478 <rtems_bdbuf_remove_from_tree+0x110>
4000c440: b2 10 3f ff mov -1, %i1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4000c444: c4 07 60 08 ld [ %i5 + 8 ], %g2
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
4000c448: c2 21 3f fc st %g1, [ %g4 + -4 ]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4000c44c: c4 20 60 08 st %g2, [ %g1 + 8 ]
r->avl.bal = q->avl.bal;
4000c450: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r->avl.cache = 1;
*buf_prev++ = q = r;
4000c454: 86 10 00 04 mov %g4, %g3
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
4000c458: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
r->avl.cache = 1;
4000c45c: 84 10 20 01 mov 1, %g2
4000c460: 10 80 00 15 b 4000c4b4 <rtems_bdbuf_remove_from_tree+0x14c>
4000c464: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
4000c468: f2 28 a0 10 stb %i1, [ %g2 + 0x10 ]
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
4000c46c: b6 10 00 02 mov %g2, %i3
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
4000c470: 86 00 e0 04 add %g3, 4, %g3
s = r->avl.left;
4000c474: 84 10 00 1a mov %i2, %g2
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4000c478: f4 00 a0 08 ld [ %g2 + 8 ], %i2
4000c47c: 80 a6 a0 00 cmp %i2, 0
4000c480: 32 bf ff fa bne,a 4000c468 <rtems_bdbuf_remove_from_tree+0x100>
4000c484: c4 20 c0 00 st %g2, [ %g3 ]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
4000c488: f4 07 60 08 ld [ %i5 + 8 ], %i2
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
*t = q = s;
4000c48c: c4 21 3f fc st %g2, [ %g4 + -4 ]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
4000c490: f4 20 a0 08 st %i2, [ %g2 + 8 ]
r->avl.left = s->avl.right;
4000c494: f4 00 a0 0c ld [ %g2 + 0xc ], %i2
s->avl.right = q->avl.right;
4000c498: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
s->avl.bal = q->avl.bal;
4000c49c: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
4000c4a0: f4 26 e0 08 st %i2, [ %i3 + 8 ]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4000c4a4: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
s->avl.cache = 1;
4000c4a8: 82 10 20 01 mov 1, %g1
4000c4ac: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*t = q = s;
4000c4b0: 82 10 00 02 mov %g2, %g1
}
}
if (p != NULL)
4000c4b4: 80 a7 20 00 cmp %i4, 0
4000c4b8: 02 80 00 0d be 4000c4ec <rtems_bdbuf_remove_from_tree+0x184>
4000c4bc: 05 10 00 67 sethi %hi(0x40019c00), %g2
{
if (p->avl.cache == -1)
4000c4c0: c4 4f 20 10 ldsb [ %i4 + 0x10 ], %g2
4000c4c4: 80 a0 bf ff cmp %g2, -1
4000c4c8: 32 80 00 03 bne,a 4000c4d4 <rtems_bdbuf_remove_from_tree+0x16c>
4000c4cc: c2 27 20 0c st %g1, [ %i4 + 0xc ]
{
p->avl.left = q;
4000c4d0: c2 27 20 08 st %g1, [ %i4 + 8 ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
4000c4d4: 82 07 bf 80 add %fp, -128, %g1
4000c4d8: 80 a0 c0 01 cmp %g3, %g1
4000c4dc: 18 80 00 06 bgu 4000c4f4 <rtems_bdbuf_remove_from_tree+0x18c>
4000c4e0: ba 10 20 01 mov 1, %i5
4000c4e4: 81 c7 e0 08 ret
4000c4e8: 81 e8 00 00 restore
p->avl.right = q;
}
}
else
{
*root = q;
4000c4ec: 10 bf ff fa b 4000c4d4 <rtems_bdbuf_remove_from_tree+0x16c>
4000c4f0: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ]
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
4000c4f4: b6 10 3f ff mov -1, %i3
default:
break;
}
}
if (buf_prev > buf_stack)
4000c4f8: b2 10 00 01 mov %g1, %i1
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
4000c4fc: c2 00 ff fc ld [ %g3 + -4 ], %g1
else
{
break;
}
if (p->avl.cache == -1)
4000c500: f8 48 60 10 ldsb [ %g1 + 0x10 ], %i4
4000c504: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
4000c508: 80 a7 3f ff cmp %i4, -1
{
/* rebalance left branch */
switch (p->avl.bal)
4000c50c: 85 28 a0 18 sll %g2, 0x18, %g2
else
{
break;
}
if (p->avl.cache == -1)
4000c510: 12 80 00 2a bne 4000c5b8 <rtems_bdbuf_remove_from_tree+0x250>
4000c514: 85 38 a0 18 sra %g2, 0x18, %g2
{
/* rebalance left branch */
switch (p->avl.bal)
4000c518: 80 a0 a0 00 cmp %g2, 0
4000c51c: 22 80 00 14 be,a 4000c56c <rtems_bdbuf_remove_from_tree+0x204>
4000c520: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
4000c524: 80 a0 a0 01 cmp %g2, 1
4000c528: 02 80 00 06 be 4000c540 <rtems_bdbuf_remove_from_tree+0x1d8>
4000c52c: 80 a0 bf ff cmp %g2, -1
4000c530: 12 80 00 4f bne 4000c66c <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
4000c534: 84 10 20 01 mov 1, %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
4000c538: 10 80 00 4d b 4000c66c <rtems_bdbuf_remove_from_tree+0x304>
4000c53c: c0 28 60 11 clrb [ %g1 + 0x11 ]
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
4000c540: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (p1->avl.bal >= 0) /* simple RR-turn */
4000c544: f4 48 a0 11 ldsb [ %g2 + 0x11 ], %i2
4000c548: 80 a6 a0 00 cmp %i2, 0
4000c54c: 06 80 00 0a bl 4000c574 <rtems_bdbuf_remove_from_tree+0x20c>
4000c550: c8 00 a0 08 ld [ %g2 + 8 ], %g4
{
p->avl.right = p1->avl.left;
4000c554: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
if (p1->avl.bal == 0)
4000c558: 80 a6 a0 00 cmp %i2, 0
4000c55c: 12 80 00 2d bne 4000c610 <rtems_bdbuf_remove_from_tree+0x2a8>
4000c560: c2 20 a0 08 st %g1, [ %g2 + 8 ]
{
p1->avl.bal = -1;
4000c564: f8 28 a0 11 stb %i4, [ %g2 + 0x11 ]
4000c568: 82 10 00 02 mov %g2, %g1
modified = false;
4000c56c: 10 80 00 40 b 4000c66c <rtems_bdbuf_remove_from_tree+0x304>
4000c570: 84 10 20 00 clr %g2
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000c574: f4 01 20 0c ld [ %g4 + 0xc ], %i2
p2->avl.right = p1;
4000c578: c4 21 20 0c st %g2, [ %g4 + 0xc ]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000c57c: f4 20 a0 08 st %i2, [ %g2 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000c580: f4 01 20 08 ld [ %g4 + 8 ], %i2
p2->avl.left = p;
4000c584: c2 21 20 08 st %g1, [ %g4 + 8 ]
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000c588: f4 20 60 0c st %i2, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000c58c: f4 49 20 11 ldsb [ %g4 + 0x11 ], %i2
4000c590: 80 a6 a0 01 cmp %i2, 1
4000c594: 32 80 00 03 bne,a 4000c5a0 <rtems_bdbuf_remove_from_tree+0x238>
4000c598: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000c59c: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000c5a0: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000c5a4: 80 a0 7f ff cmp %g1, -1
4000c5a8: 32 80 00 2e bne,a 4000c660 <rtems_bdbuf_remove_from_tree+0x2f8><== ALWAYS TAKEN
4000c5ac: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000c5b0: 10 80 00 2c b 4000c660 <rtems_bdbuf_remove_from_tree+0x2f8><== NOT EXECUTED
4000c5b4: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ] <== NOT EXECUTED
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4000c5b8: 80 a0 a0 00 cmp %g2, 0
4000c5bc: 22 bf ff ec be,a 4000c56c <rtems_bdbuf_remove_from_tree+0x204>
4000c5c0: f6 28 60 11 stb %i3, [ %g1 + 0x11 ]
4000c5c4: 80 a0 a0 01 cmp %g2, 1
4000c5c8: 02 80 00 06 be 4000c5e0 <rtems_bdbuf_remove_from_tree+0x278>
4000c5cc: 80 a0 bf ff cmp %g2, -1
4000c5d0: 32 80 00 27 bne,a 4000c66c <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
4000c5d4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
4000c5d8: 10 80 00 04 b 4000c5e8 <rtems_bdbuf_remove_from_tree+0x280>
4000c5dc: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
4000c5e0: 10 80 00 22 b 4000c668 <rtems_bdbuf_remove_from_tree+0x300>
4000c5e4: c0 28 60 11 clrb [ %g1 + 0x11 ]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
4000c5e8: f8 48 a0 11 ldsb [ %g2 + 0x11 ], %i4
4000c5ec: 80 a7 20 00 cmp %i4, 0
4000c5f0: 14 80 00 0c bg 4000c620 <rtems_bdbuf_remove_from_tree+0x2b8>
4000c5f4: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
4000c5f8: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
if (p1->avl.bal == 0)
4000c5fc: 80 a7 20 00 cmp %i4, 0
4000c600: 12 80 00 04 bne 4000c610 <rtems_bdbuf_remove_from_tree+0x2a8>
4000c604: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
p1->avl.bal = 1;
4000c608: 10 bf ff d8 b 4000c568 <rtems_bdbuf_remove_from_tree+0x200>
4000c60c: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
modified = false;
}
else
{
p->avl.bal = 0;
4000c610: c0 28 60 11 clrb [ %g1 + 0x11 ]
p1->avl.bal = 0;
4000c614: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000c618: 10 80 00 14 b 4000c668 <rtems_bdbuf_remove_from_tree+0x300>
4000c61c: 82 10 00 02 mov %g2, %g1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000c620: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p1;
4000c624: c4 21 20 08 st %g2, [ %g4 + 8 ]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000c628: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000c62c: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p;
4000c630: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000c634: f8 20 60 08 st %i4, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4000c638: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
4000c63c: 80 a7 3f ff cmp %i4, -1
4000c640: 32 80 00 03 bne,a 4000c64c <rtems_bdbuf_remove_from_tree+0x2e4>
4000c644: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000c648: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000c64c: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000c650: 80 a0 60 01 cmp %g1, 1
4000c654: 32 80 00 03 bne,a 4000c660 <rtems_bdbuf_remove_from_tree+0x2f8>
4000c658: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000c65c: f6 28 a0 11 stb %i3, [ %g2 + 0x11 ]
p = p2;
p2->avl.bal = 0;
4000c660: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000c664: 82 10 00 04 mov %g4, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4000c668: 84 10 20 01 mov 1, %g2
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
4000c66c: 88 00 ff fc add %g3, -4, %g4
default:
break;
}
}
if (buf_prev > buf_stack)
4000c670: 80 a1 00 19 cmp %g4, %i1
4000c674: 28 80 00 09 bleu,a 4000c698 <rtems_bdbuf_remove_from_tree+0x330>
4000c678: 05 10 00 67 sethi %hi(0x40019c00), %g2
{
q = *(buf_prev - 1);
4000c67c: c8 00 ff f8 ld [ %g3 + -8 ], %g4
if (q->avl.cache == -1)
4000c680: f8 49 20 10 ldsb [ %g4 + 0x10 ], %i4
4000c684: 80 a7 3f ff cmp %i4, -1
4000c688: 32 80 00 07 bne,a 4000c6a4 <rtems_bdbuf_remove_from_tree+0x33c>
4000c68c: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
q->avl.left = p;
4000c690: 10 80 00 05 b 4000c6a4 <rtems_bdbuf_remove_from_tree+0x33c>
4000c694: c2 21 20 08 st %g1, [ %g4 + 8 ]
q->avl.right = p;
}
}
else
{
*root = p;
4000c698: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ]
4000c69c: 81 c7 e0 08 ret
4000c6a0: 81 e8 00 00 restore
*root = q;
}
modified = true;
while (modified)
4000c6a4: 80 88 a0 ff btst 0xff, %g2
4000c6a8: 12 bf ff 95 bne 4000c4fc <rtems_bdbuf_remove_from_tree+0x194>
4000c6ac: 86 00 ff fc add %g3, -4, %g3
4000c6b0: 81 c7 e0 08 ret
4000c6b4: 81 e8 00 00 restore
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
4000c6b8: 80 a0 c0 01 cmp %g3, %g1
4000c6bc: 08 bf ff 51 bleu 4000c400 <rtems_bdbuf_remove_from_tree+0x98>
4000c6c0: b8 10 20 00 clr %i4
{
p = *(buf_prev - 1);
4000c6c4: 10 bf ff 4f b 4000c400 <rtems_bdbuf_remove_from_tree+0x98>
4000c6c8: f8 01 3f f8 ld [ %g4 + -8 ], %i4
4000c800 <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)
{
4000c800: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
4000c804: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000c808: 80 a2 20 00 cmp %o0, 0
4000c80c: 22 80 00 0b be,a 4000c838 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
4000c810: c4 06 00 00 ld [ %i0 ], %g2
4000c814: 80 a2 20 02 cmp %o0, 2
4000c818: 12 80 00 06 bne 4000c830 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30><== NEVER TAKEN
4000c81c: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
4000c820: 7f ff fe d2 call 4000c368 <rtems_bdbuf_remove_from_tree>
4000c824: 90 10 00 18 mov %i0, %o0
break;
4000c828: 10 80 00 04 b 4000c838 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
4000c82c: c4 06 00 00 ld [ %i0 ], %g2
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
4000c830: 7f ff fe 06 call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000c834: 92 10 20 16 mov 0x16, %o1 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000c838: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
4000c83c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000c840: c4 20 40 00 st %g2, [ %g1 ]
4000c844: 81 c7 e0 08 ret
4000c848: 81 e8 00 00 restore
4000c100 <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000c100: 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);
4000c104: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000c108: 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);
4000c10c: 90 10 00 18 mov %i0, %o0
4000c110: 92 12 63 ff or %o1, 0x3ff, %o1
4000c114: 40 00 11 35 call 400105e8 <rtems_task_mode>
4000c118: 94 07 a0 44 add %fp, 0x44, %o2
if (sc != RTEMS_SUCCESSFUL)
4000c11c: 80 a2 20 00 cmp %o0, 0
4000c120: 02 80 00 04 be 4000c130 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
4000c124: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
4000c128: 7f ff ff b1 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c12c: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6> <== NOT EXECUTED
4000c130: 81 c7 e0 08 ret
4000c134: 81 e8 00 00 restore
4000e46c <rtems_bdbuf_set_block_size>:
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
4000e46c: 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)
4000e470: 80 a6 a0 00 cmp %i2, 0
4000e474: 02 80 00 04 be 4000e484 <rtems_bdbuf_set_block_size+0x18>
4000e478: ba 10 00 18 mov %i0, %i5
rtems_bdbuf_syncdev (dd);
4000e47c: 7f ff ff 79 call 4000e260 <rtems_bdbuf_syncdev>
4000e480: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_lock_cache ();
4000e484: 7f ff f6 eb call 4000c030 <rtems_bdbuf_lock_cache>
4000e488: b0 10 20 0a mov 0xa, %i0
if (block_size > 0)
4000e48c: 80 a6 60 00 cmp %i1, 0
4000e490: 02 80 00 30 be 4000e550 <rtems_bdbuf_set_block_size+0xe4>
4000e494: 03 10 00 61 sethi %hi(0x40018400), %g1
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
4000e498: 82 10 62 48 or %g1, 0x248, %g1 ! 40018648 <rtems_bdbuf_configuration>
4000e49c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
4000e4a0: 80 a6 40 02 cmp %i1, %g2
4000e4a4: 18 80 00 2b bgu 4000e550 <rtems_bdbuf_set_block_size+0xe4><== NEVER TAKEN
4000e4a8: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
4000e4ac: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
4000e4b0: 40 00 1f f8 call 40016490 <.udiv>
4000e4b4: 90 06 7f ff add %i1, -1, %o0
for (bds_per_size = 1;
4000e4b8: 92 10 20 01 mov 1, %o1
4000e4bc: 90 02 20 01 inc %o0
4000e4c0: 80 a2 40 08 cmp %o1, %o0
4000e4c4: 2a bf ff ff bcs,a 4000e4c0 <rtems_bdbuf_set_block_size+0x54>
4000e4c8: 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;
4000e4cc: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000e4d0: d0 00 63 94 ld [ %g1 + 0x394 ], %o0 ! 40019f94 <bdbuf_cache+0x20>
4000e4d4: 40 00 1f ef call 40016490 <.udiv>
4000e4d8: b0 10 20 0a mov 0xa, %i0
if (block_size > 0)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
4000e4dc: 80 a2 20 00 cmp %o0, 0
4000e4e0: 02 80 00 1c be 4000e550 <rtems_bdbuf_set_block_size+0xe4> <== NEVER TAKEN
4000e4e4: 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;
4000e4e8: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
4000e4ec: 90 10 00 19 mov %i1, %o0
4000e4f0: 40 00 1f e8 call 40016490 <.udiv>
4000e4f4: 92 10 00 18 mov %i0, %o1
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
{
int block_to_media_block_shift = 0;
4000e4f8: b8 10 20 00 clr %i4
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
4000e4fc: b6 10 00 08 mov %o0, %i3
4000e500: 84 10 20 01 mov 1, %g2
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
4000e504: 83 28 80 1c sll %g2, %i4, %g1
4000e508: 80 a0 40 1b cmp %g1, %i3
4000e50c: 2a bf ff fe bcs,a 4000e504 <rtems_bdbuf_set_block_size+0x98>
4000e510: b8 07 20 01 inc %i4
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
4000e514: b1 2e 00 1c sll %i0, %i4, %i0
4000e518: 80 a6 00 19 cmp %i0, %i1
4000e51c: 32 80 00 02 bne,a 4000e524 <rtems_bdbuf_set_block_size+0xb8><== NEVER TAKEN
4000e520: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
4000e524: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
4000e528: 92 10 00 1b mov %i3, %o1
4000e52c: 40 00 1f d9 call 40016490 <.udiv>
4000e530: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
4000e534: b0 10 20 00 clr %i0
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
4000e538: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
dd->media_blocks_per_block = media_blocks_per_block;
4000e53c: f6 27 60 2c st %i3, [ %i5 + 0x2c ]
dd->block_to_media_block_shift = block_to_media_block_shift;
4000e540: f8 27 60 30 st %i4, [ %i5 + 0x30 ]
dd->bds_per_group = bds_per_group;
4000e544: f4 27 60 34 st %i2, [ %i5 + 0x34 ]
rtems_bdbuf_purge_dev (dd);
4000e548: 7f ff ff 5d call 4000e2bc <rtems_bdbuf_purge_dev>
4000e54c: 90 10 00 1d mov %i5, %o0
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
4000e550: 7f ff f6 cd call 4000c084 <rtems_bdbuf_unlock_cache>
4000e554: 01 00 00 00 nop
return sc;
}
4000e558: 81 c7 e0 08 ret
4000e55c: 81 e8 00 00 restore
4000ce14 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
4000ce14: 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;
4000ce18: 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 );
4000ce1c: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
4000ce20: 80 a0 40 19 cmp %g1, %i1
4000ce24: 02 80 00 4e be 4000cf5c <rtems_bdbuf_swapout_modified_processing+0x148>
4000ce28: 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))
4000ce2c: 02 80 00 05 be 4000ce40 <rtems_bdbuf_swapout_modified_processing+0x2c>
4000ce30: 84 10 20 00 clr %g2
4000ce34: c4 06 00 00 ld [ %i0 ], %g2
4000ce38: 80 a0 00 02 cmp %g0, %g2
4000ce3c: 84 60 3f ff subx %g0, -1, %g2
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
4000ce40: 07 10 00 67 sethi %hi(0x40019c00), %g3
4000ce44: de 00 e3 e8 ld [ %g3 + 0x3e8 ], %o7 ! 40019fe8 <bdbuf_cache+0x74>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
4000ce48: 9a 08 a0 ff and %g2, 0xff, %o5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ce4c: 98 10 20 09 mov 9, %o4
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
4000ce50: 80 a3 60 00 cmp %o5, 0
4000ce54: 32 80 00 0d bne,a 4000ce88 <rtems_bdbuf_swapout_modified_processing+0x74>
4000ce58: c0 20 60 2c clr [ %g1 + 0x2c ]
4000ce5c: 80 a6 e0 00 cmp %i3, 0
4000ce60: 02 80 00 07 be 4000ce7c <rtems_bdbuf_swapout_modified_processing+0x68>
4000ce64: 80 a3 e0 00 cmp %o7, 0
4000ce68: c6 06 00 00 ld [ %i0 ], %g3
4000ce6c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000ce70: 80 a0 c0 02 cmp %g3, %g2
4000ce74: 02 80 00 04 be 4000ce84 <rtems_bdbuf_swapout_modified_processing+0x70>
4000ce78: 80 a3 e0 00 cmp %o7, 0
|| rtems_bdbuf_has_buffer_waiters ())
4000ce7c: 22 80 00 04 be,a 4000ce8c <rtems_bdbuf_swapout_modified_processing+0x78>
4000ce80: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
bd->hold_timer = 0;
4000ce84: c0 20 60 2c clr [ %g1 + 0x2c ]
if (bd->hold_timer)
4000ce88: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000ce8c: 80 a0 a0 00 cmp %g2, 0
4000ce90: 22 80 00 10 be,a 4000ced0 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000ce94: c4 06 00 00 ld [ %i0 ], %g2
{
if (update_timers)
4000ce98: 80 a7 20 00 cmp %i4, 0
4000ce9c: 22 80 00 08 be,a 4000cebc <rtems_bdbuf_swapout_modified_processing+0xa8>
4000cea0: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
{
if (bd->hold_timer > timer_delta)
4000cea4: 80 a0 80 1d cmp %g2, %i5
4000cea8: 28 80 00 04 bleu,a 4000ceb8 <rtems_bdbuf_swapout_modified_processing+0xa4>
4000ceac: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
4000ceb0: 84 20 80 1d sub %g2, %i5, %g2
4000ceb4: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
4000ceb8: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000cebc: 80 a0 a0 00 cmp %g2, 0
4000cec0: 22 80 00 04 be,a 4000ced0 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000cec4: c4 06 00 00 ld [ %i0 ], %g2
{
node = node->next;
continue;
4000cec8: 10 80 00 22 b 4000cf50 <rtems_bdbuf_swapout_modified_processing+0x13c>
4000cecc: c2 00 40 00 ld [ %g1 ], %g1
/*
* This assumes we can set it to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dd_ptr == BDBUF_INVALID_DEV)
4000ced0: 80 a0 a0 00 cmp %g2, 0
4000ced4: 32 80 00 05 bne,a 4000cee8 <rtems_bdbuf_swapout_modified_processing+0xd4>
4000ced8: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
*dd_ptr = bd->dd;
4000cedc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000cee0: c4 26 00 00 st %g2, [ %i0 ]
if (bd->dd == *dd_ptr)
4000cee4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
4000cee8: c4 06 00 00 ld [ %i0 ], %g2
4000ceec: 80 a0 c0 02 cmp %g3, %g2
4000cef0: 12 80 00 17 bne 4000cf4c <rtems_bdbuf_swapout_modified_processing+0x138><== NEVER TAKEN
4000cef4: c6 00 40 00 ld [ %g1 ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000cef8: c4 00 60 04 ld [ %g1 + 4 ], %g2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000cefc: d8 20 60 20 st %o4, [ %g1 + 0x20 ]
next->previous = previous;
4000cf00: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000cf04: c6 20 80 00 st %g3, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
4000cf08: 10 80 00 0c b 4000cf38 <rtems_bdbuf_swapout_modified_processing+0x124>
4000cf0c: c4 06 a0 08 ld [ %i2 + 8 ], %g2
while (node && !rtems_chain_is_head (transfer, tnode))
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
4000cf10: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4000cf14: 80 a2 c0 04 cmp %o3, %g4
4000cf18: 28 80 00 08 bleu,a 4000cf38 <rtems_bdbuf_swapout_modified_processing+0x124>
4000cf1c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000cf20: c8 00 80 00 ld [ %g2 ], %g4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000cf24: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000cf28: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
4000cf2c: c8 20 40 00 st %g4, [ %g1 ]
before_node->previous = the_node;
4000cf30: 10 80 00 07 b 4000cf4c <rtems_bdbuf_swapout_modified_processing+0x138>
4000cf34: c2 21 20 04 st %g1, [ %g4 + 4 ]
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
4000cf38: 80 a0 80 1a cmp %g2, %i2
4000cf3c: 32 bf ff f5 bne,a 4000cf10 <rtems_bdbuf_swapout_modified_processing+0xfc>
4000cf40: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000cf44: 10 80 00 08 b 4000cf64 <rtems_bdbuf_swapout_modified_processing+0x150>
4000cf48: c4 06 80 00 ld [ %i2 ], %g2
node = next_node;
}
else
{
node = node->next;
4000cf4c: 82 10 00 03 mov %g3, %g1
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
4000cf50: 80 a0 40 19 cmp %g1, %i1
4000cf54: 12 bf ff c0 bne 4000ce54 <rtems_bdbuf_swapout_modified_processing+0x40>
4000cf58: 80 a3 60 00 cmp %o5, 0
4000cf5c: 81 c7 e0 08 ret
4000cf60: 81 e8 00 00 restore
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000cf64: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000cf68: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
4000cf6c: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
4000cf70: 10 bf ff f7 b 4000cf4c <rtems_bdbuf_swapout_modified_processing+0x138>
4000cf74: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000d2a0 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
4000d2a0: 9d e3 bf 80 save %sp, -128, %sp
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
4000d2a4: 33 10 00 61 sethi %hi(0x40018400), %i1
4000d2a8: b2 16 62 48 or %i1, 0x248, %i1 ! 40018648 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000d2ac: 7f ff fb de call 4000c224 <rtems_bdbuf_swapout_writereq_alloc>
4000d2b0: f6 06 60 0c ld [ %i1 + 0xc ], %i3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d2b4: 82 07 bf ec add %fp, -20, %g1
4000d2b8: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
4000d2bc: 82 07 bf e8 add %fp, -24, %g1
4000d2c0: c2 27 bf f0 st %g1, [ %fp + -16 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000d2c4: 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 ();
4000d2c8: d0 27 bf fc st %o0, [ %fp + -4 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000d2cc: 91 2e e0 07 sll %i3, 7, %o0
4000d2d0: 90 22 00 01 sub %o0, %g1, %o0
4000d2d4: 03 10 00 61 sethi %hi(0x40018400), %g1
4000d2d8: d2 00 62 0c ld [ %g1 + 0x20c ], %o1 ! 4001860c <Configuration+0xc>
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4000d2dc: c0 27 bf ec clr [ %fp + -20 ]
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dd = BDBUF_INVALID_DEV;
4000d2e0: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
4000d2e4: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000d2e8: 90 02 00 1b add %o0, %i3, %o0
4000d2ec: 40 00 24 69 call 40016490 <.udiv>
4000d2f0: 91 2a 20 03 sll %o0, 3, %o0
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000d2f4: 35 10 00 67 sethi %hi(0x40019c00), %i2
4000d2f8: a0 10 00 08 mov %o0, %l0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
4000d2fc: 7f ff fb 4d call 4000c030 <rtems_bdbuf_lock_cache>
4000d300: b4 16 a3 74 or %i2, 0x374, %i2
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000d304: 27 10 91 1b sethi %hi(0x42446c00), %l3
4000d308: 29 10 00 35 sethi %hi(0x4000d400), %l4
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000d30c: b8 10 20 00 clr %i4
4000d310: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
the_node->next = tail;
4000d314: a2 06 a0 0c add %i2, 0xc, %l1
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
4000d318: a4 10 20 01 mov 1, %l2
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000d31c: a6 14 e3 00 or %l3, 0x300, %l3
4000d320: 10 80 00 23 b 4000d3ac <rtems_bdbuf_swapout_task+0x10c>
4000d324: a8 15 21 c4 or %l4, 0x1c4, %l4
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4000d328: 7f ff dc 8a call 40004550 <malloc> <== NOT EXECUTED
4000d32c: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
4000d330: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4000d334: 32 80 00 04 bne,a 4000d344 <rtems_bdbuf_swapout_task+0xa4><== NOT EXECUTED
4000d338: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
4000d33c: 10 80 00 1a b 4000d3a4 <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
4000d340: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
4000d344: e2 27 40 00 st %l1, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
4000d348: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000d34c: 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;
4000d350: fa 26 a0 10 st %i5, [ %i2 + 0x10 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000d354: 7f ff fb b4 call 4000c224 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
4000d358: e4 2f 60 0c stb %l2, [ %i5 + 0xc ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000d35c: d2 06 60 18 ld [ %i1 + 0x18 ], %o1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4000d360: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
4000d364: 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 ();
4000d368: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
head->next = tail;
4000d36c: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
4000d370: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
4000d374: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000d378: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
4000d37c: 90 07 20 61 add %i4, 0x61, %o0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000d380: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
4000d384: 90 12 00 13 or %o0, %l3, %o0 <== NOT EXECUTED
4000d388: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4000d38c: 7f ff fb e0 call 4000c30c <rtems_bdbuf_create_task.constprop.10><== NOT EXECUTED
4000d390: 98 07 60 08 add %i5, 8, %o4 <== NOT EXECUTED
bdbuf_config.swapout_worker_priority,
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
4000d394: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d398: 22 80 00 05 be,a 4000d3ac <rtems_bdbuf_swapout_task+0x10c><== NOT EXECUTED
4000d39c: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
4000d3a0: 90 10 20 0d mov 0xd, %o0 <== NOT EXECUTED
4000d3a4: 7f ff fb 12 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d3a8: 01 00 00 00 nop <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000d3ac: 80 a7 00 18 cmp %i4, %i0
4000d3b0: 0a bf ff de bcs 4000d328 <rtems_bdbuf_swapout_task+0x88> <== NEVER TAKEN
4000d3b4: 01 00 00 00 nop
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
4000d3b8: 7f ff fb 33 call 4000c084 <rtems_bdbuf_unlock_cache>
4000d3bc: 39 10 00 67 sethi %hi(0x40019c00), %i4
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000d3c0: b8 17 23 74 or %i4, 0x374, %i4 ! 40019f74 <bdbuf_cache>
4000d3c4: a2 07 20 08 add %i4, 8, %l1
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000d3c8: a4 07 20 58 add %i4, 0x58, %l2
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000d3cc: 10 80 00 5a b 4000d534 <rtems_bdbuf_swapout_task+0x294>
4000d3d0: a6 07 20 4c add %i4, 0x4c, %l3
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
4000d3d4: 7f ff fb 17 call 4000c030 <rtems_bdbuf_lock_cache>
4000d3d8: 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)
4000d3dc: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
4000d3e0: 80 a0 60 00 cmp %g1, 0
4000d3e4: 02 80 00 04 be 4000d3f4 <rtems_bdbuf_swapout_task+0x154>
4000d3e8: b4 10 20 00 clr %i2
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4000d3ec: 10 80 00 08 b 4000d40c <rtems_bdbuf_swapout_task+0x16c>
4000d3f0: ba 07 bf e8 add %fp, -24, %i5
4000d3f4: 7f ff fa ea call 4000bf9c <_Chain_Get_unprotected>
4000d3f8: 90 10 00 11 mov %l1, %o0
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);
if (worker)
4000d3fc: b4 92 20 00 orcc %o0, 0, %i2
4000d400: 22 bf ff fb be,a 4000d3ec <rtems_bdbuf_swapout_task+0x14c><== ALWAYS TAKEN
4000d404: b4 10 20 00 clr %i2
transfer = &worker->transfer;
4000d408: ba 06 a0 10 add %i2, 0x10, %i5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4000d40c: 82 07 60 04 add %i5, 4, %g1
head->next = tail;
4000d410: c2 27 40 00 st %g1, [ %i5 ]
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
4000d414: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
head->previous = NULL;
4000d418: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
4000d41c: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
4000d420: c0 27 60 0c clr [ %i5 + 0xc ]
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
4000d424: 80 88 60 ff btst 0xff, %g1
4000d428: 02 80 00 04 be 4000d438 <rtems_bdbuf_swapout_task+0x198>
4000d42c: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
transfer->dd = bdbuf_cache.sync_device;
4000d430: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
4000d434: c2 27 60 0c st %g1, [ %i5 + 0xc ]
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000d438: b0 07 60 0c add %i5, 0xc, %i0
4000d43c: 92 10 00 12 mov %l2, %o1
4000d440: 90 10 00 18 mov %i0, %o0
4000d444: 94 10 00 1d mov %i5, %o2
4000d448: 96 10 20 01 mov 1, %o3
4000d44c: 98 10 20 00 clr %o4
4000d450: 7f ff fe 71 call 4000ce14 <rtems_bdbuf_swapout_modified_processing>
4000d454: 9a 10 00 1b mov %i3, %o5
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000d458: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
4000d45c: 90 10 00 18 mov %i0, %o0
4000d460: 92 10 00 13 mov %l3, %o1
4000d464: 94 10 00 1d mov %i5, %o2
4000d468: 98 0e 60 01 and %i1, 1, %o4
4000d46c: 7f ff fe 6a call 4000ce14 <rtems_bdbuf_swapout_modified_processing>
4000d470: 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 ();
4000d474: 7f ff fb 04 call 4000c084 <rtems_bdbuf_unlock_cache>
4000d478: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000d47c: c4 07 40 00 ld [ %i5 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4000d480: 82 07 60 04 add %i5, 4, %g1
4000d484: 80 a0 80 01 cmp %g2, %g1
4000d488: 02 80 00 10 be 4000d4c8 <rtems_bdbuf_swapout_task+0x228>
4000d48c: 80 a6 a0 00 cmp %i2, 0
{
if (worker)
4000d490: 02 80 00 0a be 4000d4b8 <rtems_bdbuf_swapout_task+0x218> <== ALWAYS TAKEN
4000d494: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
4000d498: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
4000d49c: 7f ff ea 43 call 40007da8 <rtems_event_send> <== NOT EXECUTED
4000d4a0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000d4a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d4a8: 02 80 00 09 be 4000d4cc <rtems_bdbuf_swapout_task+0x22c> <== NOT EXECUTED
4000d4ac: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
4000d4b0: 10 bf ff bd b 4000d3a4 <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
4000d4b4: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
4000d4b8: 7f ff ff 22 call 4000d140 <rtems_bdbuf_swapout_write>
4000d4bc: 90 10 00 1d mov %i5, %o0
}
transfered_buffers = true;
4000d4c0: 10 80 00 03 b 4000d4cc <rtems_bdbuf_swapout_task+0x22c>
4000d4c4: 82 10 20 01 mov 1, %g1
4000d4c8: 82 10 20 00 clr %g1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
4000d4cc: c4 0f 20 30 ldub [ %i4 + 0x30 ], %g2
4000d4d0: b2 10 20 00 clr %i1
4000d4d4: 80 a0 a0 00 cmp %g2, 0
4000d4d8: 02 80 00 13 be 4000d524 <rtems_bdbuf_swapout_task+0x284>
4000d4dc: 82 08 60 ff and %g1, 0xff, %g1
4000d4e0: 80 a0 60 00 cmp %g1, 0
4000d4e4: 12 bf ff bc bne 4000d3d4 <rtems_bdbuf_swapout_task+0x134>
4000d4e8: 01 00 00 00 nop
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
4000d4ec: 7f ff fa d1 call 4000c030 <rtems_bdbuf_lock_cache>
4000d4f0: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
4000d4f4: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
4000d4f8: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
4000d4fc: 7f ff fa e2 call 4000c084 <rtems_bdbuf_unlock_cache>
4000d500: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
4000d504: 80 a7 60 00 cmp %i5, 0
4000d508: 22 80 00 23 be,a 4000d594 <rtems_bdbuf_swapout_task+0x2f4><== NEVER TAKEN
4000d50c: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
4000d510: 90 10 00 1d mov %i5, %o0
4000d514: 7f ff eb c8 call 40008434 <rtems_event_system_send>
4000d518: 13 20 00 00 sethi %hi(0x80000000), %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4000d51c: 10 80 00 1e b 4000d594 <rtems_bdbuf_swapout_task+0x2f4>
4000d520: 90 10 20 04 mov 4, %o0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4000d524: 80 a0 60 00 cmp %g1, 0
4000d528: 02 80 00 1b be 4000d594 <rtems_bdbuf_swapout_task+0x2f4>
4000d52c: 90 10 20 04 mov 4, %o0
4000d530: 30 bf ff a9 b,a 4000d3d4 <rtems_bdbuf_swapout_task+0x134>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000d534: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000d538: 80 a0 60 00 cmp %g1, 0
4000d53c: 12 bf ff a6 bne 4000d3d4 <rtems_bdbuf_swapout_task+0x134> <== ALWAYS TAKEN
4000d540: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
4000d544: 7f ff fa bb call 4000c030 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000d548: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000d54c: 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))
4000d550: 10 80 00 06 b 4000d568 <rtems_bdbuf_swapout_task+0x2c8> <== NOT EXECUTED
4000d554: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
4000d558: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4000d55c: 7f ff ea 13 call 40007da8 <rtems_event_send> <== NOT EXECUTED
4000d560: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000d564: 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))
4000d568: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000d56c: 32 bf ff fb bne,a 4000d558 <rtems_bdbuf_swapout_task+0x2b8><== NOT EXECUTED
4000d570: 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 ();
4000d574: 7f ff fa c4 call 4000c084 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000d578: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
4000d57c: 7f ff da b4 call 4000404c <free> <== NOT EXECUTED
4000d580: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000d584: 7f ff ec 0b call 400085b0 <rtems_task_delete> <== NOT EXECUTED
4000d588: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000d58c: 81 c7 e0 08 ret <== NOT EXECUTED
4000d590: 81 e8 00 00 restore <== NOT EXECUTED
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4000d594: 92 10 20 00 clr %o1
4000d598: 94 10 00 10 mov %l0, %o2
4000d59c: 7f ff e9 a1 call 40007c20 <rtems_event_receive>
4000d5a0: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4000d5a4: 80 a2 20 06 cmp %o0, 6
4000d5a8: 22 bf ff e4 be,a 4000d538 <rtems_bdbuf_swapout_task+0x298>
4000d5ac: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000d5b0: 80 a2 20 00 cmp %o0, 0
4000d5b4: 22 bf ff e1 be,a 4000d538 <rtems_bdbuf_swapout_task+0x298><== ALWAYS TAKEN
4000d5b8: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000d5bc: 10 bf ff 7a b 4000d3a4 <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
4000d5c0: 90 10 20 18 mov 0x18, %o0 <== NOT EXECUTED
4000d5c4 <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)
{
4000d5c4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000d5c8: 3b 10 00 67 sethi %hi(0x40019c00), %i5 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
4000d5cc: b8 06 20 10 add %i0, 0x10, %i4 <== NOT EXECUTED
4000d5d0: ba 17 63 74 or %i5, 0x374, %i5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4000d5d4: b6 06 20 14 add %i0, 0x14, %i3 <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4000d5d8: 10 80 00 12 b 4000d620 <rtems_bdbuf_swapout_worker_task+0x5c><== NOT EXECUTED
4000d5dc: b4 07 60 0c add %i5, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4000d5e0: 7f ff fb 00 call 4000c1e0 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
4000d5e4: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4000d5e8: 7f ff fe d6 call 4000d140 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
4000d5ec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4000d5f0: 7f ff fa 90 call 4000c030 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000d5f4: 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;
4000d5f8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000d5fc: f6 26 20 10 st %i3, [ %i0 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000d600: c0 26 20 1c clr [ %i0 + 0x1c ] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000d604: f4 26 00 00 st %i2, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
4000d608: f0 27 60 10 st %i0, [ %i5 + 0x10 ] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4000d60c: c0 26 20 14 clr [ %i0 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
4000d610: f8 26 20 18 st %i4, [ %i0 + 0x18 ] <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
4000d614: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4000d618: 7f ff fa 9b call 4000c084 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000d61c: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4000d620: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
4000d624: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d628: 12 bf ff ee bne 4000d5e0 <rtems_bdbuf_swapout_worker_task+0x1c><== NOT EXECUTED
4000d62c: 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);
4000d630: 7f ff da 87 call 4000404c <free> <== NOT EXECUTED
4000d634: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
free (worker);
4000d638: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d63c: 7f ff da 84 call 4000404c <free> <== NOT EXECUTED
4000d640: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000d644: 7f ff eb db call 400085b0 <rtems_task_delete> <== NOT EXECUTED
4000d648: 81 e8 00 00 restore <== NOT EXECUTED
4000d140 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
4000d140: 9d e3 bf a0 save %sp, -96, %sp
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000d144: 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 );
4000d148: b6 06 20 04 add %i0, 4, %i3
4000d14c: 80 a0 40 1b cmp %g1, %i3
4000d150: 02 80 00 52 be 4000d298 <rtems_bdbuf_swapout_write+0x158> <== NEVER TAKEN
4000d154: 84 10 20 0c mov 0xc, %g2
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
4000d158: fa 06 20 0c ld [ %i0 + 0xc ], %i5
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000d15c: c2 07 60 08 ld [ %i5 + 8 ], %g1
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
4000d160: f4 07 60 2c ld [ %i5 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000d164: f2 00 60 0c ld [ %g1 + 0xc ], %i1
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000d168: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000d16c: b2 0e 60 01 and %i1, 1, %i1
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000d170: c4 20 60 0c st %g2, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
4000d174: c0 20 60 10 clr [ %g1 + 0x10 ]
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
4000d178: b8 10 20 00 clr %i4
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000d17c: a0 10 20 0c mov 0xc, %l0
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
4000d180: 10 80 00 35 b 4000d254 <rtems_bdbuf_swapout_write+0x114>
4000d184: 23 10 00 61 sethi %hi(0x40018400), %l1
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
4000d188: 02 80 00 12 be 4000d1d0 <rtems_bdbuf_swapout_write+0x90>
4000d18c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000d190: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000d194: 80 a0 a0 00 cmp %g2, 0
4000d198: 22 80 00 0f be,a 4000d1d4 <rtems_bdbuf_swapout_write+0x94>
4000d19c: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
4000d1a0: c6 02 20 18 ld [ %o0 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
4000d1a4: 84 07 00 1a add %i4, %i2, %g2
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
4000d1a8: 80 a0 c0 02 cmp %g3, %g2
4000d1ac: 22 80 00 0a be,a 4000d1d4 <rtems_bdbuf_swapout_write+0x94>
4000d1b0: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000d1b4: c2 06 00 00 ld [ %i0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000d1b8: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000d1bc: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
4000d1c0: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
4000d1c4: d0 20 60 04 st %o0, [ %g1 + 4 ]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
4000d1c8: 10 80 00 10 b 4000d208 <rtems_bdbuf_swapout_write+0xc8>
4000d1cc: 82 10 20 01 mov 1, %g1
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000d1d0: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000d1d4: f8 02 20 18 ld [ %o0 + 0x18 ], %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000d1d8: 87 29 20 04 sll %g4, 4, %g3
transfer->write_req->bufnum++;
4000d1dc: 88 01 20 01 inc %g4
4000d1e0: c8 20 60 10 st %g4, [ %g1 + 0x10 ]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000d1e4: 86 00 e0 18 add %g3, 0x18, %g3
4000d1e8: 84 00 40 03 add %g1, %g3, %g2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000d1ec: f8 20 40 03 st %i4, [ %g1 + %g3 ]
buf->length = dd->block_size;
4000d1f0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
4000d1f4: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
4000d1f8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
buf->buffer = bd->buffer;
4000d1fc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000d200: c2 20 a0 08 st %g1, [ %g2 + 8 ]
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
4000d204: 82 10 20 00 clr %g1
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4000d208: c4 06 00 00 ld [ %i0 ], %g2
4000d20c: 80 a0 80 1b cmp %g2, %i3
4000d210: 02 80 00 0b be 4000d23c <rtems_bdbuf_swapout_write+0xfc>
4000d214: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
4000d218: 84 14 62 48 or %l1, 0x248, %g2
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4000d21c: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
4000d220: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000d224: 80 a0 c0 02 cmp %g3, %g2
4000d228: 1a 80 00 06 bcc 4000d240 <rtems_bdbuf_swapout_write+0x100>
4000d22c: 90 10 00 1d mov %i5, %o0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
4000d230: 80 88 60 ff btst 0xff, %g1
4000d234: 02 80 00 08 be 4000d254 <rtems_bdbuf_swapout_write+0x114>
4000d238: 01 00 00 00 nop
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4000d23c: 90 10 00 1d mov %i5, %o0
4000d240: 7f ff ff 54 call 4000cf90 <rtems_bdbuf_execute_transfer_request>
4000d244: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000d248: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000d24c: e0 20 60 0c st %l0, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
4000d250: c0 20 60 10 clr [ %g1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get_unprotected(
rtems_chain_control *the_chain
)
{
return _Chain_Get_unprotected( the_chain );
4000d254: 7f ff fb 52 call 4000bf9c <_Chain_Get_unprotected>
4000d258: 90 10 00 18 mov %i0, %o0
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
4000d25c: 80 a2 20 00 cmp %o0, 0
4000d260: 12 bf ff ca bne 4000d188 <rtems_bdbuf_swapout_write+0x48>
4000d264: 80 a6 60 00 cmp %i1, 0
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
4000d268: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
4000d26c: 80 a0 60 00 cmp %g1, 0
4000d270: 02 80 00 0a be 4000d298 <rtems_bdbuf_swapout_write+0x158>
4000d274: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
4000d278: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000d27c: 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 &&
4000d280: 80 88 60 02 btst 2, %g1
4000d284: 02 80 00 05 be 4000d298 <rtems_bdbuf_swapout_write+0x158> <== ALWAYS TAKEN
4000d288: 92 10 20 02 mov 2, %o1
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
4000d28c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
4000d290: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000d294: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000d298: 81 c7 e0 08 ret
4000d29c: 81 e8 00 00 restore
4000c224 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4000c224: 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)));
4000c228: 03 10 00 61 sethi %hi(0x40018400), %g1
4000c22c: d0 00 62 4c ld [ %g1 + 0x24c ], %o0 ! 4001864c <rtems_bdbuf_configuration+0x4>
4000c230: 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 =
4000c234: 7f ff e0 c7 call 40004550 <malloc>
4000c238: 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)
4000c23c: b0 92 20 00 orcc %o0, 0, %i0
4000c240: 12 80 00 04 bne 4000c250 <rtems_bdbuf_swapout_writereq_alloc+0x2c><== ALWAYS TAKEN
4000c244: 82 10 20 01 mov 1, %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
4000c248: 7f ff ff 69 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c24c: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
4000c250: c2 26 00 00 st %g1, [ %i0 ]
write_req->done = rtems_bdbuf_transfer_done;
4000c254: 03 10 00 33 sethi %hi(0x4000cc00), %g1
4000c258: 82 10 63 78 or %g1, 0x378, %g1 ! 4000cf78 <rtems_bdbuf_transfer_done>
write_req->io_task = rtems_task_self ();
4000c25c: 40 00 11 41 call 40010760 <rtems_task_self>
4000c260: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000c264: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return write_req;
}
4000c268: 81 c7 e0 08 ret
4000c26c: 81 e8 00 00 restore
4000e12c <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
4000e12c: 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)
4000e130: 80 a6 20 00 cmp %i0, 0
4000e134: 02 80 00 49 be 4000e258 <rtems_bdbuf_sync+0x12c> <== NEVER TAKEN
4000e138: 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();
4000e13c: 7f ff f7 bd call 4000c030 <rtems_bdbuf_lock_cache>
4000e140: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4000e144: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000e148: 80 a2 20 03 cmp %o0, 3
4000e14c: 0a 80 00 3d bcs 4000e240 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000e150: 92 10 20 11 mov 0x11, %o1
4000e154: 80 a2 20 05 cmp %o0, 5
4000e158: 08 80 00 06 bleu 4000e170 <rtems_bdbuf_sync+0x44>
4000e15c: 82 10 20 08 mov 8, %g1
4000e160: 80 a2 20 06 cmp %o0, 6
4000e164: 12 80 00 37 bne 4000e240 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000e168: 01 00 00 00 nop
4000e16c: 30 80 00 32 b,a 4000e234 <rtems_bdbuf_sync+0x108>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000e170: 11 10 00 67 sethi %hi(0x40019c00), %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e174: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
4000e178: 90 12 23 74 or %o0, 0x374, %o0
4000e17c: c2 02 20 60 ld [ %o0 + 0x60 ], %g1
the_node->next = tail;
4000e180: 84 02 20 5c add %o0, 0x5c, %g2
tail->previous = the_node;
4000e184: f0 22 20 60 st %i0, [ %o0 + 0x60 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000e188: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
4000e18c: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
4000e190: c2 26 20 04 st %g1, [ %i0 + 4 ]
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
4000e194: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000e198: 80 a0 60 00 cmp %g1, 0
4000e19c: 02 80 00 04 be 4000e1ac <rtems_bdbuf_sync+0x80>
4000e1a0: 01 00 00 00 nop
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000e1a4: 7f ff f8 4c call 4000c2d4 <rtems_bdbuf_wake>
4000e1a8: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake_swapper ();
4000e1ac: 7f ff f7 bc call 4000c09c <rtems_bdbuf_wake_swapper>
4000e1b0: 3b 10 00 67 sethi %hi(0x40019c00), %i5
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000e1b4: ba 17 63 e0 or %i5, 0x3e0, %i5 ! 40019fe0 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e1b8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000e1bc: 80 a2 20 01 cmp %o0, 1
4000e1c0: 0a 80 00 20 bcs 4000e240 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000e1c4: 92 10 20 15 mov 0x15, %o1
4000e1c8: 80 a2 20 07 cmp %o0, 7
4000e1cc: 28 80 00 0a bleu,a 4000e1f4 <rtems_bdbuf_sync+0xc8>
4000e1d0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000e1d4: 80 a2 20 0a cmp %o0, 0xa
4000e1d8: 18 80 00 1a bgu 4000e240 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000e1dc: 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);
4000e1e0: 90 10 00 18 mov %i0, %o0
4000e1e4: 7f ff f7 f2 call 4000c1ac <rtems_bdbuf_wait>
4000e1e8: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e1ec: 10 bf ff f4 b 4000e1bc <rtems_bdbuf_sync+0x90>
4000e1f0: 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
4000e1f4: 80 a0 60 00 cmp %g1, 0
4000e1f8: 12 80 00 14 bne 4000e248 <rtems_bdbuf_sync+0x11c>
4000e1fc: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
4000e200: 80 a0 60 01 cmp %g1, 1
4000e204: 18 80 00 11 bgu 4000e248 <rtems_bdbuf_sync+0x11c> <== NEVER TAKEN
4000e208: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
4000e20c: 32 80 00 07 bne,a 4000e228 <rtems_bdbuf_sync+0xfc>
4000e210: 11 10 00 67 sethi %hi(0x40019c00), %o0
{
rtems_bdbuf_remove_from_tree (bd);
4000e214: 7f ff f8 55 call 4000c368 <rtems_bdbuf_remove_from_tree>
4000e218: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000e21c: 7f ff f9 39 call 4000c700 <rtems_bdbuf_make_free_and_add_to_lru_list>
4000e220: 90 10 00 18 mov %i0, %o0
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000e224: 11 10 00 67 sethi %hi(0x40019c00), %o0
4000e228: 7f ff f8 2b call 4000c2d4 <rtems_bdbuf_wake>
4000e22c: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 40019fe8 <bdbuf_cache+0x74>
4000e230: 30 80 00 06 b,a 4000e248 <rtems_bdbuf_sync+0x11c>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_sync_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4000e234: 7f ff fd 96 call 4000d88c <rtems_bdbuf_discard_buffer_after_access>
4000e238: 90 10 00 18 mov %i0, %o0
break;
4000e23c: 30 80 00 03 b,a 4000e248 <rtems_bdbuf_sync+0x11c>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
4000e240: 7f ff f7 82 call 4000c048 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e244: 01 00 00 00 nop <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000e248: 7f ff f7 8f call 4000c084 <rtems_bdbuf_unlock_cache>
4000e24c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
4000e250: 81 c7 e0 08 ret
4000e254: 81 e8 00 00 restore
}
4000e258: 81 c7 e0 08 ret <== NOT EXECUTED
4000e25c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
4000c05c <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)
{
4000c05c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
4000c060: 7f ff f0 c8 call 40008380 <rtems_semaphore_release>
4000c064: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
4000c068: 80 a2 20 00 cmp %o0, 0
4000c06c: 02 80 00 04 be 4000c07c <rtems_bdbuf_unlock+0x20> <== ALWAYS TAKEN
4000c070: 01 00 00 00 nop
rtems_bdbuf_fatal (fatal_error_code);
4000c074: 7f ff ff de call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c078: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000c07c: 81 c7 e0 08 ret
4000c080: 81 e8 00 00 restore
4000c1e0 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4000c1e0: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
4000c1e4: 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;
4000c1e8: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
4000c1ec: 90 10 00 18 mov %i0, %o0
4000c1f0: 94 10 20 00 clr %o2
4000c1f4: 7f ff ee 8b call 40007c20 <rtems_event_receive>
4000c1f8: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
4000c1fc: 80 a2 20 00 cmp %o0, 0
4000c200: 12 80 00 05 bne 4000c214 <rtems_bdbuf_wait_for_event+0x34><== NEVER TAKEN
4000c204: c2 07 bf fc ld [ %fp + -4 ], %g1
4000c208: 80 a0 40 18 cmp %g1, %i0
4000c20c: 02 80 00 04 be 4000c21c <rtems_bdbuf_wait_for_event+0x3c> <== ALWAYS TAKEN
4000c210: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
4000c214: 7f ff ff 76 call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c218: 90 10 20 1c mov 0x1c, %o0 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
4000c21c: 81 c7 e0 08 ret
4000c220: 81 e8 00 00 restore
4000c6cc <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
4000c6cc: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
4000c6d0: 11 20 00 00 sethi %hi(0x80000000), %o0
4000c6d4: 92 10 20 00 clr %o1
4000c6d8: 94 10 20 00 clr %o2
4000c6dc: 40 00 0f a1 call 40010560 <rtems_event_system_receive>
4000c6e0: 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)
4000c6e4: 80 a2 20 00 cmp %o0, 0
4000c6e8: 02 80 00 04 be 4000c6f8 <rtems_bdbuf_wait_for_transient_event+0x2c><== ALWAYS TAKEN
4000c6ec: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
4000c6f0: 7f ff fe 3f call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c6f4: 90 10 20 1d mov 0x1d, %o0 ! 1d <PROM_START+0x1d> <== NOT EXECUTED
4000c6f8: 81 c7 e0 08 ret
4000c6fc: 81 e8 00 00 restore
4000c2d4 <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)
{
4000c2d4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
4000c2d8: c2 06 00 00 ld [ %i0 ], %g1
4000c2dc: 80 a0 60 00 cmp %g1, 0
4000c2e0: 02 80 00 09 be 4000c304 <rtems_bdbuf_wake+0x30>
4000c2e4: 01 00 00 00 nop
{
sc = rtems_semaphore_flush (waiters->sema);
4000c2e8: 40 00 10 74 call 400104b8 <rtems_semaphore_flush>
4000c2ec: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4000c2f0: 80 a2 20 00 cmp %o0, 0
4000c2f4: 02 80 00 04 be 4000c304 <rtems_bdbuf_wake+0x30> <== ALWAYS TAKEN
4000c2f8: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
4000c2fc: 7f ff ff 3c call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c300: 90 10 20 04 mov 4, %o0 ! 4 <PROM_START+0x4> <== NOT EXECUTED
4000c304: 81 c7 e0 08 ret
4000c308: 81 e8 00 00 restore
4000c09c <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
4000c09c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4000c0a0: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000c0a4: d0 00 63 74 ld [ %g1 + 0x374 ], %o0 ! 40019f74 <bdbuf_cache>
4000c0a8: 7f ff ef 40 call 40007da8 <rtems_event_send>
4000c0ac: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000c0b0: 80 a2 20 00 cmp %o0, 0
4000c0b4: 02 80 00 04 be 4000c0c4 <rtems_bdbuf_wake_swapper+0x28> <== ALWAYS TAKEN
4000c0b8: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
4000c0bc: 7f ff ff cc call 4000bfec <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c0c0: 90 10 20 0b mov 0xb, %o0 ! b <PROM_START+0xb> <== NOT EXECUTED
4000c0c4: 81 c7 e0 08 ret
4000c0c8: 81 e8 00 00 restore
400027d0 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
400027d0: 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;
400027d4: 80 a6 60 00 cmp %i1, 0
400027d8: 02 80 00 08 be 400027f8 <rtems_bdpart_create+0x28> <== NEVER TAKEN
400027dc: 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
400027e0: c2 06 40 00 ld [ %i1 ], %g1
400027e4: 80 a0 60 00 cmp %g1, 0
400027e8: 12 80 00 05 bne 400027fc <rtems_bdpart_create+0x2c> <== NEVER TAKEN
400027ec: a0 10 20 00 clr %l0
&& format->mbr.dos_compatibility;
400027f0: 10 80 00 03 b 400027fc <rtems_bdpart_create+0x2c>
400027f4: e0 0e 60 08 ldub [ %i1 + 8 ], %l0
400027f8: a0 10 20 00 clr %l0 <== NOT EXECUTED
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
400027fc: a0 0c 20 01 and %l0, 1, %l0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
40002800: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
40002804: 82 0c 20 ff and %l0, 0xff, %g1
40002808: 80 a0 00 01 cmp %g0, %g1
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
4000280c: b0 10 20 00 clr %i0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
40002810: ba 40 3f ff addx %g0, -1, %i5
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
40002814: 80 a7 20 00 cmp %i4, 0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
40002818: ba 0f 7f c2 and %i5, -62, %i5
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
4000281c: 02 80 00 70 be 400029dc <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40002820: ba 07 60 3f add %i5, 0x3f, %i5
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
40002824: 80 a6 a0 00 cmp %i2, 0
40002828: 02 80 00 6d be 400029dc <rtems_bdpart_create+0x20c> <== NEVER TAKEN
4000282c: b0 10 20 09 mov 9, %i0
40002830: 80 a6 60 00 cmp %i1, 0
40002834: 02 80 00 6a be 400029dc <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40002838: 80 a6 e0 00 cmp %i3, 0
4000283c: 02 80 00 68 be 400029dc <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40002840: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
40002844: 94 10 20 00 clr %o2
40002848: 40 00 01 2a call 40002cf0 <rtems_bdpart_get_disk_data>
4000284c: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002850: b0 92 20 00 orcc %o0, 0, %i0
40002854: 12 80 00 62 bne 400029dc <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40002858: 82 10 20 00 clr %g1
4000285c: 84 10 20 00 clr %g2
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
40002860: 87 28 60 02 sll %g1, 2, %g3
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
40002864: c6 06 c0 03 ld [ %i3 + %g3 ], %g3
40002868: a8 00 c0 02 add %g3, %g2, %l4
if (dist_sum < prev_sum) {
4000286c: 80 a5 00 02 cmp %l4, %g2
40002870: 1a 80 00 04 bcc 40002880 <rtems_bdpart_create+0xb0> <== ALWAYS TAKEN
40002874: 80 a0 e0 00 cmp %g3, 0
return RTEMS_INVALID_NUMBER;
40002878: 81 c7 e0 08 ret <== NOT EXECUTED
4000287c: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
}
if (dist [i] == 0) {
40002880: 02 bf ff fe be 40002878 <rtems_bdpart_create+0xa8> <== NEVER TAKEN
40002884: 82 00 60 01 inc %g1
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
40002888: 80 a0 40 1c cmp %g1, %i4
4000288c: 12 bf ff f5 bne 40002860 <rtems_bdpart_create+0x90>
40002890: 84 10 00 14 mov %l4, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
40002894: c2 06 40 00 ld [ %i1 ], %g1
40002898: 80 a0 60 00 cmp %g1, 0
4000289c: 12 80 00 52 bne 400029e4 <rtems_bdpart_create+0x214> <== NEVER TAKEN
400028a0: 80 8c 20 ff btst 0xff, %l0
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
400028a4: 02 80 00 09 be 400028c8 <rtems_bdpart_create+0xf8> <== NEVER TAKEN
400028a8: 80 a7 20 04 cmp %i4, 4
disk_end -= (disk_end % record_space);
400028ac: f2 07 bf fc ld [ %fp + -4 ], %i1
400028b0: 92 10 00 1d mov %i5, %o1
400028b4: 40 00 78 d9 call 40020c18 <.urem>
400028b8: 90 10 00 19 mov %i1, %o0
400028bc: 90 26 40 08 sub %i1, %o0, %o0
400028c0: d0 27 bf fc st %o0, [ %fp + -4 ]
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
400028c4: 80 a7 20 04 cmp %i4, 4
400028c8: 08 80 00 06 bleu 400028e0 <rtems_bdpart_create+0x110> <== NEVER TAKEN
400028cc: b2 10 00 1d mov %i5, %i1
overhead += (count - 3) * record_space;
400028d0: 90 10 00 1d mov %i5, %o0
400028d4: 40 00 77 eb call 40020880 <.umul>
400028d8: 92 07 3f fd add %i4, -3, %o1
400028dc: b2 02 00 1d add %o0, %i5, %i1
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
400028e0: 80 8c 20 ff btst 0xff, %l0
400028e4: 02 80 00 07 be 40002900 <rtems_bdpart_create+0x130> <== NEVER TAKEN
400028e8: e6 07 bf fc ld [ %fp + -4 ], %l3
overhead += (count - 1) * record_space;
400028ec: 90 10 00 1d mov %i5, %o0
400028f0: 40 00 77 e4 call 40020880 <.umul>
400028f4: 92 07 3f ff add %i4, -1, %o1
400028f8: b2 06 40 08 add %i1, %o0, %i1
}
/* Check disk space */
if ((overhead + count) > disk_end) {
400028fc: e6 07 bf fc ld [ %fp + -4 ], %l3
40002900: 82 06 40 1c add %i1, %i4, %g1
40002904: 80 a0 40 13 cmp %g1, %l3
40002908: 38 80 00 35 bgu,a 400029dc <rtems_bdpart_create+0x20c> <== NEVER TAKEN
4000290c: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
40002910: aa 24 c0 19 sub %l3, %i1, %l5
40002914: a2 10 00 1a mov %i2, %l1
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
40002918: a0 10 00 1d mov %i5, %l0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
4000291c: b2 10 20 00 clr %i1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
40002920: 83 2e 60 02 sll %i1, 2, %g1
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
40002924: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
40002928: 92 10 00 15 mov %l5, %o1
4000292c: 40 00 77 d5 call 40020880 <.umul>
40002930: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
40002934: 80 a2 00 15 cmp %o0, %l5
40002938: 0a bf ff d0 bcs 40002878 <rtems_bdpart_create+0xa8> <== NEVER TAKEN
4000293c: 80 a2 00 12 cmp %o0, %l2
40002940: 0a bf ff ce bcs 40002878 <rtems_bdpart_create+0xa8> <== NEVER TAKEN
40002944: 01 00 00 00 nop
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
40002948: 40 00 78 08 call 40020968 <.udiv>
4000294c: 92 10 00 14 mov %l4, %o1
/* Ensure that the partition is not empty */
if (s == 0) {
40002950: a4 92 20 00 orcc %o0, 0, %l2
40002954: 22 80 00 02 be,a 4000295c <rtems_bdpart_create+0x18c> <== NEVER TAKEN
40002958: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
4000295c: 90 10 00 12 mov %l2, %o0
40002960: 40 00 78 ae call 40020c18 <.urem>
40002964: 92 10 00 1d mov %i5, %o1
40002968: a4 04 80 1d add %l2, %i5, %l2
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
4000296c: 82 10 20 01 mov 1, %g1
40002970: 80 a6 60 02 cmp %i1, 2
40002974: 18 80 00 03 bgu 40002980 <rtems_bdpart_create+0x1b0>
40002978: 90 24 80 08 sub %l2, %o0, %o0
4000297c: 82 10 20 00 clr %g1
40002980: 80 88 60 ff btst 0xff, %g1
40002984: 22 80 00 0a be,a 400029ac <rtems_bdpart_create+0x1dc>
40002988: e0 24 40 00 st %l0, [ %l1 ]
4000298c: 80 a7 20 04 cmp %i4, 4
40002990: 18 80 00 03 bgu 4000299c <rtems_bdpart_create+0x1cc> <== ALWAYS TAKEN
40002994: 82 10 20 01 mov 1, %g1
40002998: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000299c: 80 88 60 ff btst 0xff, %g1
400029a0: 32 80 00 02 bne,a 400029a8 <rtems_bdpart_create+0x1d8> <== ALWAYS TAKEN
400029a4: a0 04 00 1d add %l0, %i5, %l0
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
400029a8: e0 24 40 00 st %l0, [ %l1 ]
pos += s;
400029ac: a0 04 00 08 add %l0, %o0, %l0
p->end = pos;
400029b0: e0 24 60 04 st %l0, [ %l1 + 4 ]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
400029b4: b2 06 60 01 inc %i1
400029b8: 80 a6 40 1c cmp %i1, %i4
400029bc: 12 bf ff d9 bne 40002920 <rtems_bdpart_create+0x150>
400029c0: a2 04 60 30 add %l1, 0x30, %l1
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
400029c4: b2 06 7f ff add %i1, -1, %i1
400029c8: 83 2e 60 04 sll %i1, 4, %g1
400029cc: b3 2e 60 06 sll %i1, 6, %i1
400029d0: b2 26 40 01 sub %i1, %g1, %i1
400029d4: b4 06 80 19 add %i2, %i1, %i2
400029d8: e6 26 a0 04 st %l3, [ %i2 + 4 ]
400029dc: 81 c7 e0 08 ret
400029e0: 81 e8 00 00 restore
400029e4: b0 10 20 18 mov 0x18, %i0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
400029e8: 81 c7 e0 08 ret <== NOT EXECUTED
400029ec: 81 e8 00 00 restore <== NOT EXECUTED
400029f0 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
400029f0: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
400029f4: 11 10 00 90 sethi %hi(0x40024000), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
400029f8: 35 10 00 90 sethi %hi(0x40024000), %i2
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
400029fc: 90 12 21 f0 or %o0, 0x1f0, %o0
40002a00: 40 00 48 be call 40014cf8 <puts>
40002a04: 27 10 00 90 sethi %hi(0x40024000), %l3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002a08: 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";
40002a0c: 37 10 00 90 sethi %hi(0x40024000), %i3
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002a10: b4 16 a3 30 or %i2, 0x330, %i2
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
40002a14: 21 10 00 90 sethi %hi(0x40024000), %l0
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
40002a18: 23 10 00 90 sethi %hi(0x40024000), %l1
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
40002a1c: 25 10 00 90 sethi %hi(0x40024000), %l2
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002a20: 10 80 00 39 b 40002b04 <rtems_bdpart_dump+0x114>
40002a24: a6 14 e3 38 or %l3, 0x338, %l3
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
40002a28: b8 06 20 08 add %i0, 8, %i4
40002a2c: 92 07 bf c7 add %fp, -57, %o1
40002a30: 40 00 00 a4 call 40002cc0 <rtems_bdpart_to_mbr_partition_type>
40002a34: 90 10 00 1c mov %i4, %o0
40002a38: 80 8a 20 ff btst 0xff, %o0
40002a3c: 22 80 00 27 be,a 40002ad8 <rtems_bdpart_dump+0xe8> <== NEVER TAKEN
40002a40: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
switch (type_mbr) {
40002a44: d6 0f bf c7 ldub [ %fp + -57 ], %o3
40002a48: 82 0a e0 ff and %o3, 0xff, %g1
40002a4c: 80 a0 60 0b cmp %g1, 0xb
40002a50: 22 80 00 27 be,a 40002aec <rtems_bdpart_dump+0xfc> <== ALWAYS TAKEN
40002a54: 96 16 e1 d8 or %i3, 0x1d8, %o3
40002a58: 18 80 00 09 bgu 40002a7c <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
40002a5c: 80 a0 60 0e cmp %g1, 0xe <== NOT EXECUTED
40002a60: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40002a64: 02 80 00 0e be 40002a9c <rtems_bdpart_dump+0xac> <== NOT EXECUTED
40002a68: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
40002a6c: 12 80 00 15 bne 40002ac0 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
40002a70: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
40002a74: 10 80 00 1d b 40002ae8 <rtems_bdpart_dump+0xf8> <== NOT EXECUTED
40002a78: 17 10 00 90 sethi %hi(0x40024000), %o3 <== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
40002a7c: 02 80 00 0b be 40002aa8 <rtems_bdpart_dump+0xb8> <== NOT EXECUTED
40002a80: 80 a0 60 da cmp %g1, 0xda <== NOT EXECUTED
40002a84: 02 80 00 0d be 40002ab8 <rtems_bdpart_dump+0xc8> <== NOT EXECUTED
40002a88: 80 a0 60 0c cmp %g1, 0xc <== NOT EXECUTED
40002a8c: 12 80 00 0d bne 40002ac0 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
40002a90: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
40002a94: 10 80 00 07 b 40002ab0 <rtems_bdpart_dump+0xc0> <== NOT EXECUTED
40002a98: 96 14 a1 c8 or %l2, 0x1c8, %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";
40002a9c: 17 10 00 90 sethi %hi(0x40024000), %o3 <== NOT EXECUTED
40002aa0: 10 80 00 13 b 40002aec <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40002aa4: 96 12 e1 b8 or %o3, 0x1b8, %o3 ! 400241b8 <__FUNCTION__.6193+0x260><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
40002aa8: 10 80 00 11 b 40002aec <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40002aac: 96 14 21 e0 or %l0, 0x1e0, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
40002ab0: 10 80 00 10 b 40002af0 <rtems_bdpart_dump+0x100> <== NOT EXECUTED
40002ab4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
40002ab8: 10 80 00 0d b 40002aec <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40002abc: 96 14 61 c0 or %l1, 0x1c0, %o3 <== NOT EXECUTED
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002ac0: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
40002ac4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40002ac8: 40 00 48 c6 call 40014de0 <snprintf> <== NOT EXECUTED
40002acc: 96 0a e0 ff and %o3, 0xff, %o3 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
40002ad0: 10 80 00 07 b 40002aec <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40002ad4: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
40002ad8: 40 00 2a 09 call 4000d2fc <uuid_unparse_lower> <== NOT EXECUTED
40002adc: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
40002ae0: 10 80 00 03 b 40002aec <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40002ae4: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
40002ae8: 96 12 e1 b0 or %o3, 0x1b0, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40002aec: d2 06 00 00 ld [ %i0 ], %o1
40002af0: d4 06 20 04 ld [ %i0 + 4 ], %o2
40002af4: 90 10 00 13 mov %l3, %o0
40002af8: 40 00 48 4a call 40014c20 <printf>
40002afc: ba 07 60 01 inc %i5
40002b00: b0 06 20 30 add %i0, 0x30, %i0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002b04: 80 a7 40 19 cmp %i5, %i1
40002b08: 32 bf ff c8 bne,a 40002a28 <rtems_bdpart_dump+0x38>
40002b0c: c0 2f bf c7 clrb [ %fp + -57 ]
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
40002b10: 11 10 00 90 sethi %hi(0x40024000), %o0
40002b14: 40 00 48 79 call 40014cf8 <puts>
40002b18: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 400242e0 <__FUNCTION__.6193+0x388>
40002b1c: 81 c7 e0 08 ret
40002b20: 81 e8 00 00 restore
40002cf0 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
40002cf0: 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);
40002cf4: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
40002cf8: 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);
40002cfc: 40 00 0c 66 call 40005e94 <open>
40002d00: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
40002d04: ba 92 20 00 orcc %o0, 0, %i5
40002d08: 36 80 00 04 bge,a 40002d18 <rtems_bdpart_get_disk_data+0x28><== ALWAYS TAKEN
40002d0c: 13 10 01 10 sethi %hi(0x40044000), %o1
sc = RTEMS_INVALID_NAME;
40002d10: 10 80 00 12 b 40002d58 <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
40002d14: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
40002d18: 94 07 bf fc add %fp, -4, %o2
40002d1c: 40 00 09 43 call 40005228 <ioctl>
40002d20: 92 12 62 09 or %o1, 0x209, %o1
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
40002d24: 80 a2 20 00 cmp %o0, 0
40002d28: 32 80 00 0c bne,a 40002d58 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
40002d2c: 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;
40002d30: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
40002d34: c4 18 60 18 ldd [ %g1 + 0x18 ], %g2
40002d38: c6 26 c0 00 st %g3, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
40002d3c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40002d40: 80 a0 61 ff cmp %g1, 0x1ff
40002d44: 08 80 00 05 bleu 40002d58 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
40002d48: b0 10 20 1b mov 0x1b, %i0
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
40002d4c: 80 a0 00 02 cmp %g0, %g2
40002d50: b0 60 20 00 subx %g0, 0, %i0
40002d54: b0 0e 20 1b and %i0, 0x1b, %i0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
40002d58: 80 a6 20 00 cmp %i0, 0
40002d5c: 12 80 00 0a bne 40002d84 <rtems_bdpart_get_disk_data+0x94><== NEVER TAKEN
40002d60: 80 a6 60 00 cmp %i1, 0
40002d64: 02 80 00 08 be 40002d84 <rtems_bdpart_get_disk_data+0x94>
40002d68: 80 a6 a0 00 cmp %i2, 0
40002d6c: 02 80 00 06 be 40002d84 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
40002d70: c2 07 bf fc ld [ %fp + -4 ], %g1
*fd_ptr = fd;
40002d74: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
40002d78: c2 26 80 00 st %g1, [ %i2 ]
40002d7c: 81 c7 e0 08 ret
40002d80: 81 e8 00 00 restore
} else {
close( fd);
40002d84: 40 00 08 8b call 40004fb0 <close>
40002d88: 90 10 00 1d mov %i5, %o0
}
return sc;
}
40002d8c: 81 c7 e0 08 ret
40002d90: 81 e8 00 00 restore
40020848 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40020848: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
4002084c: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
40020850: 40 00 76 8b call 4003e27c <strrchr> <== NOT EXECUTED
40020854: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020858: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
4002085c: 40 00 72 65 call 4003d1f0 <strlen> <== NOT EXECUTED
40020860: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020864: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
40020868: 40 00 72 62 call 4003d1f0 <strlen> <== NOT EXECUTED
4002086c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
40020870: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
40020874: 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);
40020878: 7f ff 89 70 call 40002e38 <malloc> <== NOT EXECUTED
4002087c: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
40020880: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020884: 02 80 00 4d be 400209b8 <rtems_bdpart_mount+0x170> <== NOT EXECUTED
40020888: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
4002088c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40020890: 40 00 73 14 call 4003d4e0 <strncpy> <== NOT EXECUTED
40020894: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
40020898: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4002089c: 22 80 00 06 be,a 400208b4 <rtems_bdpart_mount+0x6c> <== NOT EXECUTED
400208a0: a4 10 00 10 mov %l0, %l2 <== NOT EXECUTED
disk_file_name += 1;
400208a4: b0 07 60 01 add %i5, 1, %i0 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
400208a8: 40 00 72 52 call 4003d1f0 <strlen> <== NOT EXECUTED
400208ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400208b0: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
400208b4: a6 04 80 11 add %l2, %l1, %l3 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
400208b8: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
400208bc: 7f ff 89 5f call 40002e38 <malloc> <== NOT EXECUTED
400208c0: 90 04 e0 05 add %l3, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
400208c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400208c8: 02 80 00 38 be 400209a8 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
400208cc: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
400208d0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400208d4: 40 00 73 03 call 4003d4e0 <strncpy> <== NOT EXECUTED
400208d8: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
400208dc: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400208e0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
400208e4: c2 2f 40 11 stb %g1, [ %i5 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400208e8: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED
400208ec: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
400208f0: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
400208f4: a6 04 e0 01 inc %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400208f8: 37 10 01 6c sethi %hi(0x4005b000), %i3 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400208fc: 40 00 72 f9 call 4003d4e0 <strncpy> <== NOT EXECUTED
40020900: 31 10 01 65 sethi %hi(0x40059400), %i0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
40020904: a0 06 40 10 add %i1, %l0, %l0 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40020908: a6 07 40 13 add %i5, %l3, %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
4002090c: b8 10 20 00 clr %i4 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40020910: b6 16 e3 a8 or %i3, 0x3a8, %i3 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40020914: 10 80 00 1d b 40020988 <rtems_bdpart_mount+0x140> <== NOT EXECUTED
40020918: b0 16 20 c8 or %i0, 0xc8, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
4002091c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40020920: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020924: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40020928: 40 00 6e 94 call 4003c378 <snprintf> <== NOT EXECUTED
4002092c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40020930: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
40020934: 14 80 00 1a bg 4002099c <rtems_bdpart_mount+0x154> <== NOT EXECUTED
40020938: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
4002093c: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
40020940: 40 00 72 e8 call 4003d4e0 <strncpy> <== NOT EXECUTED
40020944: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
40020948: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002094c: 40 00 0f 2c call 400245fc <rtems_mkdir> <== NOT EXECUTED
40020950: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
40020954: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020958: 12 80 00 13 bne 400209a4 <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
4002095c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
40020960: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020964: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40020968: 96 10 20 00 clr %o3 <== NOT EXECUTED
4002096c: 7f ff 89 ba call 40003054 <mount> <== NOT EXECUTED
40020970: 98 10 20 00 clr %o4 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
40020974: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020978: 02 80 00 05 be 4002098c <rtems_bdpart_mount+0x144> <== NOT EXECUTED
4002097c: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
rmdir( mount_point);
40020980: 40 00 0e f7 call 4002455c <rmdir> <== NOT EXECUTED
40020984: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40020988: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
4002098c: 32 bf ff e4 bne,a 4002091c <rtems_bdpart_mount+0xd4> <== NOT EXECUTED
40020990: b8 07 20 01 inc %i4 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
40020994: 10 80 00 05 b 400209a8 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
40020998: b8 10 20 00 clr %i4 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
4002099c: 10 80 00 03 b 400209a8 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
400209a0: b8 10 20 03 mov 3, %i4 <== NOT EXECUTED
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
esc = RTEMS_IO_ERROR;
400209a4: b8 10 20 1b mov 0x1b, %i4 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
400209a8: 7f ff 88 50 call 40002ae8 <free> <== NOT EXECUTED
400209ac: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
400209b0: 7f ff 88 4e call 40002ae8 <free> <== NOT EXECUTED
400209b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
400209b8: 81 c7 e0 08 ret <== NOT EXECUTED
400209bc: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
400031d0 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
400031d0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
400031d4: d0 06 80 00 ld [ %i2 ], %o0
400031d8: 80 a2 20 00 cmp %o0, 0
400031dc: 12 80 00 0b bne 40003208 <rtems_bdpart_new_record+0x38>
400031e0: 01 00 00 00 nop
return sc;
}
}
/* Read the new record block (this accounts for disk block sizes > 512) */
sc = rtems_bdbuf_read( dd, index, block);
400031e4: 90 10 00 18 mov %i0, %o0
400031e8: 92 10 00 19 mov %i1, %o1
400031ec: 40 00 30 09 call 4000f210 <rtems_bdbuf_read>
400031f0: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
400031f4: ba 92 20 00 orcc %o0, 0, %i5
400031f8: 22 80 00 0b be,a 40003224 <rtems_bdpart_new_record+0x54> <== ALWAYS TAKEN
400031fc: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
40003200: 81 c7 e0 08 ret <== NOT EXECUTED
40003204: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
sc = rtems_bdbuf_sync( *block);
40003208: 40 00 30 d0 call 4000f548 <rtems_bdbuf_sync>
4000320c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40003210: ba 92 20 00 orcc %o0, 0, %i5
40003214: 02 bf ff f5 be 400031e8 <rtems_bdpart_new_record+0x18> <== ALWAYS TAKEN
40003218: 90 10 00 18 mov %i0, %o0
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
4000321c: 81 c7 e0 08 ret <== NOT EXECUTED
40003220: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
40003224: 80 a0 60 00 cmp %g1, 0
40003228: 02 80 00 0e be 40003260 <rtems_bdpart_new_record+0x90> <== NEVER TAKEN
4000322c: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
40003230: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40003234: 40 00 46 28 call 40014ad4 <memset>
40003238: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
4000323c: c2 06 80 00 ld [ %i2 ], %g1
40003240: 84 10 20 55 mov 0x55, %g2
40003244: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40003248: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
4000324c: c2 06 80 00 ld [ %i2 ], %g1
40003250: 84 10 3f aa mov -86, %g2
40003254: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40003258: 10 80 00 03 b 40003264 <rtems_bdpart_new_record+0x94>
4000325c: c4 28 61 ff stb %g2, [ %g1 + 0x1ff ]
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
40003260: 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;
}
40003264: b0 10 00 1d mov %i5, %i0
40003268: 81 c7 e0 08 ret
4000326c: 81 e8 00 00 restore
40002d94 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
40002d94: 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;
40002d98: 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;
40002d9c: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
40002da0: c2 27 bf ec st %g1, [ %fp + -20 ]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40002da4: 80 a6 e0 00 cmp %i3, 0
40002da8: 02 80 00 07 be 40002dc4 <rtems_bdpart_read+0x30> <== NEVER TAKEN
40002dac: 90 10 00 18 mov %i0, %o0
40002db0: c2 06 c0 00 ld [ %i3 ], %g1
40002db4: 85 28 60 04 sll %g1, 4, %g2
40002db8: b9 28 60 06 sll %g1, 6, %i4
40002dbc: 10 80 00 03 b 40002dc8 <rtems_bdpart_read+0x34>
40002dc0: b8 27 00 02 sub %i4, %g2, %i4
40002dc4: b8 10 20 00 clr %i4 <== NOT EXECUTED
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
40002dc8: 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 */
40002dcc: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
40002dd0: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
40002dd4: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
40002dd8: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
40002ddc: 80 a6 a0 00 cmp %i2, 0
40002de0: 02 80 00 89 be 40003004 <rtems_bdpart_read+0x270> <== NEVER TAKEN
40002de4: b0 10 20 09 mov 9, %i0
40002de8: 80 a6 60 00 cmp %i1, 0
40002dec: 02 80 00 86 be 40003004 <rtems_bdpart_read+0x270> <== NEVER TAKEN
40002df0: 80 a6 e0 00 cmp %i3, 0
40002df4: 02 80 00 84 be 40003004 <rtems_bdpart_read+0x270> <== NEVER TAKEN
40002df8: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
40002dfc: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40002e00: 94 07 bf fc add %fp, -4, %o2
40002e04: 7f ff ff bb call 40002cf0 <rtems_bdpart_get_disk_data>
40002e08: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002e0c: b0 92 20 00 orcc %o0, 0, %i0
40002e10: 12 80 00 7d bne 40003004 <rtems_bdpart_read+0x270> <== NEVER TAKEN
40002e14: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
40002e18: 92 10 20 00 clr %o1
40002e1c: 7f ff ff 4d call 40002b50 <rtems_bdpart_read_record>
40002e20: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40002e24: b0 92 20 00 orcc %o0, 0, %i0
40002e28: 12 80 00 6c bne 40002fd8 <rtems_bdpart_read+0x244> <== NEVER TAKEN
40002e2c: d0 07 bf f8 ld [ %fp + -8 ], %o0
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40002e30: c2 07 bf e8 ld [ %fp + -24 ], %g1
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40002e34: b8 06 80 1c add %i2, %i4, %i4
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40002e38: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40002e3c: a2 07 bf ec add %fp, -20, %l1
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40002e40: ba 04 a1 be add %l2, 0x1be, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40002e44: a0 07 bf f0 add %fp, -16, %l0
40002e48: 90 10 00 1d mov %i5, %o0
40002e4c: 92 10 00 11 mov %l1, %o1
40002e50: 94 10 00 1c mov %i4, %o2
40002e54: 7f ff ff 70 call 40002c14 <rtems_bdpart_read_mbr_partition>
40002e58: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002e5c: b0 92 20 00 orcc %o0, 0, %i0
40002e60: 32 80 00 5e bne,a 40002fd8 <rtems_bdpart_read+0x244> <== NEVER TAKEN
40002e64: 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) {
40002e68: c2 07 bf ec ld [ %fp + -20 ], %g1
40002e6c: c2 08 60 08 ldub [ %g1 + 8 ], %g1
40002e70: 80 a0 60 ee cmp %g1, 0xee
40002e74: 02 80 00 58 be 40002fd4 <rtems_bdpart_read+0x240> <== NEVER TAKEN
40002e78: 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
40002e7c: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
40002e80: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
40002e84: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
40002e88: a4 04 a1 ee add %l2, 0x1ee, %l2
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
40002e8c: 7f ff ff 26 call 40002b24 <rtems_uint32_from_little_endian>
40002e90: 90 02 21 b8 add %o0, 0x1b8, %o0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40002e94: 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(
40002e98: d0 26 60 04 st %o0, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40002e9c: c2 2e 60 08 stb %g1, [ %i1 + 8 ]
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
40002ea0: ba 07 60 10 add %i5, 0x10, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40002ea4: 92 10 00 11 mov %l1, %o1
40002ea8: 90 10 00 1d mov %i5, %o0
40002eac: 94 10 00 1c mov %i4, %o2
40002eb0: 7f ff ff 59 call 40002c14 <rtems_bdpart_read_mbr_partition>
40002eb4: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002eb8: 80 a2 20 00 cmp %o0, 0
40002ebc: 12 80 00 45 bne 40002fd0 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
40002ec0: 80 a7 40 12 cmp %i5, %l2
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
40002ec4: 32 bf ff f8 bne,a 40002ea4 <rtems_bdpart_read+0x110>
40002ec8: ba 07 60 10 add %i5, 0x10, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
40002ecc: 10 80 00 2e b 40002f84 <rtems_bdpart_read+0x1f0>
40002ed0: fa 07 bf f0 ld [ %fp + -16 ], %i5
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
40002ed4: 92 10 00 1d mov %i5, %o1
40002ed8: 7f ff ff 1e call 40002b50 <rtems_bdpart_read_record>
40002edc: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40002ee0: 80 a2 20 00 cmp %o0, 0
40002ee4: 12 80 00 3b bne 40002fd0 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
40002ee8: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
40002eec: 92 10 00 11 mov %l1, %o1
40002ef0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40002ef4: 94 10 00 1c mov %i4, %o2
40002ef8: 90 02 21 be add %o0, 0x1be, %o0
40002efc: 7f ff ff 46 call 40002c14 <rtems_bdpart_read_mbr_partition>
40002f00: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
40002f04: 80 a2 20 00 cmp %o0, 0
40002f08: 12 80 00 32 bne 40002fd0 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
40002f0c: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
40002f10: c6 00 40 00 ld [ %g1 ], %g3
40002f14: 84 07 40 03 add %i5, %g3, %g2
if (tmp > p->begin) {
40002f18: 80 a0 80 03 cmp %g2, %g3
40002f1c: 38 80 00 04 bgu,a 40002f2c <rtems_bdpart_read+0x198> <== ALWAYS TAKEN
40002f20: c4 20 40 00 st %g2, [ %g1 ]
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
40002f24: 10 80 00 2c b 40002fd4 <rtems_bdpart_read+0x240> <== NOT EXECUTED
40002f28: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
40002f2c: c4 00 60 04 ld [ %g1 + 4 ], %g2
40002f30: ba 07 40 02 add %i5, %g2, %i5
if (tmp > p->end) {
40002f34: 80 a7 40 02 cmp %i5, %g2
40002f38: 08 80 00 27 bleu 40002fd4 <rtems_bdpart_read+0x240> <== NEVER TAKEN
40002f3c: b0 10 20 1b mov 0x1b, %i0
p->end = tmp;
40002f40: fa 20 60 04 st %i5, [ %g1 + 4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
40002f44: c2 07 bf e8 ld [ %fp + -24 ], %g1
40002f48: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
== RTEMS_BDPART_MBR_SIGNATURE_1;
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
40002f4c: 7f ff fe f6 call 40002b24 <rtems_uint32_from_little_endian>
40002f50: 90 06 61 d6 add %i1, 0x1d6, %o0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
40002f54: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
40002f58: 80 a0 60 05 cmp %g1, 5
40002f5c: 12 80 00 0e bne 40002f94 <rtems_bdpart_read+0x200>
40002f60: c2 07 bf ec ld [ %fp + -20 ], %g1
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
40002f64: 80 a2 20 00 cmp %o0, 0
40002f68: 02 80 00 0a be 40002f90 <rtems_bdpart_read+0x1fc> <== NEVER TAKEN
40002f6c: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
40002f70: 82 02 00 01 add %o0, %g1, %g1
if (tmp > ebr) {
40002f74: 80 a0 40 08 cmp %g1, %o0
40002f78: 08 80 00 17 bleu 40002fd4 <rtems_bdpart_read+0x240> <== NEVER TAKEN
40002f7c: b0 10 20 1b mov 0x1b, %i0
40002f80: ba 10 00 01 mov %g1, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
40002f84: 80 a7 60 00 cmp %i5, 0
40002f88: 12 bf ff d3 bne 40002ed4 <rtems_bdpart_read+0x140> <== ALWAYS TAKEN
40002f8c: d0 07 bf fc ld [ %fp + -4 ], %o0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40002f90: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40002f94: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40002f98: b4 20 40 1a sub %g1, %i2, %i2
40002f9c: b5 3e a0 04 sra %i2, 4, %i2
40002fa0: 83 2e a0 02 sll %i2, 2, %g1
40002fa4: 82 00 40 1a add %g1, %i2, %g1
40002fa8: 85 28 60 04 sll %g1, 4, %g2
40002fac: 82 00 40 02 add %g1, %g2, %g1
40002fb0: 85 28 60 08 sll %g1, 8, %g2
40002fb4: 82 00 40 02 add %g1, %g2, %g1
40002fb8: 85 28 60 10 sll %g1, 0x10, %g2
40002fbc: 82 00 40 02 add %g1, %g2, %g1
40002fc0: 82 20 00 01 neg %g1
40002fc4: 82 00 60 01 inc %g1
40002fc8: 10 80 00 03 b 40002fd4 <rtems_bdpart_read+0x240>
40002fcc: c2 26 c0 00 st %g1, [ %i3 ]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
40002fd0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
40002fd4: d0 07 bf f8 ld [ %fp + -8 ], %o0
40002fd8: 80 a2 20 00 cmp %o0, 0
40002fdc: 26 80 00 05 bl,a 40002ff0 <rtems_bdpart_read+0x25c> <== NEVER TAKEN
40002fe0: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
40002fe4: 40 00 07 f3 call 40004fb0 <close>
40002fe8: 01 00 00 00 nop
}
if (block != NULL) {
40002fec: d0 07 bf e8 ld [ %fp + -24 ], %o0
40002ff0: 80 a2 20 00 cmp %o0, 0
40002ff4: 02 80 00 06 be 4000300c <rtems_bdpart_read+0x278> <== NEVER TAKEN
40002ff8: 01 00 00 00 nop
rtems_bdbuf_release( block);
40002ffc: 40 00 31 01 call 4000f400 <rtems_bdbuf_release>
40003000: 01 00 00 00 nop
40003004: 81 c7 e0 08 ret
40003008: 81 e8 00 00 restore
}
return esc;
}
4000300c: 81 c7 e0 08 ret <== NOT EXECUTED
40003010: 81 e8 00 00 restore <== NOT EXECUTED
40002c14 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
40002c14: 9d e3 bf a0 save %sp, -96, %sp
rtems_blkdev_bnum begin =
40002c18: 7f ff ff c3 call 40002b24 <rtems_uint32_from_little_endian>
40002c1c: 90 06 20 08 add %i0, 8, %o0
40002c20: ba 10 00 08 mov %o0, %i5
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
40002c24: 7f ff ff c0 call 40002b24 <rtems_uint32_from_little_endian>
40002c28: 90 06 20 0c add %i0, 0xc, %o0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
40002c2c: f8 0e 20 04 ldub [ %i0 + 4 ], %i4
40002c30: 80 a7 20 00 cmp %i4, 0
40002c34: 02 80 00 21 be 40002cb8 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
40002c38: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
40002c3c: c4 06 40 00 ld [ %i1 ], %g2
40002c40: 80 a0 80 1a cmp %g2, %i2
40002c44: 02 80 00 1d be 40002cb8 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
40002c48: 82 10 20 05 mov 5, %g1
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
40002c4c: b4 02 00 1d add %o0, %i5, %i2
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
40002c50: 80 a7 40 1a cmp %i5, %i2
40002c54: 1a 80 00 19 bcc 40002cb8 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
40002c58: 82 10 20 1b mov 0x1b, %g1
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
40002c5c: 80 a7 20 05 cmp %i4, 5
40002c60: 32 80 00 07 bne,a 40002c7c <rtems_bdpart_read_mbr_partition+0x68>
40002c64: 90 00 a0 30 add %g2, 0x30, %o0
if (ep_begin != NULL) {
40002c68: 80 a6 e0 00 cmp %i3, 0
40002c6c: 32 80 00 12 bne,a 40002cb4 <rtems_bdpart_read_mbr_partition+0xa0><== ALWAYS TAKEN
40002c70: fa 26 c0 00 st %i5, [ %i3 ]
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
40002c74: 10 80 00 11 b 40002cb8 <rtems_bdpart_read_mbr_partition+0xa4><== NOT EXECUTED
40002c78: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
40002c7c: 92 10 20 00 clr %o1
40002c80: 94 10 20 30 mov 0x30, %o2
40002c84: 40 00 47 94 call 40014ad4 <memset>
40002c88: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
40002c8c: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
40002c90: 90 10 00 1c mov %i4, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
40002c94: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
40002c98: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
40002c9c: 7f ff ff d6 call 40002bf4 <rtems_bdpart_to_partition_type>
40002ca0: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
40002ca4: c2 06 40 00 ld [ %i1 ], %g1
40002ca8: c4 0e 00 00 ldub [ %i0 ], %g2
40002cac: c0 20 60 28 clr [ %g1 + 0x28 ]
40002cb0: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
40002cb4: 82 10 20 00 clr %g1
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
}
40002cb8: 81 c7 e0 08 ret
40002cbc: 91 e8 00 01 restore %g0, %g1, %o0
40002b50 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
40002b50: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
40002b54: d0 06 80 00 ld [ %i2 ], %o0
40002b58: 80 a2 20 00 cmp %o0, 0
40002b5c: 12 80 00 0b bne 40002b88 <rtems_bdpart_read_record+0x38>
40002b60: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
40002b64: 90 10 00 18 mov %i0, %o0
40002b68: 92 10 00 19 mov %i1, %o1
40002b6c: 40 00 31 a9 call 4000f210 <rtems_bdbuf_read>
40002b70: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
40002b74: 80 a2 20 00 cmp %o0, 0
40002b78: 22 80 00 0b be,a 40002ba4 <rtems_bdpart_read_record+0x54><== ALWAYS TAKEN
40002b7c: c2 06 80 00 ld [ %i2 ], %g1
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40002b80: 81 c7 e0 08 ret <== NOT EXECUTED
40002b84: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
sc = rtems_bdbuf_release( *block);
40002b88: 40 00 32 1e call 4000f400 <rtems_bdbuf_release>
40002b8c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40002b90: 80 a2 20 00 cmp %o0, 0
40002b94: 22 bf ff f5 be,a 40002b68 <rtems_bdpart_read_record+0x18><== ALWAYS TAKEN
40002b98: 90 10 00 18 mov %i0, %o0
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40002b9c: 81 c7 e0 08 ret <== NOT EXECUTED
40002ba0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
40002ba4: 80 a0 60 00 cmp %g1, 0
40002ba8: 22 80 00 10 be,a 40002be8 <rtems_bdpart_read_record+0x98><== NEVER TAKEN
40002bac: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
40002bb0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
== RTEMS_BDPART_MBR_SIGNATURE_0
&& data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]
40002bb4: c6 08 a1 fe ldub [ %g2 + 0x1fe ], %g3
40002bb8: 80 a0 e0 55 cmp %g3, 0x55
40002bbc: 12 80 00 06 bne 40002bd4 <rtems_bdpart_read_record+0x84> <== NEVER TAKEN
40002bc0: 82 10 20 00 clr %g1
40002bc4: c2 08 a1 ff ldub [ %g2 + 0x1ff ], %g1
40002bc8: 82 18 60 aa xor %g1, 0xaa, %g1
40002bcc: 80 a0 00 01 cmp %g0, %g1
40002bd0: 82 60 3f ff subx %g0, -1, %g1
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
40002bd4: 80 a0 60 00 cmp %g1, 0
40002bd8: 22 80 00 04 be,a 40002be8 <rtems_bdpart_read_record+0x98><== NEVER TAKEN
40002bdc: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40002be0: 81 c7 e0 08 ret
40002be4: 91 e8 00 08 restore %g0, %o0, %o0
40002be8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
40002bec: 81 c7 e0 08 ret <== NOT EXECUTED
40002bf0: 81 e8 00 00 restore <== NOT EXECUTED
40003014 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
40003014: 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);
40003018: 90 10 00 18 mov %i0, %o0
4000301c: 40 00 48 82 call 40015224 <strlen>
40003020: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
40003024: 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
)
{
40003028: 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);
4000302c: a0 10 00 08 mov %o0, %l0
size_t i = 0;
int fd = -1;
40003030: 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);
40003034: 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;
40003038: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
4000303c: 92 07 bf f8 add %fp, -8, %o1
40003040: 94 07 bf fc add %fp, -4, %o2
40003044: 7f ff ff 2b call 40002cf0 <rtems_bdpart_get_disk_data>
40003048: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
4000304c: b0 92 20 00 orcc %o0, 0, %i0
40003050: 12 80 00 31 bne 40003114 <rtems_bdpart_register+0x100> <== NEVER TAKEN
40003054: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
40003058: 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;
4000305c: e2 00 40 00 ld [ %g1 ], %l1
40003060: 40 00 07 d4 call 40004fb0 <close>
40003064: f6 00 60 04 ld [ %g1 + 4 ], %i3
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
40003068: 90 04 20 04 add %l0, 4, %o0
4000306c: 40 00 09 83 call 40005678 <malloc>
40003070: b0 10 20 1a mov 0x1a, %i0
if (logical_disk_name == NULL) {
40003074: 80 a2 20 00 cmp %o0, 0
40003078: 02 80 00 27 be 40003114 <rtems_bdpart_register+0x100> <== NEVER TAKEN
4000307c: b8 10 00 08 mov %o0, %i4
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
40003080: 92 10 00 1d mov %i5, %o1
40003084: 94 10 00 10 mov %l0, %o2
40003088: 40 00 48 ef call 40015444 <strncpy>
4000308c: 25 10 00 90 sethi %hi(0x40024000), %l2
logical_disk_marker = logical_disk_name + disk_name_size;
40003090: a0 07 00 10 add %i4, %l0, %l0
#include <string.h>
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_register(
40003094: b4 06 80 1b add %i2, %i3, %i2
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
40003098: ba 10 00 1b mov %i3, %i5
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
4000309c: 10 80 00 16 b 400030f4 <rtems_bdpart_register+0xe0>
400030a0: a4 14 a3 60 or %l2, 0x360, %l2
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400030a4: 90 10 00 10 mov %l0, %o0
400030a8: 92 10 20 04 mov 4, %o1
400030ac: 94 10 00 12 mov %l2, %o2
400030b0: 40 00 47 4c call 40014de0 <snprintf>
400030b4: 96 27 40 1b sub %i5, %i3, %o3
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
400030b8: 80 a2 20 03 cmp %o0, 3
400030bc: 14 80 00 13 bg 40003108 <rtems_bdpart_register+0xf4> <== NEVER TAKEN
400030c0: 90 10 00 11 mov %l1, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
400030c4: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
400030c8: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
400030cc: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
400030d0: 92 10 00 1d mov %i5, %o1
400030d4: 94 10 00 11 mov %l1, %o2
400030d8: 96 10 00 1b mov %i3, %o3
400030dc: 9a 23 40 0c sub %o5, %o4, %o5
400030e0: 40 00 03 1e call 40003d58 <rtems_disk_create_log>
400030e4: b2 06 60 30 add %i1, 0x30, %i1
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
400030e8: 80 a2 20 00 cmp %o0, 0
400030ec: 12 80 00 08 bne 4000310c <rtems_bdpart_register+0xf8> <== NEVER TAKEN
400030f0: b0 10 00 08 mov %o0, %i0
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
400030f4: 80 a7 40 1a cmp %i5, %i2
400030f8: 32 bf ff eb bne,a 400030a4 <rtems_bdpart_register+0x90>
400030fc: ba 07 60 01 inc %i5
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40003100: 10 80 00 03 b 4000310c <rtems_bdpart_register+0xf8>
40003104: b0 10 20 00 clr %i0
40003108: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
4000310c: 40 00 07 ca call 40005034 <free>
40003110: 90 10 00 1c mov %i4, %o0
return esc;
}
40003114: 81 c7 e0 08 ret
40003118: 81 e8 00 00 restore
4000311c <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
4000311c: 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;
40003120: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
40003124: 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;
40003128: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
4000312c: 92 07 bc ec add %fp, -788, %o1
40003130: 94 07 bd 00 add %fp, -768, %o2
40003134: 7f ff ff 18 call 40002d94 <rtems_bdpart_read>
40003138: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
4000313c: 80 a2 20 00 cmp %o0, 0
40003140: 12 80 00 05 bne 40003154 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
40003144: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
40003148: 90 10 00 18 mov %i0, %o0
4000314c: 7f ff ff b2 call 40003014 <rtems_bdpart_register>
40003150: 92 07 bd 00 add %fp, -768, %o1
}
40003154: 81 c7 e0 08 ret
40003158: 91 e8 00 08 restore %g0, %o0, %o0
400209c0 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
400209c0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
400209c4: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
400209c8: 40 00 76 2d call 4003e27c <strrchr> <== NOT EXECUTED
400209cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400209d0: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
400209d4: 40 00 72 07 call 4003d1f0 <strlen> <== NOT EXECUTED
400209d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400209dc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
400209e0: 40 00 72 04 call 4003d1f0 <strlen> <== NOT EXECUTED
400209e4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
400209e8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400209ec: 02 80 00 07 be 40020a08 <rtems_bdpart_unmount+0x48> <== NOT EXECUTED
400209f0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
disk_file_name += 1;
400209f4: b2 06 60 01 inc %i1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
400209f8: 40 00 71 fe call 4003d1f0 <strlen> <== NOT EXECUTED
400209fc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40020a00: 10 80 00 03 b 40020a0c <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
40020a04: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
} else {
disk_file_name = disk_name;
40020a08: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
40020a0c: a2 04 00 1c add %l0, %i4, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
40020a10: 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);
40020a14: 7f ff 89 09 call 40002e38 <malloc> <== NOT EXECUTED
40020a18: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
40020a1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020a20: 02 80 00 28 be 40020ac0 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
40020a24: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
40020a28: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40020a2c: 40 00 72 ad call 4003d4e0 <strncpy> <== NOT EXECUTED
40020a30: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
40020a34: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40020a38: 90 07 20 01 add %i4, 1, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
40020a3c: c2 2f 40 1c stb %g1, [ %i5 + %i4 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40020a40: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
40020a44: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40020a48: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40020a4c: a2 04 60 01 inc %l1 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40020a50: 40 00 72 a4 call 4003d4e0 <strncpy> <== NOT EXECUTED
40020a54: 37 10 01 6c sethi %hi(0x4005b000), %i3 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40020a58: a2 07 40 11 add %i5, %l1, %l1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40020a5c: b8 10 20 00 clr %i4 <== NOT EXECUTED
40020a60: 10 80 00 14 b 40020ab0 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
40020a64: b6 16 e3 a8 or %i3, 0x3a8, %i3 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40020a68: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40020a6c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020a70: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40020a74: 40 00 6e 41 call 4003c378 <snprintf> <== NOT EXECUTED
40020a78: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40020a7c: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
40020a80: 14 80 00 10 bg 40020ac0 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
40020a84: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
40020a88: 40 00 10 5d call 40024bfc <unmount> <== NOT EXECUTED
40020a8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv == 0) {
40020a90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020a94: 12 80 00 08 bne 40020ab4 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
40020a98: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
40020a9c: 40 00 0e b0 call 4002455c <rmdir> <== NOT EXECUTED
40020aa0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
40020aa4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020aa8: 12 80 00 06 bne 40020ac0 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
40020aac: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40020ab0: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
40020ab4: 32 bf ff ed bne,a 40020a68 <rtems_bdpart_unmount+0xa8> <== NOT EXECUTED
40020ab8: b8 07 20 01 inc %i4 <== NOT EXECUTED
40020abc: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
40020ac0: 7f ff 88 0a call 40002ae8 <free> <== NOT EXECUTED
40020ac4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
40020ac8: 81 c7 e0 08 ret <== NOT EXECUTED
40020acc: 81 e8 00 00 restore <== NOT EXECUTED
4000315c <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
4000315c: 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;
40003160: 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);
40003164: 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;
40003168: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
4000316c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
40003170: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40003174: 92 07 bf f8 add %fp, -8, %o1
40003178: 94 07 bf fc add %fp, -4, %o2
4000317c: 7f ff fe dd call 40002cf0 <rtems_bdpart_get_disk_data>
40003180: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003184: b0 92 20 00 orcc %o0, 0, %i0
40003188: 12 80 00 10 bne 400031c8 <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
4000318c: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
40003190: d0 07 bf f8 ld [ %fp + -8 ], %o0
40003194: 40 00 07 87 call 40004fb0 <close>
40003198: 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) {
4000319c: 10 80 00 08 b 400031bc <rtems_bdpart_unregister+0x60>
400031a0: b4 06 80 1d add %i2, %i5, %i2
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
400031a4: 90 10 00 1c mov %i4, %o0
400031a8: 40 00 02 84 call 40003bb8 <rtems_disk_delete>
400031ac: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
400031b0: 80 a2 20 00 cmp %o0, 0
400031b4: 32 80 00 05 bne,a 400031c8 <rtems_bdpart_unregister+0x6c><== NEVER TAKEN
400031b8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
400031bc: 80 a7 40 1a cmp %i5, %i2
400031c0: 12 bf ff f9 bne 400031a4 <rtems_bdpart_unregister+0x48>
400031c4: ba 07 60 01 inc %i5
400031c8: 81 c7 e0 08 ret
400031cc: 81 e8 00 00 restore
400032b4 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
400032b4: 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;
400032b8: 80 a6 60 00 cmp %i1, 0
400032bc: 02 80 00 08 be 400032dc <rtems_bdpart_write+0x28> <== NEVER TAKEN
400032c0: 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
400032c4: c4 06 40 00 ld [ %i1 ], %g2
400032c8: 80 a0 a0 00 cmp %g2, 0
400032cc: 12 80 00 05 bne 400032e0 <rtems_bdpart_write+0x2c> <== NEVER TAKEN
400032d0: 82 10 20 00 clr %g1
&& format->mbr.dos_compatibility;
400032d4: 10 80 00 03 b 400032e0 <rtems_bdpart_write+0x2c>
400032d8: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
400032dc: 82 10 20 00 clr %g1 <== NOT EXECUTED
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
400032e0: a2 08 60 01 and %g1, 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
400032e4: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
400032e8: ba 0c 60 ff and %l1, 0xff, %i5
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
400032ec: 82 10 3f ff mov -1, %g1
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
400032f0: 80 a0 00 1d cmp %g0, %i5
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
400032f4: c0 27 bf f4 clr [ %fp + -12 ]
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
400032f8: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
400032fc: c0 27 bf fc clr [ %fp + -4 ]
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
40003300: b8 40 3f ff addx %g0, -1, %i4
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
40003304: b0 10 20 00 clr %i0
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
40003308: b8 0f 3f c2 and %i4, -62, %i4
uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
4000330c: 80 a6 e0 00 cmp %i3, 0
40003310: 02 80 00 cd be 40003644 <rtems_bdpart_write+0x390> <== NEVER TAKEN
40003314: b8 07 20 3f add %i4, 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
40003318: 80 a6 a0 00 cmp %i2, 0
4000331c: 02 80 00 ca be 40003644 <rtems_bdpart_write+0x390> <== NEVER TAKEN
40003320: b0 10 20 09 mov 9, %i0
40003324: 80 a6 60 00 cmp %i1, 0
40003328: 02 80 00 c7 be 40003644 <rtems_bdpart_write+0x390> <== NEVER TAKEN
4000332c: 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);
40003330: 94 07 bf fc add %fp, -4, %o2
40003334: 7f ff fe 6f call 40002cf0 <rtems_bdpart_get_disk_data>
40003338: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
4000333c: b0 92 20 00 orcc %o0, 0, %i0
40003340: 12 80 00 c1 bne 40003644 <rtems_bdpart_write+0x390> <== NEVER TAKEN
40003344: 80 a7 60 00 cmp %i5, 0
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
40003348: 02 80 00 09 be 4000336c <rtems_bdpart_write+0xb8> <== NEVER TAKEN
4000334c: c8 07 bf f4 ld [ %fp + -12 ], %g4
disk_end -= (disk_end % record_space);
40003350: fa 07 bf f4 ld [ %fp + -12 ], %i5
40003354: 92 10 00 1c mov %i4, %o1
40003358: 40 00 76 30 call 40020c18 <.urem>
4000335c: 90 10 00 1d mov %i5, %o0
40003360: 90 27 40 08 sub %i5, %o0, %o0
40003364: d0 27 bf f4 st %o0, [ %fp + -12 ]
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
40003368: c8 07 bf f4 ld [ %fp + -12 ], %g4
4000336c: a0 10 00 1a mov %i2, %l0
40003370: 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) {
40003374: 84 10 20 00 clr %g2
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
40003378: c6 00 40 00 ld [ %g1 ], %g3
4000337c: 80 a0 c0 04 cmp %g3, %g4
40003380: 3a 80 00 a5 bcc,a 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
40003384: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
40003388: fa 00 60 04 ld [ %g1 + 4 ], %i5
4000338c: 80 a7 40 04 cmp %i5, %g4
40003390: 18 80 00 9e bgu 40003608 <rtems_bdpart_write+0x354> <== NEVER TAKEN
40003394: 80 a0 c0 1d cmp %g3, %i5
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
40003398: 1a 80 00 9c bcc 40003608 <rtems_bdpart_write+0x354> <== NEVER TAKEN
4000339c: 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) {
400033a0: 02 80 00 06 be 400033b8 <rtems_bdpart_write+0x104>
400033a4: 84 00 a0 01 inc %g2
400033a8: fa 00 7f d4 ld [ %g1 + -44 ], %i5
400033ac: 80 a7 40 03 cmp %i5, %g3
400033b0: 38 80 00 99 bgu,a 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
400033b4: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
400033b8: 80 a0 80 1b cmp %g2, %i3
400033bc: 12 bf ff ef bne 40003378 <rtems_bdpart_write+0xc4>
400033c0: 82 00 60 30 add %g1, 0x30, %g1
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
400033c4: c2 06 40 00 ld [ %i1 ], %g1
400033c8: 80 a0 60 00 cmp %g1, 0
400033cc: 12 80 00 92 bne 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
400033d0: 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;
400033d4: 80 a6 e0 04 cmp %i3, 4
400033d8: 08 80 00 03 bleu 400033e4 <rtems_bdpart_write+0x130> <== NEVER TAKEN
400033dc: ba 10 00 1b mov %i3, %i5
400033e0: ba 10 20 03 mov 3, %i5
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
400033e4: 80 8c 60 ff btst 0xff, %l1
400033e8: 32 80 00 09 bne,a 4000340c <rtems_bdpart_write+0x158> <== ALWAYS TAKEN
400033ec: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400033f0: 83 2f 60 04 sll %i5, 4, %g1 <== NOT EXECUTED
400033f4: a5 2f 60 06 sll %i5, 6, %l2
400033f8: 84 10 00 1d mov %i5, %g2
400033fc: a4 24 80 01 sub %l2, %g1, %l2
40003400: 82 10 20 00 clr %g1
40003404: 10 80 00 0e b 4000343c <rtems_bdpart_write+0x188>
40003408: a2 06 80 12 add %i2, %l2, %l1
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
4000340c: 80 a0 60 3f cmp %g1, 0x3f
40003410: 12 80 00 81 bne 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
40003414: b0 10 20 0a mov 0xa, %i0
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40003418: 10 bf ff f7 b 400033f4 <rtems_bdpart_write+0x140>
4000341c: 83 2f 60 04 sll %i5, 4, %g1
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
40003420: c8 04 40 01 ld [ %l1 + %g1 ], %g4
40003424: c6 00 ff d4 ld [ %g3 + -44 ], %g3
40003428: 86 21 00 03 sub %g4, %g3, %g3
4000342c: 80 a0 c0 1c cmp %g3, %i4
40003430: 0a 80 00 76 bcs 40003608 <rtems_bdpart_write+0x354> <== NEVER TAKEN
40003434: 82 00 60 30 add %g1, 0x30, %g1
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
40003438: 84 00 a0 01 inc %g2
4000343c: 80 a0 80 1b cmp %g2, %i3
40003440: 0a bf ff f8 bcs 40003420 <rtems_bdpart_write+0x16c>
40003444: 86 04 40 01 add %l1, %g1, %g3
40003448: b0 10 00 1a mov %i2, %i0
4000344c: a6 10 20 00 clr %l3
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
40003450: 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)) {
40003454: 90 06 20 08 add %i0, 8, %o0
40003458: 7f ff fe 1a call 40002cc0 <rtems_bdpart_to_mbr_partition_type>
4000345c: 92 07 bf ef add %fp, -17, %o1
40003460: 80 8a 20 ff btst 0xff, %o0
40003464: 22 80 00 6c be,a 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
40003468: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
4000346c: b0 06 20 30 add %i0, 0x30, %i0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
40003470: c2 06 3f f8 ld [ %i0 + -8 ], %g1
40003474: 80 a0 60 00 cmp %g1, 0
40003478: 32 80 00 67 bne,a 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
4000347c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
40003480: c2 06 3f fc ld [ %i0 + -4 ], %g1
40003484: 80 a0 60 ff cmp %g1, 0xff
40003488: 18 80 00 07 bgu 400034a4 <rtems_bdpart_write+0x1f0> <== NEVER TAKEN
4000348c: a6 04 e0 01 inc %l3
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
40003490: 80 a4 c0 1b cmp %l3, %i3
40003494: 32 bf ff f0 bne,a 40003454 <rtems_bdpart_write+0x1a0>
40003498: c0 2f bf ef clrb [ %fp + -17 ]
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
4000349c: 10 80 00 04 b 400034ac <rtems_bdpart_write+0x1f8>
400034a0: d0 07 bf fc ld [ %fp + -4 ], %o0
400034a4: 10 80 00 5c b 40003614 <rtems_bdpart_write+0x360> <== NOT EXECUTED
400034a8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
400034ac: 92 10 20 00 clr %o1
400034b0: 7f ff ff 48 call 400031d0 <rtems_bdpart_new_record>
400034b4: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
400034b8: b0 92 20 00 orcc %o0, 0, %i0
400034bc: 12 80 00 57 bne 40003618 <rtems_bdpart_write+0x364> <== NEVER TAKEN
400034c0: 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
400034c4: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
400034c8: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
400034cc: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
400034d0: 82 10 20 00 clr %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400034d4: 86 01 00 01 add %g4, %g1, %g3
data [i] = (uint8_t) value;
400034d8: c4 28 e1 b8 stb %g2, [ %g3 + 0x1b8 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
400034dc: 82 00 60 01 inc %g1
400034e0: 80 a0 60 04 cmp %g1, 4
400034e4: 12 bf ff fc bne 400034d4 <rtems_bdpart_write+0x220>
400034e8: 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;
400034ec: c2 07 bf f0 ld [ %fp + -16 ], %g1
for (i = 0; i < ppc; ++i) {
400034f0: b2 10 20 00 clr %i1
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
400034f4: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
400034f8: a6 04 e1 be add %l3, 0x1be, %l3
for (i = 0; i < ppc; ++i) {
400034fc: 10 80 00 0b b 40003528 <rtems_bdpart_write+0x274>
40003500: b0 10 00 13 mov %l3, %i0
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
40003504: d4 04 20 04 ld [ %l0 + 4 ], %o2
40003508: d6 0c 20 08 ldub [ %l0 + 8 ], %o3
4000350c: d8 0c 20 2f ldub [ %l0 + 0x2f ], %o4
40003510: 90 10 00 18 mov %i0, %o0
40003514: 94 22 80 09 sub %o2, %o1, %o2
40003518: 7f ff ff 56 call 40003270 <rtems_bdpart_write_mbr_partition>
4000351c: b0 06 20 10 add %i0, 0x10, %i0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
40003520: b2 06 60 01 inc %i1
40003524: a0 04 20 30 add %l0, 0x30, %l0
40003528: 80 a6 40 1d cmp %i1, %i5
4000352c: 32 bf ff f6 bne,a 40003504 <rtems_bdpart_write+0x250>
40003530: d2 04 00 00 ld [ %l0 ], %o1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40003534: 91 2f 60 04 sll %i5, 4, %o0
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40003538: b0 10 20 00 clr %i0
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
4000353c: 80 a7 40 1b cmp %i5, %i3
40003540: 02 80 00 35 be 40003614 <rtems_bdpart_write+0x360> <== NEVER TAKEN
40003544: 90 04 c0 08 add %l3, %o0, %o0
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40003548: e0 06 80 12 ld [ %i2 + %l2 ], %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
4000354c: d4 07 bf f4 ld [ %fp + -12 ], %o2
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40003550: a0 24 00 1c sub %l0, %i4, %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
40003554: 96 10 20 05 mov 5, %o3
40003558: 92 10 00 10 mov %l0, %o1
4000355c: 94 22 80 10 sub %o2, %l0, %o2
40003560: 98 10 20 00 clr %o4
40003564: 7f ff ff 43 call 40003270 <rtems_bdpart_write_mbr_partition>
40003568: b4 10 00 11 mov %l1, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
4000356c: 10 80 00 22 b 400035f4 <rtems_bdpart_write+0x340>
40003570: b2 10 00 1d mov %i5, %i1
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
40003574: 28 80 00 0e bleu,a 400035ac <rtems_bdpart_write+0x2f8>
40003578: d2 06 80 00 ld [ %i2 ], %o1
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
4000357c: 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;
40003580: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
40003584: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
40003588: d4 07 bf f4 ld [ %fp + -12 ], %o2
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
4000358c: 82 20 40 1c sub %g1, %i4, %g1
rtems_bdpart_write_mbr_partition(
40003590: 90 02 21 ce add %o0, 0x1ce, %o0
40003594: 92 20 40 10 sub %g1, %l0, %o1
40003598: 94 22 80 01 sub %o2, %g1, %o2
4000359c: 96 10 20 05 mov 5, %o3
400035a0: 7f ff ff 34 call 40003270 <rtems_bdpart_write_mbr_partition>
400035a4: 98 10 20 00 clr %o4
0
);
}
/* New EBR */
ebr = p->begin - record_space;
400035a8: d2 06 80 00 ld [ %i2 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
400035ac: d0 07 bf fc ld [ %fp + -4 ], %o0
400035b0: 92 22 40 1c sub %o1, %i4, %o1
400035b4: 7f ff ff 07 call 400031d0 <rtems_bdpart_new_record>
400035b8: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
400035bc: 80 a2 20 00 cmp %o0, 0
400035c0: 12 80 00 14 bne 40003610 <rtems_bdpart_write+0x35c> <== NEVER TAKEN
400035c4: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
400035c8: d4 06 a0 04 ld [ %i2 + 4 ], %o2
400035cc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400035d0: d6 0e a0 08 ldub [ %i2 + 8 ], %o3
400035d4: c2 06 80 00 ld [ %i2 ], %g1
400035d8: d8 0e a0 2f ldub [ %i2 + 0x2f ], %o4
400035dc: 90 02 21 be add %o0, 0x1be, %o0
400035e0: 92 10 00 1c mov %i4, %o1
400035e4: 94 22 80 01 sub %o2, %g1, %o2
400035e8: 7f ff ff 22 call 40003270 <rtems_bdpart_write_mbr_partition>
400035ec: b2 06 60 01 inc %i1
400035f0: b4 06 a0 30 add %i2, 0x30, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
400035f4: 80 a6 40 1b cmp %i1, %i3
400035f8: 0a bf ff df bcs 40003574 <rtems_bdpart_write+0x2c0>
400035fc: 80 a6 40 1d cmp %i1, %i5
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40003600: 10 80 00 05 b 40003614 <rtems_bdpart_write+0x360>
40003604: b0 10 20 00 clr %i0
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
esc = RTEMS_INVALID_NUMBER;
40003608: 10 80 00 03 b 40003614 <rtems_bdpart_write+0x360> <== NOT EXECUTED
4000360c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
40003610: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
40003614: d0 07 bf f8 ld [ %fp + -8 ], %o0
40003618: 80 a2 20 00 cmp %o0, 0
4000361c: 26 80 00 05 bl,a 40003630 <rtems_bdpart_write+0x37c> <== NEVER TAKEN
40003620: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
40003624: 40 00 06 63 call 40004fb0 <close>
40003628: 01 00 00 00 nop
}
if (block != NULL) {
4000362c: d0 07 bf f0 ld [ %fp + -16 ], %o0
40003630: 80 a2 20 00 cmp %o0, 0
40003634: 02 80 00 06 be 4000364c <rtems_bdpart_write+0x398> <== NEVER TAKEN
40003638: 01 00 00 00 nop
rtems_bdbuf_sync( block);
4000363c: 40 00 2f c3 call 4000f548 <rtems_bdbuf_sync>
40003640: 01 00 00 00 nop
40003644: 81 c7 e0 08 ret
40003648: 81 e8 00 00 restore
}
return esc;
}
4000364c: 81 c7 e0 08 ret <== NOT EXECUTED
40003650: 81 e8 00 00 restore <== NOT EXECUTED
400033d8 <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
400033d8: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
400033dc: 92 10 20 02 mov 2, %o1
400033e0: 90 10 00 19 mov %i1, %o0
400033e4: 40 00 09 2e call 4000589c <open>
400033e8: ba 10 20 04 mov 4, %i5
if (fd >= 0) {
400033ec: 80 a2 20 00 cmp %o0, 0
400033f0: 06 80 00 33 bl 400034bc <rtems_blkdev_create_partition+0xe4>
400033f4: b2 10 00 08 mov %o0, %i1
int rv;
struct stat st;
rv = fstat(fd, &st);
400033f8: 40 00 05 bb call 40004ae4 <fstat>
400033fc: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
40003400: 80 a2 20 00 cmp %o0, 0
40003404: 12 80 00 2c bne 400034b4 <rtems_blkdev_create_partition+0xdc><== NEVER TAKEN
40003408: ba 10 20 15 mov 0x15, %i5
4000340c: e0 07 bf c4 ld [ %fp + -60 ], %l0
40003410: 03 00 00 3c sethi %hi(0xf000), %g1
40003414: a0 0c 00 01 and %l0, %g1, %l0
40003418: 03 00 00 18 sethi %hi(0x6000), %g1
4000341c: 80 a4 00 01 cmp %l0, %g1
40003420: 12 80 00 25 bne 400034b4 <rtems_blkdev_create_partition+0xdc>
40003424: 90 10 00 19 mov %i1, %o0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
40003428: 13 10 01 10 sethi %hi(0x40044000), %o1
4000342c: 94 07 bf b4 add %fp, -76, %o2
40003430: 92 12 62 09 or %o1, 0x209, %o1
40003434: 40 00 05 ff call 40004c30 <ioctl>
40003438: ba 10 20 18 mov 0x18, %i5
rtems_disk_device *phys_dd;
rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
if (rv == 0) {
4000343c: 80 a2 20 00 cmp %o0, 0
40003440: 12 80 00 1d bne 400034b4 <rtems_blkdev_create_partition+0xdc>
40003444: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
40003448: 40 00 07 0e call 40005080 <malloc>
4000344c: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
40003450: b8 92 20 00 orcc %o0, 0, %i4
40003454: 02 80 00 17 be 400034b0 <rtems_blkdev_create_partition+0xd8>
40003458: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
4000345c: 94 10 00 1a mov %i2, %o2
40003460: 40 00 00 90 call 400036a0 <rtems_disk_init_log>
40003464: 96 10 00 1b mov %i3, %o3
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
40003468: ba 92 20 00 orcc %o0, 0, %i5
4000346c: 12 80 00 0e bne 400034a4 <rtems_blkdev_create_partition+0xcc>
40003470: 90 10 00 18 mov %i0, %o0
ctx->fd = fd;
40003474: f2 27 20 78 st %i1, [ %i4 + 0x78 ]
rv = IMFS_make_generic_node(
40003478: 92 14 21 ff or %l0, 0x1ff, %o1
4000347c: 15 10 00 64 sethi %hi(0x40019000), %o2
40003480: 96 10 00 1c mov %i4, %o3
40003484: 40 00 03 90 call 400042c4 <IMFS_make_generic_node>
40003488: 94 12 a0 40 or %o2, 0x40, %o2
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
4000348c: 80 a2 20 00 cmp %o0, 0
40003490: 02 80 00 0b be 400034bc <rtems_blkdev_create_partition+0xe4>
40003494: 90 10 00 1c mov %i4, %o0
free(ctx);
40003498: 40 00 05 69 call 40004a3c <free>
4000349c: ba 10 20 0d mov 0xd, %i5
400034a0: 30 80 00 05 b,a 400034b4 <rtems_blkdev_create_partition+0xdc>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
400034a4: 40 00 05 66 call 40004a3c <free>
400034a8: 90 10 00 1c mov %i4, %o0
400034ac: 30 80 00 02 b,a 400034b4 <rtems_blkdev_create_partition+0xdc>
400034b0: ba 10 20 1a mov 0x1a, %i5
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
400034b4: 40 00 05 41 call 400049b8 <close>
400034b8: 90 10 00 19 mov %i1, %o0
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
400034bc: 81 c7 e0 08 ret
400034c0: 91 e8 00 1d restore %g0, %i5, %o0
4000e920 <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)
{
4000e920: 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;
4000e924: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
4000e928: 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;
4000e92c: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
4000e930: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000e934: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000e938: 80 a2 40 01 cmp %o1, %g1
4000e93c: 02 80 00 07 be 4000e958 <rtems_blkdev_generic_ioctl+0x38> <== NEVER TAKEN
4000e940: 82 10 3f ff mov -1, %g1
{
args->ioctl_return = dd->ioctl(dd,
4000e944: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000e948: 9f c0 40 00 call %g1
4000e94c: d4 06 a0 08 ld [ %i2 + 8 ], %o2
4000e950: 10 80 00 03 b 4000e95c <rtems_blkdev_generic_ioctl+0x3c>
4000e954: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
4000e958: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
4000e95c: 81 c7 e0 08 ret
4000e960: 91 e8 20 00 restore %g0, 0, %o0
4000e700 <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)
{
4000e700: 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;
4000e704: 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);
4000e708: 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;
4000e70c: 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);
4000e710: 90 10 00 1c mov %i4, %o0
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
4000e714: e0 04 a0 24 ld [ %l2 + 0x24 ], %l0
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000e718: 94 10 20 00 clr %o2
4000e71c: 96 10 00 10 mov %l0, %o3
4000e720: 40 00 20 e6 call 40016ab8 <__divdi3>
4000e724: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000e728: 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);
4000e72c: a6 10 00 09 mov %o1, %l3
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000e730: 94 10 20 00 clr %o2
4000e734: 92 10 00 1d mov %i5, %o1
4000e738: 96 10 00 10 mov %l0, %o3
4000e73c: 40 00 21 ca call 40016e64 <__moddi3>
4000e740: f2 06 a0 10 ld [ %i2 + 0x10 ], %i1
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
4000e744: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000e748: a2 10 00 09 mov %o1, %l1
args->bytes_moved = 0;
4000e74c: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
4000e750: 10 80 00 1c b 4000e7c0 <rtems_blkdev_generic_read+0xc0>
4000e754: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
4000e758: 90 10 00 12 mov %l2, %o0
4000e75c: 7f ff fd a6 call 4000ddf4 <rtems_bdbuf_read>
4000e760: 94 07 bf fc add %fp, -4, %o2
if (rc != RTEMS_SUCCESSFUL)
4000e764: 80 a2 20 00 cmp %o0, 0
4000e768: 12 80 00 1a bne 4000e7d0 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
4000e76c: ba 24 00 11 sub %l0, %l1, %i5
4000e770: 80 a7 40 1b cmp %i5, %i3
4000e774: 38 80 00 02 bgu,a 4000e77c <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
4000e778: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4000e77c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000e780: 94 10 00 1d mov %i5, %o2
4000e784: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
4000e788: 90 10 00 19 mov %i1, %o0
4000e78c: 40 00 13 cd call 400136c0 <memcpy>
4000e790: 92 02 40 11 add %o1, %l1, %o1
rc = rtems_bdbuf_release(diskbuf);
4000e794: d0 07 bf fc ld [ %fp + -4 ], %o0
4000e798: 7f ff fe 13 call 4000dfe4 <rtems_bdbuf_release>
4000e79c: b8 07 20 01 inc %i4
args->bytes_moved += copy;
4000e7a0: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
if (rc != RTEMS_SUCCESSFUL)
4000e7a4: 80 a2 20 00 cmp %o0, 0
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
4000e7a8: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
4000e7ac: 12 80 00 09 bne 4000e7d0 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
4000e7b0: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
4000e7b4: b6 26 c0 1d sub %i3, %i5, %i3
buf += copy;
4000e7b8: b2 06 40 1d add %i1, %i5, %i1
blkofs = 0;
4000e7bc: a2 10 20 00 clr %l1
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
4000e7c0: 80 a6 e0 00 cmp %i3, 0
4000e7c4: 12 bf ff e5 bne 4000e758 <rtems_blkdev_generic_read+0x58>
4000e7c8: 92 07 00 13 add %i4, %l3, %o1
4000e7cc: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
4000e7d0: 81 c7 e0 08 ret
4000e7d4: 91 e8 00 08 restore %g0, %o0, %o0
4000e7d8 <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)
{
4000e7d8: 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;
4000e7dc: 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);
4000e7e0: 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;
4000e7e4: 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);
4000e7e8: 90 10 00 1c mov %i4, %o0
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
4000e7ec: f2 04 60 24 ld [ %l1 + 0x24 ], %i1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000e7f0: 94 10 20 00 clr %o2
4000e7f4: 96 10 00 19 mov %i1, %o3
4000e7f8: 40 00 20 b0 call 40016ab8 <__divdi3>
4000e7fc: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000e800: 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);
4000e804: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000e808: 94 10 20 00 clr %o2
4000e80c: 92 10 00 1d mov %i5, %o1
4000e810: 96 10 00 19 mov %i1, %o3
4000e814: 40 00 21 94 call 40016e64 <__moddi3>
4000e818: e0 06 a0 10 ld [ %i2 + 0x10 ], %l0
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
4000e81c: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000e820: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
4000e824: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
4000e828: 10 80 00 26 b 4000e8c0 <rtems_blkdev_generic_write+0xe8>
4000e82c: b0 10 20 00 clr %i0
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
4000e830: 90 10 00 11 mov %l1, %o0
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
4000e834: 80 a6 c0 19 cmp %i3, %i1
4000e838: 0a 80 00 09 bcs 4000e85c <rtems_blkdev_generic_write+0x84><== NEVER TAKEN
4000e83c: 94 07 bf fc add %fp, -4, %o2
4000e840: 80 a7 20 00 cmp %i4, 0
4000e844: 12 80 00 06 bne 4000e85c <rtems_blkdev_generic_write+0x84><== NEVER TAKEN
4000e848: 01 00 00 00 nop
rc = rtems_bdbuf_get(dd, block, &diskbuf);
4000e84c: 7f ff fd 39 call 4000dd30 <rtems_bdbuf_get>
4000e850: 01 00 00 00 nop
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
4000e854: 10 80 00 05 b 4000e868 <rtems_blkdev_generic_write+0x90>
4000e858: 80 a2 20 00 cmp %o0, 0
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
4000e85c: 7f ff fd 66 call 4000ddf4 <rtems_bdbuf_read> <== NOT EXECUTED
4000e860: 01 00 00 00 nop <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
4000e864: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e868: 12 80 00 1a bne 4000e8d0 <rtems_blkdev_generic_write+0xf8><== NEVER TAKEN
4000e86c: ba 26 40 1c sub %i1, %i4, %i5
4000e870: 80 a7 40 1b cmp %i5, %i3
4000e874: 38 80 00 02 bgu,a 4000e87c <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
4000e878: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4000e87c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000e880: 92 10 00 10 mov %l0, %o1
4000e884: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4000e888: 94 10 00 1d mov %i5, %o2
4000e88c: 40 00 13 8d call 400136c0 <memcpy>
4000e890: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
4000e894: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
4000e898: 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;
4000e89c: 82 00 40 1d add %g1, %i5, %g1
4000e8a0: b0 06 20 01 inc %i0
rc = rtems_bdbuf_release_modified(diskbuf);
4000e8a4: 7f ff fe 05 call 4000e0b8 <rtems_bdbuf_release_modified>
4000e8a8: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
4000e8ac: 80 a2 20 00 cmp %o0, 0
4000e8b0: 12 80 00 08 bne 4000e8d0 <rtems_blkdev_generic_write+0xf8><== NEVER TAKEN
4000e8b4: b6 26 c0 1d sub %i3, %i5, %i3
break;
count -= copy;
buf += copy;
4000e8b8: a0 04 00 1d add %l0, %i5, %l0
blkofs = 0;
4000e8bc: b8 10 20 00 clr %i4
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
4000e8c0: 80 a6 e0 00 cmp %i3, 0
4000e8c4: 12 bf ff db bne 4000e830 <rtems_blkdev_generic_write+0x58>
4000e8c8: 92 06 00 12 add %i0, %l2, %o1
4000e8cc: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
4000e8d0: 81 c7 e0 08 ret
4000e8d4: 91 e8 00 08 restore %g0, %o0, %o0
400032c4 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
400032c4: 9d e3 bf a0 save %sp, -96, %sp
static inline void *IMFS_generic_get_context_by_node(
const IMFS_jnode_t *node
)
{
return node->info.generic.context;
400032c8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv = 0;
400032cc: 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);
400032d0: 40 00 2e b2 call 4000ed98 <rtems_bdbuf_syncdev>
400032d4: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
400032d8: 80 a2 20 00 cmp %o0, 0
400032dc: 02 80 00 06 be 400032f4 <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== ALWAYS TAKEN
400032e0: 01 00 00 00 nop
errno = EIO;
400032e4: 40 00 40 40 call 400133e4 <__errno> <== NOT EXECUTED
400032e8: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400032ec: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400032f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
400032f4: 81 c7 e0 08 ret
400032f8: 81 e8 00 00 restore
400032fc <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
400032fc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
40003300: 03 30 06 10 sethi %hi(0xc0184000), %g1
40003304: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40003308: 80 a6 40 01 cmp %i1, %g1
4000330c: 02 80 00 09 be 40003330 <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
40003310: 92 10 00 19 mov %i1, %o1
40003314: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40003318: 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);
4000331c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40003320: 9f c0 40 00 call %g1
40003324: 94 10 00 1a mov %i2, %o2
40003328: 81 c7 e0 08 ret
4000332c: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
40003330: 40 00 40 2d call 400133e4 <__errno> <== NOT EXECUTED
40003334: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003338: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000333c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003340: 81 c7 e0 08 ret <== NOT EXECUTED
40003344: 81 e8 00 00 restore <== NOT EXECUTED
40003148 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40003148: 9d e3 bf 98 save %sp, -104, %sp
4000314c: 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;
40003150: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40003154: e4 00 60 50 ld [ %g1 + 0x50 ], %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40003158: 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);
4000315c: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40003160: 90 10 00 1c mov %i4, %o0
40003164: a3 3e e0 1f sra %i3, 0x1f, %l1
40003168: 96 10 00 1b mov %i3, %o3
4000316c: 40 00 50 34 call 4001723c <__divdi3>
40003170: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
40003174: 94 10 00 11 mov %l1, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40003178: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
4000317c: 90 10 00 1c mov %i4, %o0
40003180: 92 10 00 1d mov %i5, %o1
40003184: 96 10 00 1b mov %i3, %o3
40003188: 40 00 51 18 call 400175e8 <__moddi3>
4000318c: ba 10 00 1a mov %i2, %i5
char *dst = buffer;
while (remaining > 0) {
40003190: 10 80 00 19 b 400031f4 <rtems_blkdev_imfs_read+0xac>
40003194: a2 10 00 09 mov %o1, %l1
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
40003198: 92 10 00 10 mov %l0, %o1
4000319c: 40 00 2d e4 call 4000e92c <rtems_bdbuf_read>
400031a0: 94 07 bf fc add %fp, -4, %o2
if (sc == RTEMS_SUCCESSFUL) {
400031a4: 80 a2 20 00 cmp %o0, 0
400031a8: 12 80 00 1f bne 40003224 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
400031ac: b8 26 c0 11 sub %i3, %l1, %i4
400031b0: 80 a7 00 1d cmp %i4, %i5
400031b4: 34 80 00 02 bg,a 400031bc <rtems_blkdev_imfs_read+0x74>
400031b8: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
400031bc: c2 07 bf fc ld [ %fp + -4 ], %g1
400031c0: 94 10 00 1c mov %i4, %o2
400031c4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
400031c8: 90 10 00 19 mov %i1, %o0
400031cc: 40 00 42 e7 call 40013d68 <memcpy>
400031d0: 92 02 40 11 add %o1, %l1, %o1
sc = rtems_bdbuf_release(bd);
400031d4: 40 00 2e 52 call 4000eb1c <rtems_bdbuf_release>
400031d8: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
400031dc: 80 a2 20 00 cmp %o0, 0
400031e0: 12 80 00 11 bne 40003224 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
400031e4: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
dst += copy;
400031e8: b2 06 40 1c add %i1, %i4, %i1
++block;
400031ec: a0 04 20 01 inc %l0
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
sc = rtems_bdbuf_release(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
400031f0: a2 10 20 00 clr %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
400031f4: 80 a7 60 00 cmp %i5, 0
400031f8: 14 bf ff e8 bg 40003198 <rtems_blkdev_imfs_read+0x50>
400031fc: 90 10 00 12 mov %l2, %o0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
40003200: 80 a7 60 00 cmp %i5, 0
40003204: 12 80 00 08 bne 40003224 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
40003208: 01 00 00 00 nop
iop->offset += count;
4000320c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40003210: 86 80 c0 1a addcc %g3, %i2, %g3
40003214: 84 40 a0 00 addx %g2, 0, %g2
40003218: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
4000321c: 81 c7 e0 08 ret
40003220: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
40003224: 40 00 40 70 call 400133e4 <__errno> <== NOT EXECUTED
40003228: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000322c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40003230: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003234: 81 c7 e0 08 ret <== NOT EXECUTED
40003238: 81 e8 00 00 restore <== NOT EXECUTED
4000301c <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000301c: 9d e3 bf 98 save %sp, -104, %sp
40003020: 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;
40003024: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40003028: e4 00 60 50 ld [ %g1 + 0x50 ], %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
4000302c: 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);
40003030: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40003034: 90 10 00 1c mov %i4, %o0
40003038: a3 3e e0 1f sra %i3, 0x1f, %l1
4000303c: 96 10 00 1b mov %i3, %o3
40003040: 40 00 50 7f call 4001723c <__divdi3>
40003044: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
40003048: 94 10 00 11 mov %l1, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
4000304c: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
40003050: 90 10 00 1c mov %i4, %o0
40003054: 92 10 00 1d mov %i5, %o1
40003058: 96 10 00 1b mov %i3, %o3
4000305c: 40 00 51 63 call 400175e8 <__moddi3>
40003060: ba 10 00 1a mov %i2, %i5
const char *src = buffer;
while (remaining > 0) {
40003064: 10 80 00 27 b 40003100 <rtems_blkdev_imfs_write+0xe4>
40003068: a2 10 00 09 mov %o1, %l1
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
4000306c: 16 80 00 03 bge 40003078 <rtems_blkdev_imfs_write+0x5c>
40003070: 82 10 20 01 mov 1, %g1
40003074: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
40003078: 90 10 00 12 mov %l2, %o0
4000307c: 92 10 00 10 mov %l0, %o1
while (remaining > 0) {
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
40003080: 80 88 60 ff btst 0xff, %g1
40003084: 02 80 00 09 be 400030a8 <rtems_blkdev_imfs_write+0x8c>
40003088: 94 07 bf fc add %fp, -4, %o2
4000308c: 80 a4 60 00 cmp %l1, 0
40003090: 12 80 00 06 bne 400030a8 <rtems_blkdev_imfs_write+0x8c>
40003094: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
40003098: 40 00 2d f4 call 4000e868 <rtems_bdbuf_get>
4000309c: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
400030a0: 10 80 00 05 b 400030b4 <rtems_blkdev_imfs_write+0x98>
400030a4: 80 a2 20 00 cmp %o0, 0
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
sc = rtems_bdbuf_get(dd, block, &bd);
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
400030a8: 40 00 2e 21 call 4000e92c <rtems_bdbuf_read>
400030ac: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
400030b0: 80 a2 20 00 cmp %o0, 0
400030b4: 12 80 00 1f bne 40003130 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
400030b8: b8 26 c0 11 sub %i3, %l1, %i4
400030bc: 80 a7 00 1d cmp %i4, %i5
400030c0: 34 80 00 02 bg,a 400030c8 <rtems_blkdev_imfs_write+0xac>
400030c4: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
400030c8: c2 07 bf fc ld [ %fp + -4 ], %g1
400030cc: 92 10 00 19 mov %i1, %o1
400030d0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400030d4: 94 10 00 1c mov %i4, %o2
400030d8: 40 00 43 24 call 40013d68 <memcpy>
400030dc: 90 02 00 11 add %o0, %l1, %o0
sc = rtems_bdbuf_release_modified(bd);
400030e0: 40 00 2e c4 call 4000ebf0 <rtems_bdbuf_release_modified>
400030e4: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
400030e8: 80 a2 20 00 cmp %o0, 0
400030ec: 12 80 00 11 bne 40003130 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
400030f0: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
src += copy;
400030f4: b2 06 40 1c add %i1, %i4, %i1
++block;
400030f8: a0 04 20 01 inc %l0
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
sc = rtems_bdbuf_release_modified(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
400030fc: a2 10 20 00 clr %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
const char *src = buffer;
while (remaining > 0) {
40003100: 80 a7 60 00 cmp %i5, 0
40003104: 14 bf ff da bg 4000306c <rtems_blkdev_imfs_write+0x50>
40003108: 80 a7 40 1b cmp %i5, %i3
} else {
remaining = -1;
}
}
if (remaining >= 0) {
4000310c: 80 a7 60 00 cmp %i5, 0
40003110: 12 80 00 08 bne 40003130 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
40003114: 01 00 00 00 nop
iop->offset += count;
40003118: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4000311c: 86 80 c0 1a addcc %g3, %i2, %g3
40003120: 84 40 a0 00 addx %g2, 0, %g2
40003124: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
40003128: 81 c7 e0 08 ret
4000312c: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
40003130: 40 00 40 ad call 400133e4 <__errno> <== NOT EXECUTED
40003134: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003138: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000313c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003140: 81 c7 e0 08 ret <== NOT EXECUTED
40003144: 81 e8 00 00 restore <== NOT EXECUTED
4000e5a8 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000e5a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
4000e5ac: 03 10 01 10 sethi %hi(0x40044000), %g1
4000e5b0: 84 10 62 03 or %g1, 0x203, %g2 ! 40044203 <__end+0x293c3>
4000e5b4: 80 a6 40 02 cmp %i1, %g2
4000e5b8: 02 80 00 2f be 4000e674 <rtems_blkdev_ioctl+0xcc>
4000e5bc: 90 10 00 18 mov %i0, %o0
4000e5c0: 80 a6 40 02 cmp %i1, %g2
4000e5c4: 18 80 00 16 bgu 4000e61c <rtems_blkdev_ioctl+0x74>
4000e5c8: 84 10 62 09 or %g1, 0x209, %g2
4000e5cc: 05 08 00 10 sethi %hi(0x20004000), %g2
4000e5d0: 86 10 a2 0a or %g2, 0x20a, %g3 ! 2000420a <RAM_SIZE+0x1fc0420a>
4000e5d4: 80 a6 40 03 cmp %i1, %g3
4000e5d8: 02 80 00 38 be 4000e6b8 <rtems_blkdev_ioctl+0x110>
4000e5dc: 01 00 00 00 nop
4000e5e0: 38 80 00 07 bgu,a 4000e5fc <rtems_blkdev_ioctl+0x54>
4000e5e4: 84 10 a2 0c or %g2, 0x20c, %g2
4000e5e8: 84 10 a2 06 or %g2, 0x206, %g2
4000e5ec: 80 a6 40 02 cmp %i1, %g2
4000e5f0: 12 80 00 3d bne 4000e6e4 <rtems_blkdev_ioctl+0x13c>
4000e5f4: 01 00 00 00 nop
4000e5f8: 30 80 00 27 b,a 4000e694 <rtems_blkdev_ioctl+0xec>
4000e5fc: 80 a6 40 02 cmp %i1, %g2
4000e600: 02 80 00 35 be 4000e6d4 <rtems_blkdev_ioctl+0x12c>
4000e604: 82 10 62 02 or %g1, 0x202, %g1
4000e608: 80 a6 40 01 cmp %i1, %g1
4000e60c: 12 80 00 36 bne 4000e6e4 <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
4000e610: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
4000e614: 10 80 00 16 b 4000e66c <rtems_blkdev_ioctl+0xc4>
4000e618: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
4000e61c: 80 a6 40 02 cmp %i1, %g2
4000e620: 22 80 00 2f be,a 4000e6dc <rtems_blkdev_ioctl+0x134>
4000e624: f0 26 80 00 st %i0, [ %i2 ]
4000e628: 38 80 00 08 bgu,a 4000e648 <rtems_blkdev_ioctl+0xa0>
4000e62c: 82 10 62 0b or %g1, 0x20b, %g1
4000e630: 82 10 62 05 or %g1, 0x205, %g1
4000e634: 80 a6 40 01 cmp %i1, %g1
4000e638: 12 80 00 2b bne 4000e6e4 <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
4000e63c: 01 00 00 00 nop
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000e640: 10 80 00 13 b 4000e68c <rtems_blkdev_ioctl+0xe4>
4000e644: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
4000e648: 80 a6 40 01 cmp %i1, %g1
4000e64c: 02 80 00 1e be 4000e6c4 <rtems_blkdev_ioctl+0x11c>
4000e650: 03 20 01 10 sethi %hi(0x80044000), %g1
4000e654: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <LEON_REG+0x44204>
4000e658: 80 a6 40 01 cmp %i1, %g1
4000e65c: 12 80 00 22 bne 4000e6e4 <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
4000e660: 01 00 00 00 nop
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
4000e664: 10 80 00 06 b 4000e67c <rtems_blkdev_ioctl+0xd4>
4000e668: d2 06 80 00 ld [ %i2 ], %o1
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000e66c: 10 80 00 1c b 4000e6dc <rtems_blkdev_ioctl+0x134>
4000e670: c2 26 80 00 st %g1, [ %i2 ]
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
4000e674: 10 80 00 06 b 4000e68c <rtems_blkdev_ioctl+0xe4>
4000e678: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
4000e67c: 7f ff ff 7c call 4000e46c <rtems_bdbuf_set_block_size>
4000e680: 94 10 20 01 mov 1, %o2
*(rtems_blkdev_bnum *) argp = dd->size;
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
4000e684: 10 80 00 07 b 4000e6a0 <rtems_blkdev_ioctl+0xf8>
4000e688: 80 a2 20 00 cmp %o0, 0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000e68c: 10 80 00 14 b 4000e6dc <rtems_blkdev_ioctl+0x134>
4000e690: c2 26 80 00 st %g1, [ %i2 ]
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
4000e694: 7f ff fe f3 call 4000e260 <rtems_bdbuf_syncdev>
4000e698: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
4000e69c: 80 a2 20 00 cmp %o0, 0
4000e6a0: 22 80 00 16 be,a 4000e6f8 <rtems_blkdev_ioctl+0x150> <== ALWAYS TAKEN
4000e6a4: b0 10 20 00 clr %i0
errno = EIO;
4000e6a8: 40 00 11 cf call 40012de4 <__errno> <== NOT EXECUTED
4000e6ac: 01 00 00 00 nop <== NOT EXECUTED
4000e6b0: 10 80 00 10 b 4000e6f0 <rtems_blkdev_ioctl+0x148> <== NOT EXECUTED
4000e6b4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
4000e6b8: 7f ff ff 01 call 4000e2bc <rtems_bdbuf_purge_dev>
4000e6bc: b0 10 20 00 clr %i0
4000e6c0: 30 80 00 0e b,a 4000e6f8 <rtems_blkdev_ioctl+0x150>
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
4000e6c4: 7f ff ff a7 call 4000e560 <rtems_bdbuf_get_device_stats>
4000e6c8: 92 10 00 1a mov %i2, %o1
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
4000e6cc: 81 c7 e0 08 ret
4000e6d0: 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);
4000e6d4: 7f ff ff ac call 4000e584 <rtems_bdbuf_reset_device_stats>
4000e6d8: 01 00 00 00 nop
break;
4000e6dc: 81 c7 e0 08 ret
4000e6e0: 91 e8 20 00 restore %g0, 0, %o0
default:
errno = EINVAL;
4000e6e4: 40 00 11 c0 call 40012de4 <__errno>
4000e6e8: 01 00 00 00 nop
4000e6ec: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4000e6f0: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
4000e6f4: b0 10 3f ff mov -1, %i0
break;
}
return rc;
}
4000e6f8: 81 c7 e0 08 ret
4000e6fc: 81 e8 00 00 restore
40021600 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
40021600: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
40021604: 92 10 20 00 clr %o1 <== NOT EXECUTED
40021608: 7f ff 88 13 call 40003654 <open> <== NOT EXECUTED
4002160c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
40021610: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40021614: 06 80 00 51 bl 40021758 <rtems_blkstats+0x158> <== NOT EXECUTED
40021618: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
4002161c: 40 00 07 2a call 400232c4 <fstat> <== NOT EXECUTED
40021620: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
40021624: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021628: 12 80 00 34 bne 400216f8 <rtems_blkstats+0xf8> <== NOT EXECUTED
4002162c: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
40021630: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
40021634: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
40021638: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
4002163c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40021640: 32 80 00 2a bne,a 400216e8 <rtems_blkstats+0xe8> <== NOT EXECUTED
40021644: 11 10 01 65 sethi %hi(0x40059400), %o0 <== NOT EXECUTED
if (reset) {
40021648: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4002164c: 02 80 00 11 be 40021690 <rtems_blkstats+0x90> <== NOT EXECUTED
40021650: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
40021654: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
40021658: 40 00 09 d8 call 40023db8 <ioctl> <== NOT EXECUTED
4002165c: 92 12 62 0c or %o1, 0x20c, %o1 ! 2000420c <RAM_SIZE+0x1fc0420c><== NOT EXECUTED
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
40021660: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021664: 02 80 00 2f be 40021720 <rtems_blkstats+0x120> <== NOT EXECUTED
40021668: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
4002166c: 40 00 52 ed call 40036220 <__errno> <== NOT EXECUTED
40021670: 01 00 00 00 nop <== NOT EXECUTED
40021674: 40 00 6e b8 call 4003d154 <strerror> <== NOT EXECUTED
40021678: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4002167c: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
40021680: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40021684: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED
40021688: 10 80 00 24 b 40021718 <rtems_blkstats+0x118> <== NOT EXECUTED
4002168c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
40021690: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
40021694: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
40021698: 40 00 09 c8 call 40023db8 <ioctl> <== NOT EXECUTED
4002169c: 92 12 62 0b or %o1, 0x20b, %o1 <== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
400216a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400216a4: 12 80 00 08 bne 400216c4 <rtems_blkstats+0xc4> <== NOT EXECUTED
400216a8: 01 00 00 00 nop <== NOT EXECUTED
rtems_blkdev_print_stats(
400216ac: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
400216b0: 13 10 00 db sethi %hi(0x40036c00), %o1 <== NOT EXECUTED
400216b4: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
400216b8: 40 00 00 34 call 40021788 <rtems_blkdev_print_stats> <== NOT EXECUTED
400216bc: 92 12 61 2c or %o1, 0x12c, %o1 <== NOT EXECUTED
400216c0: 30 80 00 18 b,a 40021720 <rtems_blkstats+0x120> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
400216c4: 40 00 52 d7 call 40036220 <__errno> <== NOT EXECUTED
400216c8: 01 00 00 00 nop <== NOT EXECUTED
400216cc: 40 00 6e a2 call 4003d154 <strerror> <== NOT EXECUTED
400216d0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400216d4: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
400216d8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400216dc: 92 12 60 f8 or %o1, 0xf8, %o1 <== NOT EXECUTED
400216e0: 10 80 00 0e b 40021718 <rtems_blkstats+0x118> <== NOT EXECUTED
400216e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
}
} else {
fprintf(output, "error: not a block device\n");
400216e8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400216ec: 40 00 55 e0 call 40036e6c <fputs> <== NOT EXECUTED
400216f0: 90 12 21 10 or %o0, 0x110, %o0 <== NOT EXECUTED
400216f4: 30 80 00 0b b,a 40021720 <rtems_blkstats+0x120> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
400216f8: 40 00 52 ca call 40036220 <__errno> <== NOT EXECUTED
400216fc: 01 00 00 00 nop <== NOT EXECUTED
40021700: 40 00 6e 95 call 4003d154 <strerror> <== NOT EXECUTED
40021704: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40021708: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
4002170c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40021710: 92 12 61 30 or %o1, 0x130, %o1 <== NOT EXECUTED
40021714: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021718: 40 00 55 85 call 40036d2c <fprintf> <== NOT EXECUTED
4002171c: 01 00 00 00 nop <== NOT EXECUTED
}
rv = close(fd);
40021720: 40 00 05 cb call 40022e4c <close> <== NOT EXECUTED
40021724: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
40021728: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002172c: 02 80 00 15 be 40021780 <rtems_blkstats+0x180> <== NOT EXECUTED
40021730: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
40021734: 40 00 52 bb call 40036220 <__errno> <== NOT EXECUTED
40021738: 01 00 00 00 nop <== NOT EXECUTED
4002173c: 40 00 6e 86 call 4003d154 <strerror> <== NOT EXECUTED
40021740: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40021744: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
40021748: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002174c: 92 12 61 50 or %o1, 0x150, %o1 <== NOT EXECUTED
40021750: 10 80 00 0a b 40021778 <rtems_blkstats+0x178> <== NOT EXECUTED
40021754: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
40021758: 40 00 52 b2 call 40036220 <__errno> <== NOT EXECUTED
4002175c: 01 00 00 00 nop <== NOT EXECUTED
40021760: 40 00 6e 7d call 4003d154 <strerror> <== NOT EXECUTED
40021764: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40021768: 13 10 01 65 sethi %hi(0x40059400), %o1 <== NOT EXECUTED
4002176c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40021770: 92 12 61 70 or %o1, 0x170, %o1 <== NOT EXECUTED
40021774: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021778: 40 00 55 6d call 40036d2c <fprintf> <== NOT EXECUTED
4002177c: 01 00 00 00 nop <== NOT EXECUTED
40021780: 81 c7 e0 08 ret <== NOT EXECUTED
40021784: 81 e8 00 00 restore <== NOT EXECUTED
400078e4 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
400078e4: 9d e3 bf 98 save %sp, -104, %sp
400078e8: 30 80 00 08 b,a 40007908 <rtems_chain_get_with_wait+0x24>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
400078ec: 92 10 20 00 clr %o1
400078f0: 94 10 00 1a mov %i2, %o2
400078f4: 7f ff fc fb call 40006ce0 <rtems_event_receive>
400078f8: 96 07 bf fc add %fp, -4, %o3
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
400078fc: 80 a2 20 00 cmp %o0, 0
40007900: 32 80 00 09 bne,a 40007924 <rtems_chain_get_with_wait+0x40><== ALWAYS TAKEN
40007904: fa 26 c0 00 st %i5, [ %i3 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
40007908: 40 00 01 83 call 40007f14 <_Chain_Get>
4000790c: 90 10 00 18 mov %i0, %o0
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
40007910: ba 92 20 00 orcc %o0, 0, %i5
40007914: 02 bf ff f6 be 400078ec <rtems_chain_get_with_wait+0x8>
40007918: 90 10 00 19 mov %i1, %o0
4000791c: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
40007920: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
40007924: 81 c7 e0 08 ret
40007928: 91 e8 00 08 restore %g0, %o0, %o0
4000340c <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
4000340c: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
40003410: 80 a6 60 00 cmp %i1, 0
40003414: 02 80 00 7c be 40003604 <rtems_cpu_usage_report_with_plugin+0x1f8><== NEVER TAKEN
40003418: 03 10 00 85 sethi %hi(0x40021400), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
4000341c: c0 27 bf e0 clr [ %fp + -32 ]
40003420: c0 27 bf e4 clr [ %fp + -28 ]
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
40003424: f8 18 60 00 ldd [ %g1 ], %i4
}
}
}
#endif
(*print)(
40003428: 90 10 00 18 mov %i0, %o0
4000342c: 13 10 00 78 sethi %hi(0x4001e000), %o1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40003430: 29 10 00 78 sethi %hi(0x4001e000), %l4
}
}
}
#endif
(*print)(
40003434: 92 12 61 10 or %o1, 0x110, %o1
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40003438: 27 10 00 83 sethi %hi(0x40020c00), %l3
4000343c: 9f c6 40 00 call %i1
40003440: 2b 10 00 78 sethi %hi(0x4001e000), %l5
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
40003444: a2 10 20 01 mov 1, %l1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40003448: a8 15 22 88 or %l4, 0x288, %l4
4000344c: a6 14 e1 a0 or %l3, 0x1a0, %l3
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
40003450: aa 15 62 a0 or %l5, 0x2a0, %l5
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
40003454: 83 2c 60 02 sll %l1, 2, %g1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
40003458: 05 10 00 83 sethi %hi(0x40020c00), %g2
4000345c: 84 10 a1 b4 or %g2, 0x1b4, %g2 ! 40020db4 <_Objects_Information_table>
40003460: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40003464: e4 00 60 04 ld [ %g1 + 4 ], %l2
if ( information ) {
40003468: 80 a4 a0 00 cmp %l2, 0
4000346c: 12 80 00 4a bne 40003594 <rtems_cpu_usage_report_with_plugin+0x188><== ALWAYS TAKEN
40003470: a0 10 20 01 mov 1, %l0
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
40003474: a2 04 60 01 inc %l1 <== NOT EXECUTED
40003478: 80 a4 60 04 cmp %l1, 4
4000347c: 12 bf ff f7 bne 40003458 <rtems_cpu_usage_report_with_plugin+0x4c>
40003480: 83 2c 60 02 sll %l1, 2, %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
40003484: 10 80 00 4a b 400035ac <rtems_cpu_usage_report_with_plugin+0x1a0>
40003488: f8 1f bf e0 ldd [ %fp + -32 ], %i4
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
4000348c: 83 2c 20 02 sll %l0, 2, %g1
40003490: f6 00 80 01 ld [ %g2 + %g1 ], %i3
if ( !the_thread )
40003494: 80 a6 e0 00 cmp %i3, 0
40003498: 02 80 00 3e be 40003590 <rtems_cpu_usage_report_with_plugin+0x184><== NEVER TAKEN
4000349c: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
400034a0: d0 06 e0 08 ld [ %i3 + 8 ], %o0
400034a4: 40 00 13 4a call 400081cc <rtems_object_get_name>
400034a8: 94 07 bf f0 add %fp, -16, %o2
(*print)(
400034ac: d4 06 e0 08 ld [ %i3 + 8 ], %o2
400034b0: 90 10 00 18 mov %i0, %o0
400034b4: 92 10 00 14 mov %l4, %o1
400034b8: 9f c6 40 00 call %i1
400034bc: 96 07 bf f0 add %fp, -16, %o3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
400034c0: 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 ) {
400034c4: 03 10 00 84 sethi %hi(0x40021000), %g1
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
400034c8: c4 3f bf e8 std %g2, [ %fp + -24 ]
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
400034cc: 82 10 63 a0 or %g1, 0x3a0, %g1
400034d0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
400034d4: c6 00 a0 08 ld [ %g2 + 8 ], %g3
400034d8: c4 06 e0 08 ld [ %i3 + 8 ], %g2
400034dc: 80 a0 c0 02 cmp %g3, %g2
400034e0: 12 80 00 4b bne 4000360c <rtems_cpu_usage_report_with_plugin+0x200>
400034e4: 90 07 bf d8 add %fp, -40, %o0
*time_of_context_switch = _Thread_Time_of_last_context_switch;
400034e8: f4 18 60 20 ldd [ %g1 + 0x20 ], %i2
400034ec: 40 00 18 4e call 40009624 <_TOD_Get_with_nanoseconds>
400034f0: 92 10 00 13 mov %l3, %o1
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
400034f4: d8 1f bf e8 ldd [ %fp + -24 ], %o4
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
400034f8: c4 1f bf d8 ldd [ %fp + -40 ], %g2
400034fc: 86 a0 c0 1b subcc %g3, %i3, %g3
40003500: 84 60 80 1a subx %g2, %i2, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40003504: 96 83 40 03 addcc %o5, %g3, %o3
40003508: 94 43 00 02 addx %o4, %g2, %o2
4000350c: d4 3f bf e8 std %o2, [ %fp + -24 ]
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40003510: c4 1f bf d8 ldd [ %fp + -40 ], %g2
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
40003514: 90 07 bf e8 add %fp, -24, %o0
40003518: 86 a0 c0 1d subcc %g3, %i5, %g3
4000351c: 84 60 80 1c subx %g2, %i4, %g2
40003520: 92 07 bf e0 add %fp, -32, %o1
40003524: c4 3f bf e0 std %g2, [ %fp + -32 ]
40003528: 94 07 bf d0 add %fp, -48, %o2
4000352c: 40 00 21 80 call 4000bb2c <_Timestamp64_Divide>
40003530: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
40003534: 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);
40003538: 94 10 20 00 clr %o2
4000353c: 90 10 00 1a mov %i2, %o0
40003540: 92 10 00 1b mov %i3, %o1
40003544: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40003548: 40 00 5b 84 call 4001a358 <__divdi3>
4000354c: 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);
40003550: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
40003554: ac 10 00 09 mov %o1, %l6
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
40003558: 90 10 00 1a mov %i2, %o0
4000355c: 92 10 00 1b mov %i3, %o1
40003560: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40003564: 40 00 5c 68 call 4001a704 <__moddi3>
40003568: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
4000356c: 90 10 00 09 mov %o1, %o0
40003570: 40 00 5a 22 call 40019df8 <.udiv>
40003574: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
40003578: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
4000357c: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
40003580: 92 10 00 15 mov %l5, %o1
40003584: 90 10 00 18 mov %i0, %o0
40003588: 9f c6 40 00 call %i1
4000358c: 94 10 00 16 mov %l6, %o2
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
40003590: a0 04 20 01 inc %l0
40003594: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1
40003598: 80 a4 00 01 cmp %l0, %g1
4000359c: 28 bf ff bc bleu,a 4000348c <rtems_cpu_usage_report_with_plugin+0x80>
400035a0: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
400035a4: 10 bf ff b5 b 40003478 <rtems_cpu_usage_report_with_plugin+0x6c>
400035a8: a2 04 60 01 inc %l1
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400035ac: 94 10 20 00 clr %o2
400035b0: 90 10 00 1c mov %i4, %o0
400035b4: 92 10 00 1d mov %i5, %o1
400035b8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400035bc: 40 00 5b 67 call 4001a358 <__divdi3>
400035c0: 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);
400035c4: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400035c8: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400035cc: 90 10 00 1c mov %i4, %o0
400035d0: 92 10 00 1d mov %i5, %o1
400035d4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400035d8: 40 00 5c 4b call 4001a704 <__moddi3>
400035dc: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
400035e0: 90 10 00 09 mov %o1, %o0
400035e4: 40 00 5a 05 call 40019df8 <.udiv>
400035e8: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
400035ec: 13 10 00 78 sethi %hi(0x4001e000), %o1
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
400035f0: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
400035f4: 92 12 62 b8 or %o1, 0x2b8, %o1
400035f8: 90 10 00 18 mov %i0, %o0
400035fc: 9f c6 40 00 call %i1
40003600: 94 10 00 1b mov %i3, %o2
40003604: 81 c7 e0 08 ret
40003608: 81 e8 00 00 restore
4000360c: 40 00 18 06 call 40009624 <_TOD_Get_with_nanoseconds>
40003610: 92 10 00 13 mov %l3, %o1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40003614: 10 bf ff c0 b 40003514 <rtems_cpu_usage_report_with_plugin+0x108>
40003618: c4 1f bf d8 ldd [ %fp + -40 ], %g2
4000e984 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
4000e984: 9d e3 bf a0 save %sp, -96, %sp
if (sc == RTEMS_SUCCESSFUL) {
4000e988: 80 a6 20 00 cmp %i0, 0
4000e98c: 02 80 00 0d be 4000e9c0 <rtems_deviceio_errno+0x3c>
4000e990: 82 10 20 00 clr %g1
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4000e994: 80 a6 20 1c cmp %i0, 0x1c
4000e998: 18 80 00 06 bgu 4000e9b0 <rtems_deviceio_errno+0x2c> <== NEVER TAKEN
4000e99c: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
4000e9a0: b1 2e 20 02 sll %i0, 2, %i0
4000e9a4: 03 10 00 72 sethi %hi(0x4001c800), %g1
4000e9a8: 82 10 60 f0 or %g1, 0xf0, %g1 ! 4001c8f0 <status_code_to_errno>
4000e9ac: fa 00 40 18 ld [ %g1 + %i0 ], %i5
}
errno = eno;
4000e9b0: 40 00 00 2f call 4000ea6c <__errno>
4000e9b4: 01 00 00 00 nop
return -1;
4000e9b8: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff>
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4000e9bc: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
4000e9c0: 81 c7 e0 08 ret
4000e9c4: 91 e8 00 01 restore %g0, %g1, %o0
400033b8 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
400033b8: 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;
400033bc: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
400033c0: 7f ff ff 11 call 40003004 <disk_lock>
400033c4: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
400033c8: a0 92 20 00 orcc %o0, 0, %l0
400033cc: 32 80 00 2b bne,a 40003478 <rtems_disk_create_log+0xc0> <== NEVER TAKEN
400033d0: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return sc;
}
phys_dd = get_disk_entry(phys, true);
400033d4: 92 10 00 1b mov %i3, %o1
400033d8: 90 10 00 1a mov %i2, %o0
400033dc: 7f ff fe cf call 40002f18 <get_disk_entry>
400033e0: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
400033e4: b6 92 20 00 orcc %o0, 0, %i3
400033e8: 12 80 00 06 bne 40003400 <rtems_disk_create_log+0x48>
400033ec: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
400033f0: 7f ff ff 14 call 40003040 <disk_unlock>
400033f4: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
400033f8: 81 c7 e0 08 ret
400033fc: 91 e8 00 10 restore %g0, %l0, %o0
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
40003400: 90 10 00 18 mov %i0, %o0
40003404: 92 10 00 19 mov %i1, %o1
40003408: 96 07 bf f8 add %fp, -8, %o3
4000340c: 7f ff ff 1a call 40003074 <create_disk>
40003410: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
40003414: a0 92 20 00 orcc %o0, 0, %l0
40003418: 12 80 00 16 bne 40003470 <rtems_disk_create_log+0xb8>
4000341c: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
40003420: 92 10 00 1b mov %i3, %o1
40003424: 94 10 00 1c mov %i4, %o2
40003428: 40 00 2d bc call 4000eb18 <rtems_disk_init_log>
4000342c: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
40003430: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
40003434: c4 07 bf fc ld [ %fp + -4 ], %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
40003438: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
4000343c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
++phys_dd->uses;
40003440: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
40003444: a0 10 00 08 mov %o0, %l0
);
dd->dev = dev;
dd->name = alloc_name;
++phys_dd->uses;
40003448: 84 00 a0 01 inc %g2
if (sc != RTEMS_SUCCESSFUL) {
4000344c: 80 a2 20 00 cmp %o0, 0
40003450: 02 80 00 08 be 40003470 <rtems_disk_create_log+0xb8>
40003454: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
dd->ioctl = null_handler;
40003458: 05 10 00 0b sethi %hi(0x40002c00), %g2
4000345c: 84 10 a3 a8 or %g2, 0x3a8, %g2 ! 40002fa8 <null_handler>
rtems_disk_delete(dev);
40003460: 90 10 00 18 mov %i0, %o0
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
40003464: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
40003468: 7f ff ff 6c call 40003218 <rtems_disk_delete>
4000346c: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
40003470: 7f ff fe f4 call 40003040 <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
40003480 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
40003480: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
40003484: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
40003488: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
4000348c: 80 a7 20 00 cmp %i4, 0
40003490: 02 80 00 23 be 4000351c <rtems_disk_create_phys+0x9c>
40003494: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
40003498: 7f ff fe db call 40003004 <disk_lock>
4000349c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400034a0: a0 92 20 00 orcc %o0, 0, %l0
400034a4: 12 80 00 1e bne 4000351c <rtems_disk_create_phys+0x9c> <== NEVER TAKEN
400034a8: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
400034ac: 90 10 00 18 mov %i0, %o0
400034b0: 92 10 00 19 mov %i1, %o1
400034b4: 96 07 bf f8 add %fp, -8, %o3
400034b8: 7f ff fe ef call 40003074 <create_disk>
400034bc: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
400034c0: a0 92 20 00 orcc %o0, 0, %l0
400034c4: 12 80 00 14 bne 40003514 <rtems_disk_create_phys+0x94>
400034c8: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
400034cc: 92 10 00 1a mov %i2, %o1
400034d0: 94 10 00 1b mov %i3, %o2
400034d4: 96 10 00 1c mov %i4, %o3
400034d8: 40 00 2d 76 call 4000eab0 <rtems_disk_init_phys>
400034dc: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
400034e0: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
400034e4: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
400034e8: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
400034ec: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
400034f0: 80 a2 20 00 cmp %o0, 0
400034f4: 02 80 00 08 be 40003514 <rtems_disk_create_phys+0x94>
400034f8: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
400034fc: 05 10 00 0b sethi %hi(0x40002c00), %g2
40003500: 84 10 a3 a8 or %g2, 0x3a8, %g2 ! 40002fa8 <null_handler>
rtems_disk_delete(dev);
40003504: 90 10 00 18 mov %i0, %o0
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
40003508: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
4000350c: 7f ff ff 43 call 40003218 <rtems_disk_delete>
40003510: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
40003514: 7f ff fe cb call 40003040 <disk_unlock>
40003518: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
4000351c: 81 c7 e0 08 ret
40003520: 91 e8 00 10 restore %g0, %l0, %o0
40003218 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
40003218: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
4000321c: 7f ff ff 7a call 40003004 <disk_lock>
40003220: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
40003224: b0 92 20 00 orcc %o0, 0, %i0
40003228: 12 80 00 0a bne 40003250 <rtems_disk_delete+0x38> <== NEVER TAKEN
4000322c: 90 10 00 1c mov %i4, %o0
return sc;
}
dd = get_disk_entry(dev, true);
40003230: 92 10 00 19 mov %i1, %o1
40003234: 7f ff ff 39 call 40002f18 <get_disk_entry>
40003238: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
4000323c: 82 92 20 00 orcc %o0, 0, %g1
40003240: 32 80 00 06 bne,a 40003258 <rtems_disk_delete+0x40> <== ALWAYS TAKEN
40003244: fa 00 60 08 ld [ %g1 + 8 ], %i5
disk_unlock();
40003248: 7f ff ff 7e call 40003040 <disk_unlock> <== NOT EXECUTED
4000324c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
40003250: 81 c7 e0 08 ret <== NOT EXECUTED
40003254: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INVALID_ID;
}
dd->deleted = true;
40003258: 84 10 20 01 mov 1, %g2
4000325c: 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) {
40003260: c4 0f 60 40 ldub [ %i5 + 0x40 ], %g2
40003264: 80 a0 a0 00 cmp %g2, 0
40003268: 22 80 00 41 be,a 4000336c <rtems_disk_delete+0x154>
4000326c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
40003270: e2 07 40 00 ld [ %i5 ], %l1
40003274: e4 07 60 04 ld [ %i5 + 4 ], %l2
unsigned deleted_count = 0;
40003278: b4 10 20 00 clr %i2
for (major = 0; major < disktab_size; ++major) {
4000327c: b8 10 20 00 clr %i4
40003280: 21 10 00 67 sethi %hi(0x40019c00), %l0
rtems_disk_device_table *dtab = disktab + major;
40003284: 27 10 00 67 sethi %hi(0x40019c00), %l3
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
40003288: 10 80 00 26 b 40003320 <rtems_disk_delete+0x108>
4000328c: a8 10 20 01 mov 1, %l4
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
40003290: 83 2f 20 03 sll %i4, 3, %g1
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
40003294: b6 10 20 00 clr %i3
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
40003298: 10 80 00 1d b 4000330c <rtems_disk_delete+0xf4>
4000329c: b2 06 40 01 add %i1, %g1, %i1
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400032a0: 85 2e e0 02 sll %i3, 2, %g2
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
400032a4: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
400032a8: 80 a2 20 00 cmp %o0, 0
400032ac: 22 80 00 18 be,a 4000330c <rtems_disk_delete+0xf4>
400032b0: b6 06 e0 01 inc %i3
400032b4: c8 02 20 08 ld [ %o0 + 8 ], %g4
400032b8: de 01 00 00 ld [ %g4 ], %o7
400032bc: 80 a3 c0 11 cmp %o7, %l1
400032c0: 32 80 00 13 bne,a 4000330c <rtems_disk_delete+0xf4> <== NEVER TAKEN
400032c4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
400032c8: c8 01 20 04 ld [ %g4 + 4 ], %g4
400032cc: 80 a1 00 12 cmp %g4, %l2
400032d0: 32 80 00 0f bne,a 4000330c <rtems_disk_delete+0xf4> <== NEVER TAKEN
400032d4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
400032d8: 80 a2 00 1d cmp %o0, %i5
400032dc: 22 80 00 0c be,a 4000330c <rtems_disk_delete+0xf4>
400032e0: b6 06 e0 01 inc %i3
if (dd->uses == 0) {
400032e4: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
400032e8: 80 a1 20 00 cmp %g4, 0
400032ec: 32 80 00 07 bne,a 40003308 <rtems_disk_delete+0xf0>
400032f0: e8 2a 20 40 stb %l4, [ %o0 + 0x40 ]
++deleted_count;
400032f4: b4 06 a0 01 inc %i2
dtab->minor [minor] = NULL;
free_disk_device(dd);
400032f8: 7f ff ff 2e call 40002fb0 <free_disk_device>
400032fc: 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) {
40003300: 10 80 00 03 b 4000330c <rtems_disk_delete+0xf4>
40003304: b6 06 e0 01 inc %i3
40003308: b6 06 e0 01 inc %i3
4000330c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40003310: 80 a6 c0 01 cmp %i3, %g1
40003314: 2a bf ff e3 bcs,a 400032a0 <rtems_disk_delete+0x88>
40003318: c6 06 40 00 ld [ %i1 ], %g3
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
4000331c: b8 07 20 01 inc %i4
40003320: c2 04 22 58 ld [ %l0 + 0x258 ], %g1
40003324: 80 a7 00 01 cmp %i4, %g1
40003328: 2a bf ff da bcs,a 40003290 <rtems_disk_delete+0x78>
4000332c: f2 04 e2 5c ld [ %l3 + 0x25c ], %i1
}
}
}
}
physical_disk->uses -= deleted_count;
40003330: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40003334: b4 20 40 1a sub %g1, %i2, %i2
if (physical_disk->uses == 0) {
40003338: 80 a6 a0 00 cmp %i2, 0
4000333c: 12 80 00 1b bne 400033a8 <rtems_disk_delete+0x190>
40003340: f4 27 60 14 st %i2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
40003344: c4 07 40 00 ld [ %i5 ], %g2
disktab [major].minor [minor] = NULL;
40003348: 07 10 00 67 sethi %hi(0x40019c00), %g3
4000334c: c6 00 e2 5c ld [ %g3 + 0x25c ], %g3 ! 40019e5c <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
40003350: c2 07 60 04 ld [ %i5 + 4 ], %g1
disktab [major].minor [minor] = NULL;
40003354: 85 28 a0 03 sll %g2, 3, %g2
40003358: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
4000335c: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
40003360: 90 10 00 1d mov %i5, %o0
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
40003364: 10 80 00 0f b 400033a0 <rtems_disk_delete+0x188>
40003368: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
4000336c: 80 a0 a0 00 cmp %g2, 0
40003370: 12 80 00 0e bne 400033a8 <rtems_disk_delete+0x190> <== NEVER TAKEN
40003374: 07 10 00 67 sethi %hi(0x40019c00), %g3
--physical_disk->uses;
40003378: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4000337c: 84 00 bf ff add %g2, -1, %g2
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
40003380: c6 00 e2 5c ld [ %g3 + 0x25c ], %g3
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
40003384: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
40003388: c4 00 40 00 ld [ %g1 ], %g2
4000338c: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
40003390: 85 28 a0 03 sll %g2, 3, %g2
40003394: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
40003398: 83 28 60 02 sll %g1, 2, %g1
4000339c: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(disk_to_remove);
400033a0: 7f ff ff 04 call 40002fb0 <free_disk_device>
400033a4: 01 00 00 00 nop
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
400033a8: 7f ff ff 26 call 40003040 <disk_unlock>
400033ac: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
400033b0: 81 c7 e0 08 ret
400033b4: 81 e8 00 00 restore
400036d8 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
400036d8: 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) {
400036dc: 39 10 00 67 sethi %hi(0x40019c00), %i4
400036e0: c2 07 22 58 ld [ %i4 + 0x258 ], %g1 ! 40019e58 <disktab_size>
400036e4: 80 a0 60 00 cmp %g1, 0
400036e8: 12 80 00 19 bne 4000374c <rtems_disk_io_initialize+0x74>
400036ec: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
400036f0: 90 10 20 08 mov 8, %o0
400036f4: 92 10 20 08 mov 8, %o1
400036f8: 40 00 02 1d call 40003f6c <calloc>
400036fc: 3b 10 00 67 sethi %hi(0x40019c00), %i5
40003700: d0 27 62 5c st %o0, [ %i5 + 0x25c ] ! 40019e5c <disktab>
if (disktab == NULL) {
40003704: 80 a2 20 00 cmp %o0, 0
40003708: 02 80 00 11 be 4000374c <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
4000370c: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
40003710: 03 10 00 67 sethi %hi(0x40019c00), %g1
sc = rtems_semaphore_create(
40003714: 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;
40003718: c0 28 62 50 clrb [ %g1 + 0x250 ]
sc = rtems_semaphore_create(
4000371c: 90 12 21 56 or %o0, 0x156, %o0
40003720: 92 10 20 01 mov 1, %o1
40003724: 94 10 20 10 mov 0x10, %o2
40003728: 96 10 20 00 clr %o3
4000372c: 37 10 00 67 sethi %hi(0x40019c00), %i3
40003730: 40 00 12 2e call 40007fe8 <rtems_semaphore_create>
40003734: 98 16 e2 54 or %i3, 0x254, %o4 ! 40019e54 <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
40003738: 80 a2 20 00 cmp %o0, 0
4000373c: 02 80 00 06 be 40003754 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
40003740: 01 00 00 00 nop
free(disktab);
40003744: 40 00 02 42 call 4000404c <free> <== NOT EXECUTED
40003748: d0 07 62 5c ld [ %i5 + 0x25c ], %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
4000374c: 81 c7 e0 08 ret
40003750: 81 e8 00 00 restore
}
sc = rtems_bdbuf_init();
40003754: 40 00 28 65 call 4000d8e8 <rtems_bdbuf_init>
40003758: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
4000375c: 80 a2 20 00 cmp %o0, 0
40003760: 02 80 00 09 be 40003784 <rtems_disk_io_initialize+0xac> <== ALWAYS TAKEN
40003764: 82 10 20 08 mov 8, %g1
rtems_semaphore_delete(diskdevs_mutex);
40003768: d0 06 e2 54 ld [ %i3 + 0x254 ], %o0 <== NOT EXECUTED
4000376c: 40 00 12 8d call 400081a0 <rtems_semaphore_delete> <== NOT EXECUTED
40003770: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
free(disktab);
40003774: 40 00 02 36 call 4000404c <free> <== NOT EXECUTED
40003778: d0 07 62 5c ld [ %i5 + 0x25c ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
4000377c: 81 c7 e0 08 ret <== NOT EXECUTED
40003780: 81 e8 00 00 restore <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
40003784: b0 10 20 00 clr %i0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
40003788: c2 27 22 58 st %g1, [ %i4 + 0x258 ]
return RTEMS_SUCCESSFUL;
}
4000378c: 81 c7 e0 08 ret
40003790: 81 e8 00 00 restore
400035e8 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
400035e8: 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) {
400035ec: 80 a6 3f ff cmp %i0, -1
400035f0: 12 80 00 05 bne 40003604 <rtems_disk_next+0x1c>
400035f4: b8 06 60 01 add %i1, 1, %i4
400035f8: 80 a6 7f ff cmp %i1, -1
400035fc: 22 80 00 0b be,a 40003628 <rtems_disk_next+0x40> <== ALWAYS TAKEN
40003600: b8 10 20 00 clr %i4
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
40003604: 80 a7 00 19 cmp %i4, %i1
40003608: 1a 80 00 09 bcc 4000362c <rtems_disk_next+0x44> <== ALWAYS TAKEN
4000360c: ba 10 00 18 mov %i0, %i5
/* If major wraps around */
if ((major + 1) < major) {
40003610: ba 06 20 01 add %i0, 1, %i5 <== NOT EXECUTED
40003614: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
40003618: 1a 80 00 05 bcc 4000362c <rtems_disk_next+0x44> <== NOT EXECUTED
4000361c: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
if (major >= disktab_size) {
disk_unlock();
return NULL;
40003620: 81 c7 e0 08 ret <== NOT EXECUTED
40003624: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40003628: ba 10 20 00 clr %i5
} else {
++minor;
}
}
sc = disk_lock();
4000362c: 7f ff fe 76 call 40003004 <disk_lock>
40003630: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40003634: 80 a2 20 00 cmp %o0, 0
40003638: 12 80 00 08 bne 40003658 <rtems_disk_next+0x70> <== NEVER TAKEN
4000363c: 03 10 00 67 sethi %hi(0x40019c00), %g1
return NULL;
}
if (major >= disktab_size) {
40003640: c4 00 62 58 ld [ %g1 + 0x258 ], %g2 ! 40019e58 <disktab_size>
40003644: 80 a7 40 02 cmp %i5, %g2
40003648: 0a 80 00 06 bcs 40003660 <rtems_disk_next+0x78> <== ALWAYS TAKEN
4000364c: 03 10 00 67 sethi %hi(0x40019c00), %g1
disk_unlock();
40003650: 7f ff fe 7c call 40003040 <disk_unlock>
40003654: 01 00 00 00 nop
return NULL;
40003658: 81 c7 e0 08 ret
4000365c: 91 e8 20 00 restore %g0, 0, %o0
}
dtab = disktab + major;
40003660: c6 00 62 5c ld [ %g1 + 0x25c ], %g3
40003664: b7 2f 60 03 sll %i5, 3, %i3
40003668: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
4000366c: c2 06 c0 00 ld [ %i3 ], %g1
40003670: 80 a0 60 00 cmp %g1, 0
40003674: 22 80 00 07 be,a 40003690 <rtems_disk_next+0xa8>
40003678: ba 07 60 01 inc %i5
4000367c: c8 06 e0 04 ld [ %i3 + 4 ], %g4
40003680: 80 a7 00 04 cmp %i4, %g4
40003684: 0a 80 00 09 bcs 400036a8 <rtems_disk_next+0xc0>
40003688: b5 2f 20 02 sll %i4, 2, %i2
minor = 0;
++major;
4000368c: ba 07 60 01 inc %i5
if (major >= disktab_size) {
40003690: 80 a7 40 02 cmp %i5, %g2
40003694: 1a bf ff ef bcc 40003650 <rtems_disk_next+0x68>
40003698: b7 2f 60 03 sll %i5, 3, %i3
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
4000369c: b8 10 20 00 clr %i4
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
400036a0: 10 bf ff f3 b 4000366c <rtems_disk_next+0x84>
400036a4: b6 00 c0 1b add %g3, %i3, %i3
} else if (dtab->minor [minor] == NULL) {
400036a8: c2 00 40 1a ld [ %g1 + %i2 ], %g1
400036ac: 80 a0 60 00 cmp %g1, 0
400036b0: 02 bf ff ef be 4000366c <rtems_disk_next+0x84>
400036b4: b8 07 20 01 inc %i4
++minor;
} else {
++dtab->minor [minor]->uses;
400036b8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
400036bc: 84 00 a0 01 inc %g2
disk_unlock();
400036c0: 7f ff fe 60 call 40003040 <disk_unlock>
400036c4: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return dtab->minor [minor];
400036c8: c2 06 c0 00 ld [ %i3 ], %g1
400036cc: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
400036d0: 81 c7 e0 08 ret
400036d4: 81 e8 00 00 restore
40003524 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
40003524: 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);
40003528: 7f ff fd 13 call 40002974 <sparc_disable_interrupts>
4000352c: b8 10 00 18 mov %i0, %i4
40003530: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
40003534: 03 10 00 67 sethi %hi(0x40019c00), %g1
40003538: c2 08 62 50 ldub [ %g1 + 0x250 ], %g1 ! 40019e50 <diskdevs_protected>
4000353c: 80 a0 60 00 cmp %g1, 0
40003540: 12 80 00 0a bne 40003568 <rtems_disk_obtain+0x44> <== NEVER TAKEN
40003544: 92 10 00 19 mov %i1, %o1
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
40003548: 90 10 00 18 mov %i0, %o0
4000354c: 7f ff fe 73 call 40002f18 <get_disk_entry>
40003550: 94 10 20 00 clr %o2
40003554: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
40003558: 7f ff fd 0b call 40002984 <sparc_enable_interrupts>
4000355c: 90 10 00 1b mov %i3, %o0
40003560: 81 c7 e0 08 ret
40003564: 81 e8 00 00 restore
} else {
rtems_interrupt_enable(level);
40003568: 7f ff fd 07 call 40002984 <sparc_enable_interrupts> <== NOT EXECUTED
4000356c: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
40003570: 7f ff fe a5 call 40003004 <disk_lock> <== NOT EXECUTED
40003574: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
40003578: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000357c: 12 bf ff f9 bne 40003560 <rtems_disk_obtain+0x3c> <== NOT EXECUTED
40003580: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
40003584: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40003588: 7f ff fe 64 call 40002f18 <get_disk_entry> <== NOT EXECUTED
4000358c: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
40003590: 7f ff fe ac call 40003040 <disk_unlock> <== NOT EXECUTED
40003594: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
40003598: 81 c7 e0 08 ret <== NOT EXECUTED
4000359c: 81 e8 00 00 restore <== NOT EXECUTED
40010560 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
40010560: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
40010564: 80 a6 e0 00 cmp %i3, 0
40010568: 02 80 00 1e be 400105e0 <rtems_event_system_receive+0x80> <== NEVER TAKEN
4001056c: 82 10 20 09 mov 9, %g1
Thread_Control *executing = _Thread_Executing;
40010570: 03 10 00 6a sethi %hi(0x4001a800), %g1
40010574: fa 00 60 30 ld [ %g1 + 0x30 ], %i5 ! 4001a830 <_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 ) ) {
40010578: 80 a6 20 00 cmp %i0, 0
4001057c: 02 80 00 16 be 400105d4 <rtems_event_system_receive+0x74> <== NEVER TAKEN
40010580: da 07 61 4c ld [ %i5 + 0x14c ], %o5
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40010584: 03 10 00 68 sethi %hi(0x4001a000), %g1
40010588: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 4001a310 <_Thread_Dispatch_disable_level>
++level;
4001058c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40010590: c4 20 63 10 st %g2, [ %g1 + 0x310 ]
_Thread_Disable_dispatch();
_Event_Seize(
40010594: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40010598: 82 10 60 20 or %g1, 0x20, %g1 ! 4001ac20 <_System_event_Sync_state>
4001059c: 90 10 00 18 mov %i0, %o0
400105a0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400105a4: 92 10 00 19 mov %i1, %o1
400105a8: 03 00 01 00 sethi %hi(0x40000), %g1
400105ac: 94 10 00 1a mov %i2, %o2
400105b0: 96 10 00 1b mov %i3, %o3
400105b4: 98 10 00 1d mov %i5, %o4
400105b8: 9a 03 60 04 add %o5, 4, %o5
400105bc: 7f ff dd ba call 40007ca4 <_Event_Seize>
400105c0: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
400105c4: 7f ff e9 21 call 4000aa48 <_Thread_Enable_dispatch>
400105c8: 01 00 00 00 nop
sc = executing->Wait.return_code;
400105cc: 10 80 00 05 b 400105e0 <rtems_event_system_receive+0x80>
400105d0: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
} else {
*event_out = event->pending_events;
400105d4: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED
400105d8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
400105dc: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
400105e0: 81 c7 e0 08 ret
400105e4: 91 e8 00 01 restore %g0, %g1, %o0
40007148 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
40007148: 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 );
4000714c: 90 10 00 18 mov %i0, %o0
40007150: 40 00 09 c0 call 40009850 <_Thread_Get>
40007154: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40007158: c4 07 bf fc ld [ %fp + -4 ], %g2
4000715c: 80 a0 a0 00 cmp %g2, 0
40007160: 12 80 00 0d bne 40007194 <rtems_event_system_send+0x4c> <== NEVER TAKEN
40007164: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
40007168: d4 02 21 4c ld [ %o0 + 0x14c ], %o2
4000716c: 94 02 a0 04 add %o2, 4, %o2
40007170: 19 00 01 00 sethi %hi(0x40000), %o4
40007174: 17 10 00 7a sethi %hi(0x4001e800), %o3
40007178: 96 12 e3 10 or %o3, 0x310, %o3 ! 4001eb10 <_System_event_Sync_state>
4000717c: 7f ff fe 64 call 40006b0c <_Event_Surrender>
40007180: b0 10 20 00 clr %i0
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
40007184: 40 00 09 a7 call 40009820 <_Thread_Enable_dispatch>
40007188: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
break;
4000718c: 81 c7 e0 08 ret
40007190: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
40007194: 81 c7 e0 08 ret <== NOT EXECUTED
40007198: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
40006e04 <rtems_fdisk_abort.constprop.0>:
*
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
40006e04: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
40006e08: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
40006e0c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
40006e10: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
40006e14: 3b 10 00 da sethi %hi(0x40036800), %i5 <== NOT EXECUTED
40006e18: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 ! 40036b30 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
40006e1c: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40006e20: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40006e24: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40006e28: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
40006e2c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40006e30: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
40006e34: 40 00 67 13 call 40020a80 <fputs> <== NOT EXECUTED
40006e38: 90 12 22 88 or %o0, 0x288, %o0 ! 40031a88 <__FUNCTION__.6193+0x280><== NOT EXECUTED
vfprintf (stderr, format, args);
40006e3c: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
40006e40: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
40006e44: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40006e48: 40 00 67 0e call 40020a80 <fputs> <== NOT EXECUTED
40006e4c: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
40006e50: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
40006e54: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
40006e58: 40 00 66 d6 call 400209b0 <fputc> <== NOT EXECUTED
40006e5c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
40006e60: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
40006e64: 40 00 65 bb call 40020550 <fflush> <== NOT EXECUTED
40006e68: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
40006e6c: 40 00 64 b9 call 40020150 <exit> <== NOT EXECUTED
40006e70: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
4000553c <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)
{
4000553c: 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)
40005540: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
40005544: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40005548: 80 a0 80 01 cmp %g2, %g1
4000554c: 1a 80 00 72 bcc 40005714 <rtems_fdisk_compact+0x1d8>
40005550: ba 10 00 18 mov %i0, %i5
fd->starvations++;
40005554: 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");
40005558: 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++;
4000555c: 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");
40005560: 13 10 00 c7 sethi %hi(0x40031c00), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
40005564: 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");
40005568: 7f ff fc ac call 40004818 <rtems_fdisk_printf>
4000556c: 92 12 62 60 or %o1, 0x260, %o1
#endif
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
40005570: 7f ff fb d6 call 400044c8 <rtems_fdisk_segment_queue_pop_head>
40005574: 90 06 20 40 add %i0, 0x40, %o0
if (!ssc)
40005578: b8 92 20 00 orcc %o0, 0, %i4
4000557c: 12 80 00 07 bne 40005598 <rtems_fdisk_compact+0x5c> <== ALWAYS TAKEN
40005580: 01 00 00 00 nop
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
40005584: 7f ff fb d1 call 400044c8 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
40005588: 90 06 20 34 add %i0, 0x34, %o0 <== NOT EXECUTED
if (ssc)
4000558c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40005590: 02 80 00 12 be 400055d8 <rtems_fdisk_compact+0x9c> <== NOT EXECUTED
40005594: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
40005598: 7f ff fc 6e call 40004750 <rtems_fdisk_seg_most_available>
4000559c: 90 07 60 34 add %i5, 0x34, %o0
if (dsc)
400055a0: 94 92 20 00 orcc %o0, 0, %o2
400055a4: 02 80 00 0a be 400055cc <rtems_fdisk_compact+0x90> <== NEVER TAKEN
400055a8: 92 10 00 1c mov %i4, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
400055ac: 90 10 00 1d mov %i5, %o0
400055b0: 7f ff ff 02 call 400051b8 <rtems_fdisk_recycle_segment>
400055b4: 96 07 bf fc add %fp, -4, %o3
if (ret)
400055b8: 80 a2 20 00 cmp %o0, 0
400055bc: 02 80 00 57 be 40005718 <rtems_fdisk_compact+0x1dc> <== ALWAYS TAKEN
400055c0: 21 10 00 c7 sethi %hi(0x40031c00), %l0
compacted_segs += segments;
}
return 0;
}
400055c4: 81 c7 e0 08 ret <== NOT EXECUTED
400055c8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
400055cc: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
400055d0: 10 80 00 03 b 400055dc <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
400055d4: 90 12 22 78 or %o0, 0x278, %o0 ! 40031e78 <__FUNCTION__.6193+0x670><== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
400055d8: 90 12 22 90 or %o0, 0x290, %o0 <== NOT EXECUTED
400055dc: 7f ff fc cf call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
400055e0: 01 00 00 00 nop <== NOT EXECUTED
return EIO;
400055e4: 10 80 00 61 b 40005768 <rtems_fdisk_compact+0x22c> <== NOT EXECUTED
400055e8: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
400055ec: 7f ff fc 8b call 40004818 <rtems_fdisk_printf>
400055f0: 90 10 00 1d mov %i5, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
400055f4: 7f ff fc 57 call 40004750 <rtems_fdisk_seg_most_available>
400055f8: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
400055fc: b6 92 20 00 orcc %o0, 0, %i3
40005600: 12 80 00 05 bne 40005614 <rtems_fdisk_compact+0xd8> <== ALWAYS TAKEN
40005604: 01 00 00 00 nop
{
rtems_fdisk_error ("compacting: no available segments to compact too");
40005608: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
4000560c: 10 bf ff f4 b 400055dc <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
40005610: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 40031ec0 <__FUNCTION__.6193+0x6b8><== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
40005614: 7f ff fc 47 call 40004730 <rtems_fdisk_seg_pages_available>
40005618: 01 00 00 00 nop
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4000561c: d4 06 e0 08 ld [ %i3 + 8 ], %o2
40005620: d6 06 e0 0c ld [ %i3 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
40005624: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
dst_pages = rtems_fdisk_seg_pages_available (dsc);
40005628: b0 10 00 08 mov %o0, %i0
segments = 0;
pages = 0;
4000562c: c0 27 bf fc clr [ %fp + -4 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
40005630: 90 10 00 1d mov %i5, %o0
40005634: 7f ff fc 79 call 40004818 <rtems_fdisk_printf>
40005638: 92 10 00 11 mov %l1, %o1
4000563c: d8 07 bf fc ld [ %fp + -4 ], %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
40005640: 10 80 00 04 b 40005650 <rtems_fdisk_compact+0x114>
40005644: 9a 10 20 00 clr %o5
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
40005648: 9a 03 60 01 inc %o5
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
4000564c: 98 10 00 01 mov %g1, %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
40005650: 80 a7 20 00 cmp %i4, 0
40005654: 32 80 00 09 bne,a 40005678 <rtems_fdisk_compact+0x13c>
40005658: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
4000565c: 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");
40005660: 90 10 00 1d mov %i5, %o0
40005664: 13 10 00 c7 sethi %hi(0x40031c00), %o1
40005668: 7f ff fc 6c call 40004818 <rtems_fdisk_printf>
4000566c: 92 12 63 18 or %o1, 0x318, %o1 ! 40031f18 <__FUNCTION__.6193+0x710>
}
compacted_segs += segments;
}
return 0;
40005670: 10 80 00 3e b 40005768 <rtems_fdisk_compact+0x22c>
40005674: 90 10 20 00 clr %o0
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
40005678: 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 &&
4000567c: 80 a0 40 18 cmp %g1, %i0
40005680: 1a 80 00 34 bcc 40005750 <rtems_fdisk_compact+0x214>
40005684: 86 03 40 1a add %o5, %i2, %g3
((pages + ssc->pages_active) < dst_pages) &&
40005688: c4 07 60 0c ld [ %i5 + 0xc ], %g2
4000568c: 80 a0 c0 02 cmp %g3, %g2
40005690: 2a bf ff ee bcs,a 40005648 <rtems_fdisk_compact+0x10c> <== ALWAYS TAKEN
40005694: f8 07 00 00 ld [ %i4 ], %i4
40005698: 10 80 00 2f b 40005754 <rtems_fdisk_compact+0x218> <== NOT EXECUTED
4000569c: d8 27 bf fc st %o4, [ %fp + -4 ] <== NOT EXECUTED
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
400056a0: 80 a6 a0 01 cmp %i2, 1
400056a4: 22 bf ff f0 be,a 40005664 <rtems_fdisk_compact+0x128>
400056a8: 90 10 00 1d mov %i5, %o0
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
400056ac: d4 07 20 08 ld [ %i4 + 8 ], %o2
400056b0: d6 07 20 0c ld [ %i4 + 0xc ], %o3
400056b4: 92 10 00 12 mov %l2, %o1
400056b8: 7f ff fc 58 call 40004818 <rtems_fdisk_printf>
400056bc: 90 10 00 1d mov %i5, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
400056c0: 90 10 00 19 mov %i1, %o0
400056c4: 7f ff fb a3 call 40004550 <rtems_fdisk_segment_queue_remove>
400056c8: 92 10 00 1b mov %i3, %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
400056cc: 10 80 00 0e b 40005704 <rtems_fdisk_compact+0x1c8>
400056d0: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
400056d4: 7f ff fb 7d call 400044c8 <rtems_fdisk_segment_queue_pop_head>
400056d8: 90 10 00 13 mov %l3, %o0
if (ssc)
400056dc: 92 92 20 00 orcc %o0, 0, %o1
400056e0: 02 80 00 09 be 40005704 <rtems_fdisk_compact+0x1c8> <== NEVER TAKEN
400056e4: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
400056e8: 90 10 00 1d mov %i5, %o0
400056ec: 94 10 00 1b mov %i3, %o2
400056f0: 7f ff fe b2 call 400051b8 <rtems_fdisk_recycle_segment>
400056f4: 96 07 bf fc add %fp, -4, %o3
if (ret)
400056f8: 80 a2 20 00 cmp %o0, 0
400056fc: 12 80 00 1b bne 40005768 <rtems_fdisk_compact+0x22c> <== NEVER TAKEN
40005700: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* We now copy the pages to the new segment.
*/
while (pages)
40005704: 80 a0 60 00 cmp %g1, 0
40005708: 22 80 00 0d be,a 4000573c <rtems_fdisk_compact+0x200>
4000570c: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
40005710: 30 bf ff f1 b,a 400056d4 <rtems_fdisk_compact+0x198>
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
40005714: 21 10 00 c7 sethi %hi(0x40031c00), %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",
40005718: 23 10 00 c7 sethi %hi(0x40031c00), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
4000571c: 25 10 00 c7 sethi %hi(0x40031c00), %l2
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
40005720: b4 10 20 00 clr %i2
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
40005724: a0 14 22 b0 or %l0, 0x2b0, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
40005728: b2 07 60 34 add %i5, 0x34, %i1
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4000572c: a2 14 62 f8 or %l1, 0x2f8, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40005730: a4 14 a3 30 or %l2, 0x330, %l2
* We now copy the pages to the new segment.
*/
while (pages)
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
40005734: a6 07 60 40 add %i5, 0x40, %l3
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
40005738: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
4000573c: 80 a0 60 00 cmp %g1, 0
40005740: 12 bf ff ab bne 400055ec <rtems_fdisk_compact+0xb0>
40005744: 92 10 00 10 mov %l0, %o1
}
compacted_segs += segments;
}
return 0;
40005748: 10 80 00 08 b 40005768 <rtems_fdisk_compact+0x22c>
4000574c: 90 10 20 00 clr %o0
40005750: 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))
40005754: 80 a3 20 00 cmp %o4, 0
40005758: 32 bf ff d2 bne,a 400056a0 <rtems_fdisk_compact+0x164>
4000575c: b4 06 80 0d add %i2, %o5, %i2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
40005760: 10 bf ff c1 b 40005664 <rtems_fdisk_compact+0x128>
40005764: 90 10 00 1d mov %i5, %o0
compacted_segs += segments;
}
return 0;
}
40005768: b0 10 00 08 mov %o0, %i0
4000576c: 81 c7 e0 08 ret
40005770: 81 e8 00 00 restore
4000498c <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
4000498c: 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;
40004990: d2 06 60 08 ld [ %i1 + 8 ], %o1
segment = sc->segment;
40004994: d4 06 60 0c ld [ %i1 + 0xc ], %o2
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40004998: 85 2a 60 04 sll %o1, 4, %g2
4000499c: 83 2a 60 02 sll %o1, 2, %g1
400049a0: 82 20 80 01 sub %g2, %g1, %g1
400049a4: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
400049a8: 89 2a a0 06 sll %o2, 6, %g4
400049ac: 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;
400049b0: 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;
400049b4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
400049b8: 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;
400049bc: 85 2a a0 04 sll %o2, 4, %g2
400049c0: 84 21 00 02 sub %g4, %g2, %g2
400049c4: 84 00 40 02 add %g1, %g2, %g2
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
400049c8: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
400049cc: 9f c0 40 00 call %g1
400049d0: d0 00 a0 04 ld [ %g2 + 4 ], %o0
if (ret)
400049d4: ba 92 20 00 orcc %o0, 0, %i5
400049d8: 22 80 00 16 be,a 40004a30 <rtems_fdisk_erase_segment+0xa4><== ALWAYS TAKEN
400049dc: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
400049e0: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
400049e4: 40 00 77 9d call 40022858 <strerror> <== NOT EXECUTED
400049e8: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
400049ec: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400049f0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400049f4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400049f8: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
400049fc: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
40004a00: 7f ff ff c6 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40004a04: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40031ab8 <__FUNCTION__.6193+0x2b0><== NOT EXECUTED
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
40004a08: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
40004a0c: b0 06 20 58 add %i0, 0x58, %i0 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
40004a10: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
40004a14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40004a18: 7f ff ff 09 call 4000463c <rtems_fdisk_segment_queue_present><== NOT EXECUTED
40004a1c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40004a20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40004a24: 12 80 00 18 bne 40004a84 <rtems_fdisk_erase_segment+0xf8> <== NOT EXECUTED
40004a28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40004a2c: 30 80 00 14 b,a 40004a7c <rtems_fdisk_erase_segment+0xf0><== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
40004a30: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004a34: d2 06 60 18 ld [ %i1 + 0x18 ], %o1
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
40004a38: 82 00 80 01 add %g2, %g1, %g1
40004a3c: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
sc->erased++;
40004a40: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004a44: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
40004a48: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004a4c: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
40004a50: 7f ff f6 d1 call 40002594 <.umul>
40004a54: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
40004a58: 92 10 20 ff mov 0xff, %o1
40004a5c: 94 10 00 08 mov %o0, %o2
40004a60: 40 00 72 94 call 400214b0 <memset>
40004a64: 90 10 00 1c mov %i4, %o0
/*
* Push to the tail of the available queue. It is a very
* simple type of wear reduction. Every other available
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
40004a68: 90 06 20 34 add %i0, 0x34, %o0
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
40004a6c: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
40004a70: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
40004a74: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
40004a78: c0 26 60 28 clr [ %i1 + 0x28 ]
/*
* Push to the tail of the available queue. It is a very
* simple type of wear reduction. Every other available
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
40004a7c: 7f ff fe a3 call 40004508 <rtems_fdisk_segment_queue_push_tail>
40004a80: 92 10 00 19 mov %i1, %o1
return 0;
}
40004a84: 81 c7 e0 08 ret
40004a88: 91 e8 00 1d restore %g0, %i5, %o0
40004918 <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, ...)
{
40004918: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
4000491c: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
40004920: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
40004924: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40004928: 3b 10 00 da sethi %hi(0x40036800), %i5 <== NOT EXECUTED
4000492c: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 ! 40036b30 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
40004930: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40004934: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40004938: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
4000493c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40004940: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40004944: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
40004948: 40 00 70 4e call 40020a80 <fputs> <== NOT EXECUTED
4000494c: 90 12 22 78 or %o0, 0x278, %o0 ! 40031a78 <__FUNCTION__.6193+0x270><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
40004950: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
40004954: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
40004958: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
4000495c: 40 00 93 45 call 40029670 <vfprintf> <== NOT EXECUTED
40004960: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
40004964: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
40004968: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
4000496c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40004970: 40 00 70 10 call 400209b0 <fputc> <== NOT EXECUTED
40004974: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
40004978: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
4000497c: 40 00 6e f5 call 40020550 <fflush> <== NOT EXECUTED
40004980: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
40004984: 81 c7 e0 08 ret <== NOT EXECUTED
40004988: 81 e8 00 00 restore <== NOT EXECUTED
40004798 <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, ...)
{
40004798: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
4000479c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400047a0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400047a4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
400047a8: 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)
400047ac: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
400047b0: 80 a0 60 01 cmp %g1, 1
400047b4: 08 80 00 17 bleu 40004810 <rtems_fdisk_info+0x78> <== ALWAYS TAKEN
400047b8: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
400047bc: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
400047c0: 3b 10 00 da sethi %hi(0x40036800), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
400047c4: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
400047c8: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
400047cc: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
400047d0: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
400047d4: 40 00 70 ab call 40020a80 <fputs> <== NOT EXECUTED
400047d8: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
400047dc: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
400047e0: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
400047e4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
400047e8: 40 00 93 a2 call 40029670 <vfprintf> <== NOT EXECUTED
400047ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
400047f0: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
400047f4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
400047f8: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
400047fc: 40 00 70 6d call 400209b0 <fputc> <== NOT EXECUTED
40004800: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
40004804: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
40004808: 40 00 6f 52 call 40020550 <fflush> <== NOT EXECUTED
4000480c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40004810: 81 c7 e0 08 ret
40004814: 81 e8 00 00 restore
40006900 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
40006900: 9d e3 bf 60 save %sp, -160, %sp
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
40006904: 7f ff f6 8c call 40004334 <rtems_disk_io_initialize>
40006908: b4 10 00 18 mov %i0, %i2
if (sc != RTEMS_SUCCESSFUL)
4000690c: b0 92 20 00 orcc %o0, 0, %i0
40006910: 12 80 01 3b bne 40006dfc <rtems_fdisk_initialize+0x4fc> <== NEVER TAKEN
40006914: 01 00 00 00 nop
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
40006918: 40 00 05 1c call 40007d88 <malloc>
4000691c: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200>
40006920: 03 10 01 1c sethi %hi(0x40047000), %g1
40006924: d0 20 60 a0 st %o0, [ %g1 + 0xa0 ] ! 400470a0 <rtems_fdisk_crc16_factor>
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
40006928: 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)
4000692c: 82 10 20 00 clr %g1
40006930: 80 a2 20 00 cmp %o0, 0
40006934: 12 80 00 04 bne 40006944 <rtems_fdisk_initialize+0x44> <== ALWAYS TAKEN
40006938: 88 11 20 08 or %g4, 8, %g4
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
4000693c: 81 c7 e0 08 ret <== NOT EXECUTED
40006940: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
40006944: 84 10 00 01 mov %g1, %g2
40006948: 10 80 00 06 b 40006960 <rtems_fdisk_initialize+0x60>
4000694c: 86 10 20 09 mov 9, %g3
40006950: 85 28 a0 10 sll %g2, 0x10, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
40006954: 02 80 00 03 be 40006960 <rtems_fdisk_initialize+0x60>
40006958: 85 30 a0 11 srl %g2, 0x11, %g2
4000695c: 84 18 80 04 xor %g2, %g4, %g2
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
40006960: 86 80 ff ff addcc %g3, -1, %g3
40006964: 12 bf ff fb bne 40006950 <rtems_fdisk_initialize+0x50>
40006968: 80 88 a0 01 btst 1, %g2
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
4000696c: 87 28 60 01 sll %g1, 1, %g3
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
40006970: 82 00 60 01 inc %g1
40006974: 80 a0 61 00 cmp %g1, 0x100
40006978: 12 bf ff f3 bne 40006944 <rtems_fdisk_initialize+0x44>
4000697c: c4 32 00 03 sth %g2, [ %o0 + %g3 ]
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
40006980: 10 80 01 0f b 40006dbc <rtems_fdisk_initialize+0x4bc>
40006984: 2f 10 00 da sethi %hi(0x40036800), %l7
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
40006988: c2 05 60 98 ld [ %l5 + 0x98 ], %g1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
4000698c: f6 2f bf f9 stb %i3, [ %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";
40006990: 05 0b d9 19 sethi %hi(0x2f646400), %g2
40006994: 07 0b d9 99 sethi %hi(0x2f666400), %g3
40006998: 84 10 a1 76 or %g2, 0x176, %g2
4000699c: 86 10 e0 64 or %g3, 0x64, %g3
400069a0: c4 3f bf f0 std %g2, [ %fp + -16 ]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
400069a4: ba 00 40 10 add %g1, %l0, %i5
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
400069a8: f4 20 40 10 st %i2, [ %g1 + %l0 ]
fd->minor = minor;
fd->flags = c->flags;
400069ac: c2 07 20 0c ld [ %i4 + 0xc ], %g1
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
400069b0: e2 07 00 00 ld [ %i4 ], %l1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
400069b4: c2 27 60 08 st %g1, [ %i5 + 8 ]
fd->compact_segs = c->compact_segs;
400069b8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
400069bc: f6 27 60 04 st %i3, [ %i5 + 4 ]
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
400069c0: c2 27 60 0c st %g1, [ %i5 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
400069c4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
400069c8: da 07 20 04 ld [ %i4 + 4 ], %o5
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
400069cc: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
400069d0: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
400069d4: e2 27 60 14 st %l1, [ %i5 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
400069d8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
fd->info_level = c->info_level;
400069dc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
for (device = 0; device < c->device_count; device++)
400069e0: a4 10 20 00 clr %l2
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
400069e4: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
400069e8: b2 10 20 00 clr %i1
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++)
400069ec: 10 80 00 28 b 40006a8c <rtems_fdisk_initialize+0x18c>
400069f0: b0 10 20 00 clr %i0
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
400069f4: a6 10 20 00 clr %l3
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
400069f8: 96 00 40 12 add %g1, %l2, %o3
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++)
400069fc: d8 00 40 12 ld [ %g1 + %l2 ], %o4
40006a00: 86 10 20 00 clr %g3
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
40006a04: 10 80 00 1c b 40006a74 <rtems_fdisk_initialize+0x174>
40006a08: 84 10 20 00 clr %g2
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40006a0c: 92 10 00 11 mov %l1, %o1
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
40006a10: 9e 01 00 13 add %g4, %l3, %o7
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40006a14: d0 03 e0 08 ld [ %o7 + 8 ], %o0
40006a18: c4 3f bf e0 std %g2, [ %fp + -32 ]
40006a1c: d8 3f bf c8 std %o4, [ %fp + -56 ]
40006a20: c8 27 bf dc st %g4, [ %fp + -36 ]
40006a24: 7f ff ef 16 call 4000267c <.udiv>
40006a28: d6 27 bf d4 st %o3, [ %fp + -44 ]
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;
40006a2c: 94 02 3f ff add %o0, -1, %o2
40006a30: 92 10 00 11 mov %l1, %o1
40006a34: d4 27 bf d0 st %o2, [ %fp + -48 ]
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);
40006a38: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
40006a3c: 7f ff ef 10 call 4000267c <.udiv>
40006a40: 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;
40006a44: c8 07 bf dc ld [ %fp + -36 ], %g4
40006a48: d4 1f bf d0 ldd [ %fp + -48 ], %o2
40006a4c: d2 11 00 13 lduh [ %g4 + %l3 ], %o1
40006a50: 90 22 80 08 sub %o2, %o0, %o0
40006a54: 7f ff ee d0 call 40002594 <.umul>
40006a58: d6 27 bf d4 st %o3, [ %fp + -44 ]
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
40006a5c: c4 1f bf e0 ldd [ %fp + -32 ], %g2
40006a60: d8 1f bf c8 ldd [ %fp + -56 ], %o4
40006a64: d6 07 bf d4 ld [ %fp + -44 ], %o3
40006a68: 84 00 80 08 add %g2, %o0, %g2
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
40006a6c: 86 00 e0 01 inc %g3
40006a70: a6 04 e0 0c add %l3, 0xc, %l3
40006a74: 80 a0 c0 0c cmp %g3, %o4
40006a78: 32 bf ff e5 bne,a 40006a0c <rtems_fdisk_initialize+0x10c>
40006a7c: c8 02 e0 04 ld [ %o3 + 4 ], %g4
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
40006a80: b2 06 40 02 add %i1, %g2, %i1
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++)
40006a84: b0 06 20 01 inc %i0
40006a88: a4 04 a0 0c add %l2, 0xc, %l2
40006a8c: 80 a6 00 0d cmp %i0, %o5
40006a90: 32 bf ff d9 bne,a 400069f4 <rtems_fdisk_initialize+0xf4>
40006a94: c2 07 20 08 ld [ %i4 + 8 ], %g1
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
40006a98: 40 00 04 bc call 40007d88 <malloc>
40006a9c: 90 10 00 11 mov %l1, %o0
if (!fd->copy_buffer)
40006aa0: 80 a2 20 00 cmp %o0, 0
40006aa4: 02 80 00 bc be 40006d94 <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40006aa8: d0 27 60 68 st %o0, [ %i5 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
40006aac: 90 10 00 19 mov %i1, %o0
40006ab0: 40 00 02 c1 call 400075b4 <calloc>
40006ab4: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
40006ab8: 80 a2 20 00 cmp %o0, 0
40006abc: 02 80 00 b6 be 40006d94 <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40006ac0: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
40006ac4: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40006ac8: 90 10 00 18 mov %i0, %o0
40006acc: 40 00 02 ba call 400075b4 <calloc>
40006ad0: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
40006ad4: 80 a2 20 00 cmp %o0, 0
40006ad8: 02 80 00 af be 40006d94 <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40006adc: d0 27 60 2c st %o0, [ %i5 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
40006ae0: 90 10 00 14 mov %l4, %o0
40006ae4: 92 10 20 01 mov 1, %o1
40006ae8: 94 10 20 54 mov 0x54, %o2
40006aec: 96 10 20 00 clr %o3
40006af0: 40 00 14 d7 call 4000be4c <rtems_semaphore_create>
40006af4: 98 07 60 64 add %i5, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
40006af8: b0 92 20 00 orcc %o0, 0, %i0
40006afc: 22 80 00 0d be,a 40006b30 <rtems_fdisk_initialize+0x230> <== ALWAYS TAKEN
40006b00: d6 07 60 20 ld [ %i5 + 0x20 ], %o3
{
rtems_fdisk_error ("disk lock create failed");
40006b04: 11 10 00 c9 sethi %hi(0x40032400), %o0 <== NOT EXECUTED
40006b08: 7f ff f7 84 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40006b0c: 90 12 21 88 or %o0, 0x188, %o0 ! 40032588 <__FUNCTION__.6193+0xd80><== NOT EXECUTED
free (fd->copy_buffer);
40006b10: 40 00 03 0d call 40007744 <free> <== NOT EXECUTED
40006b14: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40006b18: 40 00 03 0b call 40007744 <free> <== NOT EXECUTED
40006b1c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40006b20: 40 00 03 09 call 40007744 <free> <== NOT EXECUTED
40006b24: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
40006b28: 81 c7 e0 08 ret <== NOT EXECUTED
40006b2c: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
40006b30: d4 07 00 00 ld [ %i4 ], %o2
40006b34: 86 07 bf f0 add %fp, -16, %g3
40006b38: 90 10 00 1a mov %i2, %o0
40006b3c: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
40006b40: 92 10 00 1b mov %i3, %o1
40006b44: 96 26 40 0b sub %i1, %o3, %o3
40006b48: 19 10 00 15 sethi %hi(0x40005400), %o4
40006b4c: 9a 10 20 00 clr %o5
40006b50: 7f ff f5 63 call 400040dc <rtems_disk_create_phys>
40006b54: 98 13 23 74 or %o4, 0x374, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
40006b58: b0 92 20 00 orcc %o0, 0, %i0
40006b5c: 22 80 00 56 be,a 40006cb4 <rtems_fdisk_initialize+0x3b4> <== ALWAYS TAKEN
40006b60: b2 10 20 00 clr %i1
{
rtems_semaphore_delete (fd->lock);
40006b64: 40 00 15 28 call 4000c004 <rtems_semaphore_delete> <== NOT EXECUTED
40006b68: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
40006b6c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006b70: 7f ff f4 c1 call 40003e74 <rtems_disk_delete> <== NOT EXECUTED
40006b74: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40006b78: 40 00 02 f3 call 40007744 <free> <== NOT EXECUTED
40006b7c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40006b80: 40 00 02 f1 call 40007744 <free> <== NOT EXECUTED
40006b84: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40006b88: 40 00 02 ef call 40007744 <free> <== NOT EXECUTED
40006b8c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
40006b90: 11 10 00 c9 sethi %hi(0x40032400), %o0 <== NOT EXECUTED
40006b94: 7f ff f7 61 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40006b98: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400325a0 <__FUNCTION__.6193+0xd98><== NOT EXECUTED
40006b9c: 81 c7 e0 08 ret <== NOT EXECUTED
40006ba0: 81 e8 00 00 restore <== NOT EXECUTED
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
40006ba4: 84 10 20 00 clr %g2
{
rtems_fdisk_segment_ctl* sc;
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
40006ba8: a4 00 40 19 add %g1, %i1, %l2
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
40006bac: d8 00 40 19 ld [ %g1 + %i1 ], %o4
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
40006bb0: a2 10 20 00 clr %l1
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
40006bb4: 10 80 00 06 b 40006bcc <rtems_fdisk_initialize+0x2cc>
40006bb8: 82 10 20 00 clr %g1
40006bbc: 82 00 60 01 inc %g1
count += dd->segments[segment].count;
40006bc0: c6 10 c0 02 lduh [ %g3 + %g2 ], %g3
40006bc4: 84 00 a0 0c add %g2, 0xc, %g2
40006bc8: a2 04 40 03 add %l1, %g3, %l1
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
40006bcc: 80 a0 40 0c cmp %g1, %o4
40006bd0: 32 bf ff fb bne,a 40006bbc <rtems_fdisk_initialize+0x2bc>
40006bd4: c6 04 a0 04 ld [ %l2 + 4 ], %g3
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
40006bd8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40006bdc: 90 10 00 11 mov %l1, %o0
40006be0: 9a 00 40 19 add %g1, %i1, %o5
40006be4: c2 27 bf ec st %g1, [ %fp + -20 ]
40006be8: d8 3f bf c8 std %o4, [ %fp + -56 ]
40006bec: 40 00 02 72 call 400075b4 <calloc>
40006bf0: 92 10 20 30 mov 0x30, %o1
40006bf4: c2 07 bf ec ld [ %fp + -20 ], %g1
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40006bf8: 80 a2 20 00 cmp %o0, 0
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
40006bfc: d0 20 40 19 st %o0, [ %g1 + %i1 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40006c00: 12 80 00 23 bne 40006c8c <rtems_fdisk_initialize+0x38c> <== ALWAYS TAKEN
40006c04: d8 1f bf c8 ldd [ %fp + -56 ], %o4
{
rtems_disk_delete (dev);
40006c08: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006c0c: 7f ff f4 9a call 40003e74 <rtems_disk_delete> <== NOT EXECUTED
40006c10: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40006c14: 40 00 14 fc call 4000c004 <rtems_semaphore_delete> <== NOT EXECUTED
40006c18: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40006c1c: 40 00 02 ca call 40007744 <free> <== NOT EXECUTED
40006c20: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40006c24: 40 00 02 c8 call 40007744 <free> <== NOT EXECUTED
40006c28: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40006c2c: 40 00 02 c6 call 40007744 <free> <== NOT EXECUTED
40006c30: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
40006c34: 81 c7 e0 08 ret <== NOT EXECUTED
40006c38: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40006c3c: 86 10 20 00 clr %g3
for (segment = 0; segment < c->devices[device].segment_count; segment++)
{
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
40006c40: 96 00 40 02 add %g1, %g2, %o3
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40006c44: de 10 40 02 lduh [ %g1 + %g2 ], %o7
40006c48: 10 80 00 07 b 40006c64 <rtems_fdisk_initialize+0x364>
40006c4c: 82 10 00 08 mov %o0, %g1
{
sc->descriptor = sd;
40006c50: d6 20 60 04 st %o3, [ %g1 + 4 ]
sc->device = device;
40006c54: f0 20 60 08 st %i0, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
40006c58: 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++)
40006c5c: 86 00 e0 01 inc %g3
40006c60: 82 00 60 30 add %g1, 0x30, %g1
40006c64: 80 a0 c0 0f cmp %g3, %o7
40006c68: 2a bf ff fa bcs,a 40006c50 <rtems_fdisk_initialize+0x350>
40006c6c: c6 20 60 0c st %g3, [ %g1 + 0xc ]
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
40006c70: 83 2b e0 04 sll %o7, 4, %g1
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
40006c74: 88 01 20 01 inc %g4
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
40006c78: 9f 2b e0 06 sll %o7, 6, %o7
40006c7c: 84 00 a0 0c add %g2, 0xc, %g2
40006c80: 9e 23 c0 01 sub %o7, %g1, %o7
40006c84: 10 80 00 04 b 40006c94 <rtems_fdisk_initialize+0x394>
40006c88: 90 02 00 0f add %o0, %o7, %o0
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40006c8c: 84 10 20 00 clr %g2
40006c90: 88 10 20 00 clr %g4
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
40006c94: 80 a1 00 0c cmp %g4, %o4
40006c98: 32 bf ff e9 bne,a 40006c3c <rtems_fdisk_initialize+0x33c>
40006c9c: c2 04 a0 04 ld [ %l2 + 4 ], %g1
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
40006ca0: e2 23 60 04 st %l1, [ %o5 + 4 ]
fd->devices[device].descriptor = &c->devices[device];
40006ca4: e4 23 60 08 st %l2, [ %o5 + 8 ]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
40006ca8: b0 06 20 01 inc %i0
40006cac: 10 80 00 03 b 40006cb8 <rtems_fdisk_initialize+0x3b8>
40006cb0: b2 06 60 0c add %i1, 0xc, %i1
}
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
40006cb4: b0 10 20 00 clr %i0
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
40006cb8: c2 07 20 04 ld [ %i4 + 4 ], %g1
40006cbc: 80 a6 00 01 cmp %i0, %g1
40006cc0: 2a bf ff b9 bcs,a 40006ba4 <rtems_fdisk_initialize+0x2a4>
40006cc4: c2 07 20 08 ld [ %i4 + 8 ], %g1
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
40006cc8: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
40006ccc: 7f ff f8 47 call 40004de8 <rtems_fdisk_recover_block_mappings>
40006cd0: 90 10 00 1d mov %i5, %o0
if (ret)
40006cd4: b0 92 20 00 orcc %o0, 0, %i0
40006cd8: 22 80 00 13 be,a 40006d24 <rtems_fdisk_initialize+0x424> <== ALWAYS TAKEN
40006cdc: 90 10 00 1d mov %i5, %o0
{
rtems_disk_delete (dev);
40006ce0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006ce4: 7f ff f4 64 call 40003e74 <rtems_disk_delete> <== NOT EXECUTED
40006ce8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40006cec: 40 00 14 c6 call 4000c004 <rtems_semaphore_delete> <== NOT EXECUTED
40006cf0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40006cf4: 40 00 02 94 call 40007744 <free> <== NOT EXECUTED
40006cf8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40006cfc: 40 00 02 92 call 40007744 <free> <== NOT EXECUTED
40006d00: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40006d04: 40 00 02 90 call 40007744 <free> <== NOT EXECUTED
40006d08: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
40006d0c: 40 00 6e d3 call 40022858 <strerror> <== NOT EXECUTED
40006d10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006d14: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40006d18: 11 10 00 c9 sethi %hi(0x40032400), %o0 <== NOT EXECUTED
40006d1c: 10 80 00 17 b 40006d78 <rtems_fdisk_initialize+0x478> <== NOT EXECUTED
40006d20: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400325b8 <__FUNCTION__.6193+0xdb0><== NOT EXECUTED
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
40006d24: 7f ff fa 06 call 4000553c <rtems_fdisk_compact>
40006d28: a0 04 20 74 add %l0, 0x74, %l0
if (ret)
40006d2c: 80 a2 20 00 cmp %o0, 0
40006d30: 02 80 00 16 be 40006d88 <rtems_fdisk_initialize+0x488> <== ALWAYS TAKEN
40006d34: b0 10 00 08 mov %o0, %i0
{
rtems_disk_delete (dev);
40006d38: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006d3c: 7f ff f4 4e call 40003e74 <rtems_disk_delete> <== NOT EXECUTED
40006d40: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40006d44: 40 00 14 b0 call 4000c004 <rtems_semaphore_delete> <== NOT EXECUTED
40006d48: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40006d4c: 40 00 02 7e call 40007744 <free> <== NOT EXECUTED
40006d50: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40006d54: 40 00 02 7c call 40007744 <free> <== NOT EXECUTED
40006d58: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40006d5c: 40 00 02 7a call 40007744 <free> <== NOT EXECUTED
40006d60: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
40006d64: 40 00 6e bd call 40022858 <strerror> <== NOT EXECUTED
40006d68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006d6c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40006d70: 11 10 00 c9 sethi %hi(0x40032400), %o0 <== NOT EXECUTED
40006d74: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400325e0 <__FUNCTION__.6193+0xdd8><== NOT EXECUTED
40006d78: 7f ff f6 e8 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40006d7c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40006d80: 81 c7 e0 08 ret <== NOT EXECUTED
40006d84: 81 e8 00 00 restore <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
40006d88: b6 06 e0 01 inc %i3
40006d8c: 10 80 00 04 b 40006d9c <rtems_fdisk_initialize+0x49c>
40006d90: b8 07 20 20 add %i4, 0x20, %i4
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
40006d94: 81 c7 e0 08 ret <== NOT EXECUTED
40006d98: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
40006d9c: c2 05 e1 7c ld [ %l7 + 0x17c ], %g1
40006da0: 80 a6 c0 01 cmp %i3, %g1
40006da4: 2a bf fe f9 bcs,a 40006988 <rtems_fdisk_initialize+0x88>
40006da8: ec 37 bf f8 sth %l6, [ %fp + -8 ]
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
40006dac: 05 10 01 1c sethi %hi(0x40047000), %g2
40006db0: c2 20 a0 9c st %g1, [ %g2 + 0x9c ] ! 4004709c <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
40006db4: 81 c7 e0 08 ret
40006db8: 91 e8 20 00 restore %g0, 0, %o0
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
40006dbc: d0 05 e1 7c ld [ %l7 + 0x17c ], %o0
40006dc0: 92 10 20 74 mov 0x74, %o1
40006dc4: 40 00 01 fc call 400075b4 <calloc>
40006dc8: 2b 10 01 1c sethi %hi(0x40047000), %l5
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
40006dcc: 80 a2 20 00 cmp %o0, 0
40006dd0: 02 bf ff f1 be 40006d94 <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40006dd4: d0 25 60 98 st %o0, [ %l5 + 0x98 ]
40006dd8: 39 10 00 c4 sethi %hi(0x40031000), %i4
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
40006ddc: 2d 00 00 18 sethi %hi(0x6000), %l6
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
40006de0: 29 11 91 14 sethi %hi(0x46445000), %l4
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
40006de4: a0 10 20 00 clr %l0
40006de8: b8 17 22 90 or %i4, 0x290, %i4
40006dec: b6 10 20 00 clr %i3
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
40006df0: ac 15 a1 00 or %l6, 0x100, %l6
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
40006df4: 10 bf ff ea b 40006d9c <rtems_fdisk_initialize+0x49c>
40006df8: a8 15 23 4b or %l4, 0x34b, %l4
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
40006dfc: 81 c7 e0 08 ret <== NOT EXECUTED
40006e00: 81 e8 00 00 restore <== NOT EXECUTED
40005774 <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)
{
40005774: 9d e3 bf 40 save %sp, -192, %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;
40005778: 40 00 6a 73 call 40020144 <__errno>
4000577c: f8 06 20 04 ld [ %i0 + 4 ], %i4
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40005780: 83 2f 20 02 sll %i4, 2, %g1
40005784: b7 2f 20 05 sll %i4, 5, %i3
40005788: 3b 10 01 1c sethi %hi(0x40047000), %i5
4000578c: b6 26 c0 01 sub %i3, %g1, %i3
40005790: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
40005794: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40005798: b6 06 c0 1c add %i3, %i4, %i3
4000579c: b7 2e e0 02 sll %i3, 2, %i3
400057a0: 82 00 40 1b add %g1, %i3, %g1
400057a4: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
400057a8: 92 10 20 00 clr %o1
400057ac: 40 00 1a 45 call 4000c0c0 <rtems_semaphore_obtain>
400057b0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
400057b4: 80 a2 20 00 cmp %o0, 0
400057b8: 12 80 04 41 bne 400068bc <rtems_fdisk_ioctl+0x1148> <== NEVER TAKEN
400057bc: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
400057c0: 40 00 6a 61 call 40020144 <__errno>
400057c4: 01 00 00 00 nop
switch (req)
400057c8: 03 08 00 10 sethi %hi(0x20004000), %g1
400057cc: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_SIZE+0x1fc04283>
400057d0: 80 a6 40 02 cmp %i1, %g2
400057d4: 02 80 02 ce be 4000630c <rtems_fdisk_ioctl+0xb98> <== NEVER TAKEN
400057d8: c0 22 00 00 clr [ %o0 ]
400057dc: 80 a6 40 02 cmp %i1, %g2
400057e0: 38 80 00 0c bgu,a 40005810 <rtems_fdisk_ioctl+0x9c>
400057e4: 82 10 62 85 or %g1, 0x285, %g1
400057e8: 84 10 62 81 or %g1, 0x281, %g2
400057ec: 80 a6 40 02 cmp %i1, %g2
400057f0: 02 80 02 a9 be 40006294 <rtems_fdisk_ioctl+0xb20> <== NEVER TAKEN
400057f4: 01 00 00 00 nop
400057f8: 18 80 02 af bgu 400062b4 <rtems_fdisk_ioctl+0xb40> <== NEVER TAKEN
400057fc: 82 10 62 80 or %g1, 0x280, %g1
40005800: 80 a6 40 01 cmp %i1, %g1
40005804: 32 80 04 23 bne,a 40006890 <rtems_fdisk_ioctl+0x111c> <== ALWAYS TAKEN
40005808: 90 10 00 18 mov %i0, %o0
4000580c: 30 80 02 66 b,a 400061a4 <rtems_fdisk_ioctl+0xa30> <== NOT EXECUTED
40005810: 80 a6 40 01 cmp %i1, %g1
40005814: 02 80 03 1e be 4000648c <rtems_fdisk_ioctl+0xd18>
40005818: 01 00 00 00 nop
4000581c: 0a 80 03 19 bcs 40006480 <rtems_fdisk_ioctl+0xd0c> <== NEVER TAKEN
40005820: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40005824: 03 30 06 10 sethi %hi(0xc0184000), %g1
40005828: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000582c: 80 a6 40 01 cmp %i1, %g1
40005830: 12 80 04 18 bne 40006890 <rtems_fdisk_ioctl+0x111c>
40005834: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40005838: 03 10 01 1c sethi %hi(0x40047000), %g1
4000583c: c2 00 60 9c ld [ %g1 + 0x9c ], %g1 ! 4004709c <rtems_flashdisk_count>
40005840: 80 a7 00 01 cmp %i4, %g1
40005844: 1a 80 00 08 bcc 40005864 <rtems_fdisk_ioctl+0xf0> <== NEVER TAKEN
40005848: 01 00 00 00 nop
(rtems_flashdisks[minor].device_count == 0))
4000584c: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40005850: 82 00 40 1b add %g1, %i3, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40005854: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
40005858: 80 a0 60 00 cmp %g1, 0
4000585c: 32 80 00 06 bne,a 40005874 <rtems_fdisk_ioctl+0x100> <== ALWAYS TAKEN
40005860: c2 06 80 00 ld [ %i2 ], %g1
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
40005864: 40 00 6a 38 call 40020144 <__errno> <== NOT EXECUTED
40005868: 01 00 00 00 nop <== NOT EXECUTED
4000586c: 10 80 02 4c b 4000619c <rtems_fdisk_ioctl+0xa28> <== NOT EXECUTED
40005870: 82 10 20 13 mov 0x13, %g1 ! 13 <PROM_START+0x13> <== NOT EXECUTED
}
else
{
switch (r->req)
40005874: 80 a0 60 00 cmp %g1, 0
40005878: 02 80 00 05 be 4000588c <rtems_fdisk_ioctl+0x118>
4000587c: 80 a0 60 01 cmp %g1, 1
40005880: 12 80 02 44 bne 40006190 <rtems_fdisk_ioctl+0xa1c> <== NEVER TAKEN
40005884: 01 00 00 00 nop
40005888: 30 80 00 b4 b,a 40005b58 <rtems_fdisk_ioctl+0x3e4>
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
4000588c: 40 00 6a 2e call 40020144 <__errno>
40005890: b0 06 a0 18 add %i2, 0x18, %i0
40005894: f8 07 60 98 ld [ %i5 + 0x98 ], %i4
40005898: d0 27 bf ec st %o0, [ %fp + -20 ]
4000589c: b8 07 00 1b add %i4, %i3, %i4
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
400058a0: 10 80 00 a2 b 40005b28 <rtems_fdisk_ioctl+0x3b4>
400058a4: a4 10 20 00 clr %l2
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
400058a8: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
400058ac: 7f ff f3 74 call 4000267c <.udiv>
400058b0: a2 10 20 00 clr %l1
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
400058b4: 2d 10 00 c6 sethi %hi(0x40031800), %l6
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
400058b8: d0 27 bf e8 st %o0, [ %fp + -24 ]
data = sg->buffer;
400058bc: e0 06 20 08 ld [ %i0 + 8 ], %l0
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
400058c0: 10 80 00 91 b 40005b04 <rtems_fdisk_ioctl+0x390>
400058c4: 2f 10 00 c6 sethi %hi(0x40031800), %l7
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
400058c8: 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);
400058cc: b2 04 40 19 add %l1, %i1, %i1
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
400058d0: 13 10 00 c7 sethi %hi(0x40031c00), %o1
400058d4: 94 10 00 19 mov %i1, %o2
400058d8: 7f ff fb b0 call 40004798 <rtems_fdisk_info>
400058dc: 92 12 63 68 or %o1, 0x368, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
400058e0: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
400058e4: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
400058e8: 82 20 80 01 sub %g2, %g1, %g1
400058ec: 80 a6 40 01 cmp %i1, %g1
400058f0: 2a 80 00 08 bcs,a 40005910 <rtems_fdisk_ioctl+0x19c> <== ALWAYS TAKEN
400058f4: c6 07 20 18 ld [ %i4 + 0x18 ], %g3
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
400058f8: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
400058fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005900: 7f ff fc 06 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005904: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40005908: 10 80 00 84 b 40005b18 <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
4000590c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
40005910: 83 2e 60 03 sll %i1, 3, %g1
if (!bc->segment)
40005914: fa 00 c0 01 ld [ %g3 + %g1 ], %i5
40005918: 80 a7 60 00 cmp %i5, 0
4000591c: 12 80 00 0d bne 40005950 <rtems_fdisk_ioctl+0x1dc>
40005920: aa 00 c0 01 add %g3, %g1, %l5
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
40005924: 94 10 00 19 mov %i1, %o2
40005928: 90 10 00 1c mov %i4, %o0
4000592c: 13 10 00 c7 sethi %hi(0x40031c00), %o1
40005930: 7f ff fb 9a call 40004798 <rtems_fdisk_info>
40005934: 92 12 63 a0 or %o1, 0x3a0, %o1 ! 40031fa0 <__FUNCTION__.6193+0x798>
#endif
memset (buffer, 0xff, fd->block_size);
40005938: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
4000593c: 90 10 00 10 mov %l0, %o0
40005940: 40 00 6e dc call 400214b0 <memset>
40005944: 92 10 20 ff mov 0xff, %o1
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40005948: 10 80 03 e9 b 400068ec <rtems_fdisk_ioctl+0x1178>
4000594c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
40005950: da 05 60 04 ld [ %l5 + 4 ], %o5
40005954: e8 07 60 10 ld [ %i5 + 0x10 ], %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40005958: c8 07 40 00 ld [ %i5 ], %g4
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
4000595c: a7 2b 60 03 sll %o5, 3, %l3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40005960: 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];
40005964: 86 05 00 13 add %l4, %l3, %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40005968: d8 07 60 0c ld [ %i5 + 0xc ], %o4
4000596c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
40005970: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
40005974: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
40005978: 80 a1 20 00 cmp %g4, 0
4000597c: 02 80 00 04 be 4000598c <rtems_fdisk_ioctl+0x218>
40005980: de 07 60 24 ld [ %i5 + 0x24 ], %o7
40005984: 10 80 00 03 b 40005990 <rtems_fdisk_ioctl+0x21c>
40005988: 88 15 e3 00 or %l7, 0x300, %g4
4000598c: 88 15 a3 08 or %l6, 0x308, %g4
40005990: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
40005994: d2 23 a0 60 st %o1, [ %sp + 0x60 ]
40005998: d4 23 a0 64 st %o2, [ %sp + 0x64 ]
4000599c: de 23 a0 68 st %o7, [ %sp + 0x68 ]
400059a0: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
400059a4: c8 10 e0 02 lduh [ %g3 + 2 ], %g4
400059a8: 90 10 00 1c mov %i4, %o0
400059ac: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
400059b0: c8 15 00 13 lduh [ %l4 + %l3 ], %g4
400059b4: 13 10 00 c7 sethi %hi(0x40031c00), %o1
400059b8: c8 23 a0 74 st %g4, [ %sp + 0x74 ]
400059bc: c8 00 e0 04 ld [ %g3 + 4 ], %g4
400059c0: 92 12 63 c8 or %o1, 0x3c8, %o1
400059c4: c6 27 bf d4 st %g3, [ %fp + -44 ]
400059c8: c8 23 a0 78 st %g4, [ %sp + 0x78 ]
400059cc: 7f ff fb 73 call 40004798 <rtems_fdisk_info>
400059d0: 94 10 00 19 mov %i1, %o2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
400059d4: c6 07 bf d4 ld [ %fp + -44 ], %g3
400059d8: c6 10 e0 02 lduh [ %g3 + 2 ], %g3
sc->pages, sc->pages_active, sc->pages_used, sc->pages_bad,
sc->next ? "set" : "null",
pd->flags, pd->crc, pd->block);
#endif
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
400059dc: 80 88 e0 01 btst 1, %g3
400059e0: 12 80 00 41 bne 40005ae4 <rtems_fdisk_ioctl+0x370> <== NEVER TAKEN
400059e4: d8 05 60 04 ld [ %l5 + 4 ], %o4
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
400059e8: 80 88 e0 02 btst 2, %g3
400059ec: 02 80 00 3c be 40005adc <rtems_fdisk_ioctl+0x368> <== NEVER TAKEN
400059f0: 11 10 00 c8 sethi %hi(0x40032000), %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);
400059f4: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
400059f8: 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,
400059fc: 92 10 00 03 mov %g3, %o1
40005a00: 90 02 00 0c add %o0, %o4, %o0
40005a04: 7f ff f2 e4 call 40002594 <.umul>
40005a08: c6 27 bf d4 st %g3, [ %fp + -44 ]
40005a0c: c6 07 bf d4 ld [ %fp + -44 ], %g3
40005a10: 94 10 00 08 mov %o0, %o2
40005a14: 98 10 00 03 mov %g3, %o4
40005a18: 90 10 00 1c mov %i4, %o0
40005a1c: 92 10 00 1d mov %i5, %o1
40005a20: 7f ff fc 78 call 40004c00 <rtems_fdisk_seg_read>
40005a24: 96 10 00 10 mov %l0, %o3
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
40005a28: 86 92 20 00 orcc %o0, 0, %g3
40005a2c: 22 80 00 13 be,a 40005a78 <rtems_fdisk_ioctl+0x304> <== ALWAYS TAKEN
40005a30: 03 10 01 1c sethi %hi(0x40047000), %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40005a34: e0 07 60 08 ld [ %i5 + 8 ], %l0 <== NOT EXECUTED
40005a38: f2 07 60 0c ld [ %i5 + 0xc ], %i1 <== NOT EXECUTED
40005a3c: fa 05 60 04 ld [ %l5 + 4 ], %i5 <== NOT EXECUTED
40005a40: 40 00 73 86 call 40022858 <strerror> <== NOT EXECUTED
40005a44: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED
40005a48: c6 07 bf d4 ld [ %fp + -44 ], %g3 <== NOT EXECUTED
40005a4c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40005a50: c6 23 a0 5c st %g3, [ %sp + 0x5c ] <== NOT EXECUTED
40005a54: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40005a58: 13 10 00 c8 sethi %hi(0x40032000), %o1 <== NOT EXECUTED
40005a5c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40005a60: 92 12 60 10 or %o1, 0x10, %o1 <== NOT EXECUTED
40005a64: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
40005a68: 7f ff fb 4c call 40004798 <rtems_fdisk_info> <== NOT EXECUTED
40005a6c: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40005a70: 10 80 00 2a b 40005b18 <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
40005a74: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
40005a78: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40005a7c: c8 00 60 a0 ld [ %g1 + 0xa0 ], %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
40005a80: 84 10 20 00 clr %g2
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
40005a84: 10 80 00 09 b 40005aa8 <rtems_fdisk_ioctl+0x334>
40005a88: 94 10 3f ff mov -1, %o2
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40005a8c: fa 0c 00 02 ldub [ %l0 + %g2 ], %i5
40005a90: 95 32 a0 10 srl %o2, 0x10, %o2
40005a94: 94 1f 40 0a xor %i5, %o2, %o2
40005a98: 94 0a a0 ff and %o2, 0xff, %o2
40005a9c: 95 2a a0 01 sll %o2, 1, %o2
40005aa0: d4 11 00 0a lduh [ %g4 + %o2 ], %o2
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
40005aa4: 84 00 a0 01 inc %g2
40005aa8: 80 a0 80 03 cmp %g2, %g3
40005aac: 12 bf ff f8 bne 40005a8c <rtems_fdisk_ioctl+0x318>
40005ab0: 95 2a a0 10 sll %o2, 0x10, %o2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
40005ab4: d6 15 00 13 lduh [ %l4 + %l3 ], %o3
40005ab8: 95 32 a0 10 srl %o2, 0x10, %o2
40005abc: 80 a2 80 0b cmp %o2, %o3
40005ac0: 02 80 03 8a be 400068e8 <rtems_fdisk_ioctl+0x1174> <== ALWAYS TAKEN
40005ac4: 11 10 00 c8 sethi %hi(0x40032000), %o0
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
40005ac8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005acc: 7f ff fb 93 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005ad0: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40005ad4: 10 80 00 11 b 40005b18 <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
40005ad8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
block, cs, pd->crc);
}
else
{
rtems_fdisk_error ("read-block: block points to used page: %d: %d-%d-%d",
40005adc: 10 80 00 04 b 40005aec <rtems_fdisk_ioctl+0x378> <== NOT EXECUTED
40005ae0: 90 12 20 80 or %o0, 0x80, %o0 <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
40005ae4: 11 10 00 c8 sethi %hi(0x40032000), %o0 <== NOT EXECUTED
40005ae8: 90 12 20 b8 or %o0, 0xb8, %o0 ! 400320b8 <__FUNCTION__.6193+0x8b0><== NOT EXECUTED
40005aec: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
40005af0: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
40005af4: 7f ff fb 89 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005af8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40005afc: 10 80 03 7f b 400068f8 <rtems_fdisk_ioctl+0x1184> <== NOT EXECUTED
40005b00: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40005b04: c4 07 bf e8 ld [ %fp + -24 ], %g2
40005b08: 80 a4 40 02 cmp %l1, %g2
40005b0c: 32 bf ff 6f bne,a 400058c8 <rtems_fdisk_ioctl+0x154>
40005b10: f2 06 00 00 ld [ %i0 ], %i1
40005b14: 82 10 20 00 clr %g1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40005b18: a4 04 a0 01 inc %l2
40005b1c: 80 a0 60 00 cmp %g1, 0
40005b20: 12 80 00 08 bne 40005b40 <rtems_fdisk_ioctl+0x3cc> <== NEVER TAKEN
40005b24: b0 06 20 10 add %i0, 0x10, %i0
40005b28: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40005b2c: 80 a4 80 01 cmp %l2, %g1
40005b30: 2a bf ff 5e bcs,a 400058a8 <rtems_fdisk_ioctl+0x134>
40005b34: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40005b38: 10 80 00 03 b 40005b44 <rtems_fdisk_ioctl+0x3d0>
40005b3c: 92 10 20 00 clr %o1
40005b40: 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);
40005b44: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40005b48: 9f c0 40 00 call %g1
40005b4c: 90 10 00 1a mov %i2, %o0
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
40005b50: 10 80 01 8e b 40006188 <rtems_fdisk_ioctl+0xa14>
40005b54: c2 07 bf ec ld [ %fp + -20 ], %g1
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40005b58: 40 00 69 7b call 40020144 <__errno>
40005b5c: a0 06 a0 18 add %i2, 0x18, %l0
40005b60: 03 10 01 1c sethi %hi(0x40047000), %g1
40005b64: fa 00 60 98 ld [ %g1 + 0x98 ], %i5 ! 40047098 <rtems_flashdisks>
40005b68: d0 27 bf e8 st %o0, [ %fp + -24 ]
40005b6c: ba 07 40 1b add %i5, %i3, %i5
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40005b70: 10 80 01 7a b 40006158 <rtems_fdisk_ioctl+0x9e4>
40005b74: c0 27 bf ec clr [ %fp + -20 ]
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40005b78: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
40005b7c: 7f ff f2 c0 call 4000267c <.udiv>
40005b80: a4 10 20 00 clr %l2
data = sg->buffer;
40005b84: e2 04 20 08 ld [ %l0 + 8 ], %l1
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40005b88: 10 80 01 69 b 4000612c <rtems_fdisk_ioctl+0x9b8>
40005b8c: d0 27 bf e4 st %o0, [ %fp + -28 ]
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
40005b90: 90 10 00 1d mov %i5, %o0
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
40005b94: b2 04 80 19 add %l2, %i1, %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
40005b98: 13 10 00 c8 sethi %hi(0x40032000), %o1
40005b9c: 94 10 00 19 mov %i1, %o2
40005ba0: 7f ff fa fe call 40004798 <rtems_fdisk_info>
40005ba4: 92 12 60 e8 or %o1, 0xe8, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40005ba8: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
40005bac: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40005bb0: 82 20 80 01 sub %g2, %g1, %g1
40005bb4: 80 a6 40 01 cmp %i1, %g1
40005bb8: 2a 80 00 08 bcs,a 40005bd8 <rtems_fdisk_ioctl+0x464> <== ALWAYS TAKEN
40005bbc: ec 07 60 18 ld [ %i5 + 0x18 ], %l6
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
40005bc0: 11 10 00 c8 sethi %hi(0x40032000), %o0 <== NOT EXECUTED
40005bc4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005bc8: 7f ff fb 54 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005bcc: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
rtems_fdisk_queue_segment (fd, sc);
return EIO;
40005bd0: 10 80 01 5c b 40006140 <rtems_fdisk_ioctl+0x9cc> <== NOT EXECUTED
40005bd4: b2 10 20 05 mov 5, %i1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
40005bd8: ab 2e 60 03 sll %i1, 3, %l5
/*
* Does the page exist in flash ?
*/
if (bc->segment)
40005bdc: f8 05 80 15 ld [ %l6 + %l5 ], %i4
40005be0: 80 a7 20 00 cmp %i4, 0
40005be4: 02 80 00 95 be 40005e38 <rtems_fdisk_ioctl+0x6c4>
40005be8: b0 05 80 15 add %l6, %l5, %i0
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
40005bec: c2 06 20 04 ld [ %i0 + 4 ], %g1
40005bf0: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
40005bf4: d4 07 20 08 ld [ %i4 + 8 ], %o2
40005bf8: d6 07 20 0c ld [ %i4 + 0xc ], %o3
40005bfc: 98 10 00 01 mov %g1, %o4
40005c00: c2 27 bf dc st %g1, [ %fp + -36 ]
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
40005c04: c4 27 bf e0 st %g2, [ %fp + -32 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
40005c08: 90 10 00 1d mov %i5, %o0
40005c0c: 13 10 00 c8 sethi %hi(0x40032000), %o1
40005c10: 7f ff fa e2 call 40004798 <rtems_fdisk_info>
40005c14: 92 12 61 20 or %o1, 0x120, %o1 ! 40032120 <__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,
40005c18: c4 06 20 04 ld [ %i0 + 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);
40005c1c: ee 07 60 14 ld [ %i5 + 0x14 ], %l7
#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,
40005c20: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
40005c24: e8 07 20 08 ld [ %i4 + 8 ], %l4
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
40005c28: 90 02 00 02 add %o0, %g2, %o0
40005c2c: 7f ff f2 5a call 40002594 <.umul>
40005c30: 92 10 00 17 mov %l7, %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;
40005c34: 89 2d 20 04 sll %l4, 4, %g4
40005c38: 87 2d 20 02 sll %l4, 2, %g3
40005c3c: 86 21 00 03 sub %g4, %g3, %g3
40005c40: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
40005c44: e6 07 20 0c ld [ %i4 + 0xc ], %l3
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005c48: 9e 01 00 03 add %g4, %g3, %o7
40005c4c: c8 01 00 03 ld [ %g4 + %g3 ], %g4
40005c50: 9b 2c e0 06 sll %l3, 6, %o5
40005c54: 87 2c e0 04 sll %l3, 4, %g3
40005c58: 86 23 40 03 sub %o5, %g3, %g3
40005c5c: 86 01 00 03 add %g4, %g3, %g3
40005c60: c8 00 e0 04 ld [ %g3 + 4 ], %g4
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
40005c64: c6 03 e0 08 ld [ %o7 + 8 ], %g3
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
40005c68: 84 10 00 08 mov %o0, %g2
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
40005c6c: c6 00 e0 08 ld [ %g3 + 8 ], %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
40005c70: 94 10 00 14 mov %l4, %o2
40005c74: 98 10 00 02 mov %g2, %o4
40005c78: c4 3f bf d0 std %g2, [ %fp + -48 ]
40005c7c: 96 10 00 13 mov %l3, %o3
40005c80: 9a 10 00 17 mov %l7, %o5
40005c84: c8 27 bf cc st %g4, [ %fp + -52 ]
40005c88: 90 10 00 1d mov %i5, %o0
40005c8c: 13 10 00 c8 sethi %hi(0x40032000), %o1
40005c90: 7f ff fa e2 call 40004818 <rtems_fdisk_printf>
40005c94: 92 12 61 48 or %o1, 0x148, %o1 ! 40032148 <__FUNCTION__.6193+0x940>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
40005c98: c6 07 bf d4 ld [ %fp + -44 ], %g3
40005c9c: c8 07 bf cc ld [ %fp + -52 ], %g4
40005ca0: c4 07 bf d0 ld [ %fp + -48 ], %g2
40005ca4: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
40005ca8: 92 10 00 14 mov %l4, %o1
40005cac: 90 10 00 04 mov %g4, %o0
40005cb0: 94 10 00 13 mov %l3, %o2
40005cb4: 96 10 00 02 mov %g2, %o3
40005cb8: 98 10 00 11 mov %l1, %o4
40005cbc: 9f c0 c0 00 call %g3
40005cc0: 9a 10 00 17 mov %l7, %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,
40005cc4: c2 07 bf dc ld [ %fp + -36 ], %g1
40005cc8: 80 a2 20 00 cmp %o0, 0
40005ccc: 12 80 00 0c bne 40005cfc <rtems_fdisk_ioctl+0x588>
40005cd0: e8 06 20 04 ld [ %i0 + 4 ], %l4
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
40005cd4: d6 07 20 08 ld [ %i4 + 8 ], %o3
40005cd8: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40005cdc: 90 10 00 1d mov %i5, %o0
40005ce0: 13 10 00 c8 sethi %hi(0x40032000), %o1
40005ce4: 94 10 00 19 mov %i1, %o2
40005ce8: 92 12 61 70 or %o1, 0x170, %o1
40005cec: 7f ff fa ab call 40004798 <rtems_fdisk_info>
40005cf0: 9a 10 00 14 mov %l4, %o5
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40005cf4: 10 80 01 0c b 40006124 <rtems_fdisk_ioctl+0x9b0>
40005cf8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
40005cfc: c4 07 bf e0 ld [ %fp + -32 ], %g2
40005d00: 83 28 60 03 sll %g1, 3, %g1
40005d04: ae 00 80 01 add %g2, %g1, %l7
* 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;
40005d08: c2 15 e0 02 lduh [ %l7 + 2 ], %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))
40005d0c: 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;
40005d10: 82 08 7f fd and %g1, -3, %g1
40005d14: c2 35 e0 02 sth %g1, [ %l7 + 2 ]
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
40005d18: 80 88 a0 08 btst 8, %g2
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)) +
40005d1c: 83 2d 20 03 sll %l4, 3, %g1
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
40005d20: 02 80 00 1e be 40005d98 <rtems_fdisk_ioctl+0x624> <== NEVER TAKEN
40005d24: 82 00 60 02 add %g1, 2, %g1
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
40005d28: 94 10 00 01 mov %g1, %o2
40005d2c: c2 27 bf dc st %g1, [ %fp + -36 ]
40005d30: 90 10 00 1d mov %i5, %o0
40005d34: 92 10 00 1c mov %i4, %o1
40005d38: 96 07 bf f6 add %fp, -10, %o3
40005d3c: 7f ff fb b1 call 40004c00 <rtems_fdisk_seg_read>
40005d40: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
40005d44: a6 92 20 00 orcc %o0, 0, %l3
40005d48: 12 80 00 1d bne 40005dbc <rtems_fdisk_ioctl+0x648> <== NEVER TAKEN
40005d4c: c2 07 bf dc ld [ %fp + -36 ], %g1
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
40005d50: c4 15 e0 02 lduh [ %l7 + 2 ], %g2
40005d54: d8 17 bf f6 lduh [ %fp + -10 ], %o4
40005d58: 86 08 80 0c and %g2, %o4, %g3
40005d5c: 85 28 a0 10 sll %g2, 0x10, %g2
40005d60: 87 28 e0 10 sll %g3, 0x10, %g3
40005d64: 80 a0 c0 02 cmp %g3, %g2
40005d68: 02 80 00 0c be 40005d98 <rtems_fdisk_ioctl+0x624> <== ALWAYS TAKEN
40005d6c: 9b 30 a0 10 srl %g2, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
40005d70: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
40005d74: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
40005d78: 99 2b 20 10 sll %o4, 0x10, %o4 <== NOT EXECUTED
40005d7c: 11 10 00 c8 sethi %hi(0x40032000), %o0 <== NOT EXECUTED
40005d80: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
40005d84: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
40005d88: 7f ff fa e4 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005d8c: 90 12 21 a0 or %o0, 0x1a0, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40005d90: 10 80 00 1c b 40005e00 <rtems_fdisk_ioctl+0x68c> <== NOT EXECUTED
40005d94: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
40005d98: 90 10 00 1d mov %i5, %o0
40005d9c: 92 10 00 1c mov %i4, %o1
40005da0: 94 10 00 01 mov %g1, %o2
40005da4: 96 05 e0 02 add %l7, 2, %o3
40005da8: 7f ff fb d9 call 40004d0c <rtems_fdisk_seg_write>
40005dac: 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)
40005db0: a6 92 20 00 orcc %o0, 0, %l3
40005db4: 22 80 00 13 be,a 40005e00 <rtems_fdisk_ioctl+0x68c> <== ALWAYS TAKEN
40005db8: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
40005dbc: d4 07 20 08 ld [ %i4 + 8 ], %o2 <== NOT EXECUTED
40005dc0: ee 07 20 0c ld [ %i4 + 0xc ], %l7 <== NOT EXECUTED
40005dc4: e8 06 20 04 ld [ %i0 + 4 ], %l4 <== NOT EXECUTED
40005dc8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40005dcc: 40 00 72 a3 call 40022858 <strerror> <== NOT EXECUTED
40005dd0: d4 27 bf c8 st %o2, [ %fp + -56 ] <== NOT EXECUTED
40005dd4: d4 07 bf c8 ld [ %fp + -56 ], %o2 <== NOT EXECUTED
40005dd8: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40005ddc: e6 23 a0 5c st %l3, [ %sp + 0x5c ] <== NOT EXECUTED
40005de0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005de4: 13 10 00 c8 sethi %hi(0x40032000), %o1 <== NOT EXECUTED
40005de8: 96 10 00 17 mov %l7, %o3 <== NOT EXECUTED
40005dec: 92 12 61 f0 or %o1, 0x1f0, %o1 <== NOT EXECUTED
40005df0: 7f ff fa 6a call 40004798 <rtems_fdisk_info> <== NOT EXECUTED
40005df4: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
40005df8: 10 80 00 08 b 40005e18 <rtems_fdisk_ioctl+0x6a4> <== NOT EXECUTED
40005dfc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40005e00: 82 00 7f ff add %g1, -1, %g1
40005e04: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
sc->pages_used++;
40005e08: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40005e0c: 82 00 60 01 inc %g1
40005e10: 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);
40005e14: 90 10 00 1d mov %i5, %o0
40005e18: 7f ff fb 1d call 40004a8c <rtems_fdisk_queue_segment>
40005e1c: 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)
40005e20: c2 07 60 08 ld [ %i5 + 8 ], %g1
40005e24: 80 88 60 02 btst 2, %g1
40005e28: 12 80 00 05 bne 40005e3c <rtems_fdisk_ioctl+0x6c8> <== NEVER TAKEN
40005e2c: b8 07 60 34 add %i5, 0x34, %i4
rtems_fdisk_compact (fd);
40005e30: 7f ff fd c3 call 4000553c <rtems_fdisk_compact>
40005e34: 90 10 00 1d mov %i5, %o0
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
40005e38: b8 07 60 34 add %i5, 0x34, %i4
40005e3c: 7f ff f9 f7 call 40004618 <rtems_fdisk_segment_count_queue>
40005e40: 90 10 00 1c mov %i4, %o0
40005e44: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005e48: 80 a2 00 01 cmp %o0, %g1
40005e4c: 18 80 00 04 bgu 40005e5c <rtems_fdisk_ioctl+0x6e8>
40005e50: 01 00 00 00 nop
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
40005e54: 7f ff fd ba call 4000553c <rtems_fdisk_compact>
40005e58: 90 10 00 1d mov %i5, %o0
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
40005e5c: 7f ff f9 9b call 400044c8 <rtems_fdisk_segment_queue_pop_head>
40005e60: 90 10 00 1c mov %i4, %o0
/*
* Is the flash disk full ?
*/
if (!sc)
40005e64: a6 92 20 00 orcc %o0, 0, %l3
40005e68: 32 80 00 13 bne,a 40005eb4 <rtems_fdisk_ioctl+0x740> <== ALWAYS TAKEN
40005e6c: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
{
/*
* If compacting is configured for the background do it now
* to see if we can get some space back.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))
40005e70: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40005e74: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40005e78: 02 80 00 04 be 40005e88 <rtems_fdisk_ioctl+0x714> <== NOT EXECUTED
40005e7c: 01 00 00 00 nop <== NOT EXECUTED
rtems_fdisk_compact (fd);
40005e80: 7f ff fd af call 4000553c <rtems_fdisk_compact> <== NOT EXECUTED
40005e84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* Try again for some free space.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
40005e88: 7f ff f9 90 call 400044c8 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
40005e8c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (!sc)
40005e90: a6 92 20 00 orcc %o0, 0, %l3 <== NOT EXECUTED
40005e94: 32 80 00 08 bne,a 40005eb4 <rtems_fdisk_ioctl+0x740> <== NOT EXECUTED
40005e98: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: no available pages");
40005e9c: 11 10 00 c8 sethi %hi(0x40032000), %o0 <== NOT EXECUTED
return ENOSPC;
40005ea0: b2 10 20 1c mov 0x1c, %i1 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
40005ea4: 7f ff fa 9d call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005ea8: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40005eac: 10 80 00 a6 b 40006144 <rtems_fdisk_ioctl+0x9d0> <== NOT EXECUTED
40005eb0: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
40005eb4: 80 a0 60 02 cmp %g1, 2
40005eb8: 28 80 00 0f bleu,a 40005ef4 <rtems_fdisk_ioctl+0x780> <== ALWAYS TAKEN
40005ebc: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
40005ec0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005ec4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40005ec8: 7f ff f9 e8 call 40004668 <rtems_fdisk_queue_status> <== NOT EXECUTED
40005ecc: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
40005ed0: d6 04 e0 08 ld [ %l3 + 8 ], %o3 <== NOT EXECUTED
40005ed4: d8 04 e0 0c ld [ %l3 + 0xc ], %o4 <== NOT EXECUTED
40005ed8: 13 10 00 c8 sethi %hi(0x40032000), %o1 <== NOT EXECUTED
40005edc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005ee0: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
40005ee4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005ee8: 7f ff fa 2c call 40004798 <rtems_fdisk_info> <== NOT EXECUTED
40005eec: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
40005ef0: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1 <== NOT EXECUTED
for (page = 0; page < sc->pages; page++, pd++)
40005ef4: ee 04 e0 14 ld [ %l3 + 0x14 ], %l7
40005ef8: 10 80 00 77 b 400060d4 <rtems_fdisk_ioctl+0x960>
40005efc: b8 10 20 00 clr %i4
{
if (rtems_fdisk_page_desc_erased (pd))
40005f00: c2 27 bf dc st %g1, [ %fp + -36 ]
40005f04: 7f ff fa 01 call 40004708 <rtems_fdisk_page_desc_erased>
40005f08: 90 10 00 14 mov %l4, %o0
40005f0c: 80 8a 20 ff btst 0xff, %o0
40005f10: 02 80 00 70 be 400060d0 <rtems_fdisk_ioctl+0x95c>
40005f14: c2 07 bf dc ld [ %fp + -36 ], %g1
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40005f18: 03 10 01 1c sethi %hi(0x40047000), %g1
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
40005f1c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40005f20: c8 00 60 a0 ld [ %g1 + 0xa0 ], %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
40005f24: 84 10 20 00 clr %g2
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
40005f28: 10 80 00 07 b 40005f44 <rtems_fdisk_ioctl+0x7d0>
40005f2c: 82 10 3f ff mov -1, %g1
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40005f30: 82 08 60 ff and %g1, 0xff, %g1
40005f34: 82 18 40 0f xor %g1, %o7, %g1
40005f38: 83 28 60 01 sll %g1, 1, %g1
40005f3c: c2 11 00 01 lduh [ %g4 + %g1 ], %g1
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
40005f40: 84 00 a0 01 inc %g2
40005f44: 80 a0 80 03 cmp %g2, %g3
40005f48: 32 bf ff fa bne,a 40005f30 <rtems_fdisk_ioctl+0x7bc>
40005f4c: de 0c 40 02 ldub [ %l1 + %g2 ], %o7
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
40005f50: c2 35 00 00 sth %g1, [ %l4 ]
pd->block = block;
40005f54: f2 25 20 04 st %i1, [ %l4 + 4 ]
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40005f58: c4 15 20 02 lduh [ %l4 + 2 ], %g2
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
40005f5c: e6 25 80 15 st %l3, [ %l6 + %l5 ]
bc->page = page;
40005f60: f8 26 20 04 st %i4, [ %i0 + 4 ]
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
40005f64: c6 04 c0 00 ld [ %l3 ], %g3
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40005f68: 84 08 bf fe and %g2, -2, %g2
40005f6c: c4 35 20 02 sth %g2, [ %l4 + 2 ]
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
40005f70: d6 04 e0 08 ld [ %l3 + 8 ], %o3
40005f74: d8 04 e0 0c ld [ %l3 + 0xc ], %o4
40005f78: da 04 e0 1c ld [ %l3 + 0x1c ], %o5
40005f7c: de 04 e0 20 ld [ %l3 + 0x20 ], %o7
40005f80: 80 a0 e0 00 cmp %g3, 0
40005f84: 02 80 00 05 be 40005f98 <rtems_fdisk_ioctl+0x824> <== ALWAYS TAKEN
40005f88: c8 04 e0 24 ld [ %l3 + 0x24 ], %g4
40005f8c: 07 10 00 c6 sethi %hi(0x40031800), %g3 <== NOT EXECUTED
40005f90: 10 80 00 04 b 40005fa0 <rtems_fdisk_ioctl+0x82c> <== NOT EXECUTED
40005f94: 86 10 e3 00 or %g3, 0x300, %g3 ! 40031b00 <__FUNCTION__.6193+0x2f8><== NOT EXECUTED
40005f98: 07 10 00 c6 sethi %hi(0x40031800), %g3
40005f9c: 86 10 e3 08 or %g3, 0x308, %g3 ! 40031b08 <__FUNCTION__.6193+0x300>
40005fa0: 85 28 a0 10 sll %g2, 0x10, %g2
40005fa4: 83 28 60 10 sll %g1, 0x10, %g1
40005fa8: 85 30 a0 10 srl %g2, 0x10, %g2
40005fac: 83 30 60 10 srl %g1, 0x10, %g1
40005fb0: 94 10 00 19 mov %i1, %o2
40005fb4: da 23 a0 60 st %o5, [ %sp + 0x60 ]
40005fb8: de 23 a0 64 st %o7, [ %sp + 0x64 ]
40005fbc: c8 23 a0 68 st %g4, [ %sp + 0x68 ]
40005fc0: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
40005fc4: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
40005fc8: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40005fcc: f2 23 a0 78 st %i1, [ %sp + 0x78 ]
40005fd0: 9a 10 00 1c mov %i4, %o5
40005fd4: ee 23 a0 5c st %l7, [ %sp + 0x5c ]
40005fd8: 90 10 00 1d mov %i5, %o0
40005fdc: 13 10 00 c8 sethi %hi(0x40032000), %o1
40005fe0: 7f ff f9 ee call 40004798 <rtems_fdisk_info>
40005fe4: 92 12 62 78 or %o1, 0x278, %o1 ! 40032278 <__FUNCTION__.6193+0xa70>
/*
* 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);
40005fe8: d4 04 e0 18 ld [ %l3 + 0x18 ], %o2
40005fec: 90 10 00 1d mov %i5, %o0
40005ff0: 92 10 00 13 mov %l3, %o1
40005ff4: 94 07 00 0a add %i4, %o2, %o2
40005ff8: 7f ff fc 55 call 4000514c <rtems_fdisk_seg_write_page>
40005ffc: 96 10 00 11 mov %l1, %o3
if (ret)
40006000: b2 92 20 00 orcc %o0, 0, %i1
40006004: 22 80 00 0d be,a 40006038 <rtems_fdisk_ioctl+0x8c4> <== ALWAYS TAKEN
40006008: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
4000600c: e8 04 e0 08 ld [ %l3 + 8 ], %l4 <== NOT EXECUTED
40006010: 40 00 72 12 call 40022858 <strerror> <== NOT EXECUTED
40006014: f0 04 e0 0c ld [ %l3 + 0xc ], %i0 <== NOT EXECUTED
40006018: 13 10 00 c8 sethi %hi(0x40032000), %o1 <== NOT EXECUTED
4000601c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006020: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
40006024: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006028: 92 12 62 c8 or %o1, 0x2c8, %o1 <== NOT EXECUTED
4000602c: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
40006030: 10 80 00 14 b 40006080 <rtems_fdisk_ioctl+0x90c> <== NOT EXECUTED
40006034: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
40006038: 92 10 00 13 mov %l3, %o1
4000603c: 94 10 00 1c mov %i4, %o2
40006040: 7f ff fb 59 call 40004da4 <rtems_fdisk_seg_write_page_desc>
40006044: 96 10 00 14 mov %l4, %o3
if (ret)
40006048: b2 92 20 00 orcc %o0, 0, %i1
4000604c: 22 80 00 11 be,a 40006090 <rtems_fdisk_ioctl+0x91c> <== ALWAYS TAKEN
40006050: c2 04 e0 1c ld [ %l3 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
40006054: ea 04 e0 08 ld [ %l3 + 8 ], %l5 <== NOT EXECUTED
40006058: e8 04 e0 0c ld [ %l3 + 0xc ], %l4 <== NOT EXECUTED
4000605c: 40 00 71 ff call 40022858 <strerror> <== NOT EXECUTED
40006060: f8 06 20 04 ld [ %i0 + 4 ], %i4 <== NOT EXECUTED
40006064: 13 10 00 c8 sethi %hi(0x40032000), %o1 <== NOT EXECUTED
40006068: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
4000606c: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
40006070: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006074: 92 12 63 00 or %o1, 0x300, %o1 <== NOT EXECUTED
40006078: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
4000607c: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
40006080: 7f ff f9 c6 call 40004798 <rtems_fdisk_info> <== NOT EXECUTED
40006084: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
40006088: 10 80 00 05 b 4000609c <rtems_fdisk_ioctl+0x928> <== NOT EXECUTED
4000608c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
40006090: 82 00 60 01 inc %g1
40006094: c2 24 e0 1c st %g1, [ %l3 + 0x1c ]
}
}
rtems_fdisk_queue_segment (fd, sc);
40006098: 90 10 00 1d mov %i5, %o0
4000609c: 7f ff fa 7c call 40004a8c <rtems_fdisk_queue_segment>
400060a0: 92 10 00 13 mov %l3, %o1
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
400060a4: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
400060a8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
400060ac: 80 a0 80 01 cmp %g2, %g1
400060b0: 1a 80 00 19 bcc 40006114 <rtems_fdisk_ioctl+0x9a0>
400060b4: 90 10 00 1d mov %i5, %o0
fd->starvations++;
400060b8: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
400060bc: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
400060c0: 7f ff fd 1f call 4000553c <rtems_fdisk_compact>
400060c4: 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)
400060c8: 10 80 00 14 b 40006118 <rtems_fdisk_ioctl+0x9a4>
400060cc: 80 a6 60 00 cmp %i1, 0
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
400060d0: b8 07 20 01 inc %i4
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
400060d4: a9 2f 20 03 sll %i4, 3, %l4
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
400060d8: 80 a7 00 17 cmp %i4, %l7
400060dc: 12 bf ff 89 bne 40005f00 <rtems_fdisk_ioctl+0x78c> <== ALWAYS TAKEN
400060e0: a8 00 40 14 add %g1, %l4, %l4
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
400060e4: d2 04 e0 08 ld [ %l3 + 8 ], %o1 <== NOT EXECUTED
400060e8: d4 04 e0 0c ld [ %l3 + 0xc ], %o2 <== NOT EXECUTED
400060ec: 11 10 00 c8 sethi %hi(0x40032000), %o0 <== NOT EXECUTED
400060f0: 7f ff fa 0a call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
400060f4: 90 12 23 40 or %o0, 0x340, %o0 ! 40032340 <__FUNCTION__.6193+0xb38><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
400060f8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
400060fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
sc->device, sc->segment);
sc->failed = true;
40006100: c2 24 e0 28 st %g1, [ %l3 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
40006104: 7f ff fa 62 call 40004a8c <rtems_fdisk_queue_segment> <== NOT EXECUTED
40006108: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
return EIO;
4000610c: 10 80 00 0d b 40006140 <rtems_fdisk_ioctl+0x9cc> <== NOT EXECUTED
40006110: b2 10 20 05 mov 5, %i1 <== NOT EXECUTED
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
if (ret)
40006114: 80 a6 60 00 cmp %i1, 0
40006118: 12 80 00 0b bne 40006144 <rtems_fdisk_ioctl+0x9d0> <== NEVER TAKEN
4000611c: c4 07 bf ec ld [ %fp + -20 ], %g2
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)
40006120: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40006124: a4 04 a0 01 inc %l2
40006128: a2 04 40 01 add %l1, %g1, %l1
4000612c: c2 07 bf e4 ld [ %fp + -28 ], %g1
40006130: 80 a4 80 01 cmp %l2, %g1
40006134: 32 bf fe 97 bne,a 40005b90 <rtems_fdisk_ioctl+0x41c>
40006138: f2 04 00 00 ld [ %l0 ], %i1
4000613c: b2 10 20 00 clr %i1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40006140: c4 07 bf ec ld [ %fp + -20 ], %g2
40006144: a0 04 20 10 add %l0, 0x10, %l0
40006148: 84 00 a0 01 inc %g2
4000614c: 80 a6 60 00 cmp %i1, 0
40006150: 12 80 00 09 bne 40006174 <rtems_fdisk_ioctl+0xa00> <== NEVER TAKEN
40006154: c4 27 bf ec st %g2, [ %fp + -20 ]
40006158: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000615c: c4 07 bf ec ld [ %fp + -20 ], %g2
40006160: 80 a0 80 01 cmp %g2, %g1
40006164: 2a bf fe 85 bcs,a 40005b78 <rtems_fdisk_ioctl+0x404>
40006168: d0 04 20 04 ld [ %l0 + 4 ], %o0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
4000616c: 10 80 00 03 b 40006178 <rtems_fdisk_ioctl+0xa04>
40006170: 92 10 20 00 clr %o1
40006174: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
40006178: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000617c: 9f c0 40 00 call %g1
40006180: 90 10 00 1a mov %i2, %o0
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40006184: c2 07 bf e8 ld [ %fp + -24 ], %g1
break;
40006188: 10 80 01 c5 b 4000689c <rtems_fdisk_ioctl+0x1128>
4000618c: c0 20 40 00 clr [ %g1 ]
default:
errno = EINVAL;
40006190: 40 00 67 ed call 40020144 <__errno> <== NOT EXECUTED
40006194: 01 00 00 00 nop <== NOT EXECUTED
40006198: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
4000619c: 10 80 01 c0 b 4000689c <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
400061a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
400061a4: 40 00 67 e8 call 40020144 <__errno> <== NOT EXECUTED
400061a8: 21 10 00 c8 sethi %hi(0x40032000), %l0 <== NOT EXECUTED
400061ac: fa 07 60 98 ld [ %i5 + 0x98 ], %i5 <== NOT EXECUTED
400061b0: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
400061b4: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
400061b8: 13 10 00 c8 sethi %hi(0x40032000), %o1 <== NOT EXECUTED
400061bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400061c0: 92 12 63 78 or %o1, 0x378, %o1 <== NOT EXECUTED
400061c4: 7f ff f9 75 call 40004798 <rtems_fdisk_info> <== NOT EXECUTED
400061c8: 31 10 00 c8 sethi %hi(0x40032000), %i0 <== NOT EXECUTED
400061cc: b4 10 20 00 clr %i2 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
400061d0: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
400061d4: a0 14 23 88 or %l0, 0x388, %l0 <== NOT EXECUTED
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400061d8: 10 80 00 17 b 40006234 <rtems_fdisk_ioctl+0xac0> <== NOT EXECUTED
400061dc: b0 16 23 a0 or %i0, 0x3a0, %i0 <== NOT EXECUTED
for (device = 0; device < fd->device_count; device++)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
400061e0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400061e4: 7f ff f9 6d call 40004798 <rtems_fdisk_info> <== NOT EXECUTED
400061e8: 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;
400061ec: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400061f0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
400061f4: 82 00 40 1a add %g1, %i2, %g1 <== NOT EXECUTED
400061f8: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400061fc: 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;
40006200: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
40006204: 7f ff f9 85 call 40004818 <rtems_fdisk_printf> <== NOT EXECUTED
40006208: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
4000620c: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
40006210: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
40006214: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
40006218: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
4000621c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40006220: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006224: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
40006228: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000622c: 12 80 00 18 bne 4000628c <rtems_fdisk_ioctl+0xb18> <== NOT EXECUTED
40006230: b8 07 20 01 inc %i4 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
40006234: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40006238: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
4000623c: 0a bf ff e9 bcs 400061e0 <rtems_fdisk_ioctl+0xa6c> <== NOT EXECUTED
40006240: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40006244: b4 10 20 00 clr %i2 <== NOT EXECUTED
40006248: 10 80 00 0d b 4000627c <rtems_fdisk_ioctl+0xb08> <== NOT EXECUTED
4000624c: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
40006250: c2 00 40 1a ld [ %g1 + %i2 ], %g1 <== NOT EXECUTED
40006254: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006258: 02 80 00 0d be 4000628c <rtems_fdisk_ioctl+0xb18> <== NOT EXECUTED
4000625c: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
40006260: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006264: 7f ff fa e1 call 40004de8 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
40006268: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
if (ret)
4000626c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006270: 12 80 00 07 bne 4000628c <rtems_fdisk_ioctl+0xb18> <== NOT EXECUTED
40006274: b8 07 20 01 inc %i4 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
40006278: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
4000627c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40006280: 2a bf ff f4 bcs,a 40006250 <rtems_fdisk_ioctl+0xadc> <== NOT EXECUTED
40006284: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
40006288: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
4000628c: 10 80 01 84 b 4000689c <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
40006290: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
40006294: 40 00 67 ac call 40020144 <__errno> <== NOT EXECUTED
40006298: 01 00 00 00 nop <== NOT EXECUTED
4000629c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
400062a0: d0 07 60 98 ld [ %i5 + 0x98 ], %o0 <== NOT EXECUTED
400062a4: 7f ff fc a6 call 4000553c <rtems_fdisk_compact> <== NOT EXECUTED
400062a8: 90 02 00 1b add %o0, %i3, %o0 <== NOT EXECUTED
break;
400062ac: 10 80 01 7c b 4000689c <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
400062b0: d0 27 00 00 st %o0, [ %i4 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
400062b4: 40 00 67 a4 call 40020144 <__errno> <== NOT EXECUTED
400062b8: 01 00 00 00 nop <== NOT EXECUTED
400062bc: f8 07 60 98 ld [ %i5 + 0x98 ], %i4 <== NOT EXECUTED
400062c0: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
400062c4: b8 07 00 1b add %i4, %i3, %i4 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
400062c8: ba 10 20 00 clr %i5 <== NOT EXECUTED
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
400062cc: 10 80 00 09 b 400062f0 <rtems_fdisk_ioctl+0xb7c> <== NOT EXECUTED
400062d0: b2 07 20 4c add %i4, 0x4c, %i1 <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
400062d4: 7f ff f9 ae call 4000498c <rtems_fdisk_erase_segment> <== NOT EXECUTED
400062d8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret && !latched_ret)
400062dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400062e0: 02 80 00 04 be 400062f0 <rtems_fdisk_ioctl+0xb7c> <== NOT EXECUTED
400062e4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400062e8: 22 80 00 02 be,a 400062f0 <rtems_fdisk_ioctl+0xb7c> <== NOT EXECUTED
400062ec: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
400062f0: 7f ff f8 76 call 400044c8 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
400062f4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400062f8: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
400062fc: 12 bf ff f6 bne 400062d4 <rtems_fdisk_ioctl+0xb60> <== NOT EXECUTED
40006300: 01 00 00 00 nop <== NOT EXECUTED
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
40006304: 10 80 01 66 b 4000689c <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
40006308: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
4000630c: 40 00 67 8e call 40020144 <__errno> <== NOT EXECUTED
40006310: 01 00 00 00 nop <== NOT EXECUTED
40006314: fa 07 60 98 ld [ %i5 + 0x98 ], %i5 <== NOT EXECUTED
40006318: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
4000631c: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
40006320: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
data->block_count = fd->block_count;
40006324: c4 07 60 1c ld [ %i5 + 0x1c ], %g2 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
40006328: f2 07 60 30 ld [ %i5 + 0x30 ], %i1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
4000632c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
40006330: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
40006334: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
40006338: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
4000633c: f2 26 a0 0c st %i1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
40006340: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
40006344: 10 80 00 0a b 4000636c <rtems_fdisk_ioctl+0xbf8> <== NOT EXECUTED
40006348: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (fd->blocks[i].segment)
4000634c: 87 28 60 03 sll %g1, 3, %g3 <== NOT EXECUTED
40006350: c6 01 00 03 ld [ %g4 + %g3 ], %g3 <== NOT EXECUTED
40006354: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40006358: 02 80 00 05 be 4000636c <rtems_fdisk_ioctl+0xbf8> <== NOT EXECUTED
4000635c: 82 00 60 01 inc %g1 <== NOT EXECUTED
data->blocks_used++;
40006360: c6 06 a0 18 ld [ %i2 + 0x18 ], %g3 <== NOT EXECUTED
40006364: 86 00 e0 01 inc %g3 <== NOT EXECUTED
40006368: c6 26 a0 18 st %g3, [ %i2 + 0x18 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
4000636c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40006370: 32 bf ff f7 bne,a 4000634c <rtems_fdisk_ioctl+0xbd8> <== NOT EXECUTED
40006374: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
40006378: 7f ff f8 a8 call 40004618 <rtems_fdisk_segment_count_queue><== NOT EXECUTED
4000637c: 90 07 60 34 add %i5, 0x34, %o0 <== NOT EXECUTED
40006380: d0 26 a0 1c st %o0, [ %i2 + 0x1c ] <== NOT EXECUTED
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
40006384: 7f ff f8 a5 call 40004618 <rtems_fdisk_segment_count_queue><== NOT EXECUTED
40006388: 90 07 60 40 add %i5, 0x40, %o0 <== NOT EXECUTED
4000638c: d0 26 a0 20 st %o0, [ %i2 + 0x20 ] <== NOT EXECUTED
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
40006390: 7f ff f8 a2 call 40004618 <rtems_fdisk_segment_count_queue><== NOT EXECUTED
40006394: 90 07 60 58 add %i5, 0x58, %o0 <== NOT EXECUTED
data->page_count = 0;
data->pages_desc = 0;
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
40006398: 86 10 20 00 clr %g3 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
4000639c: d0 26 a0 24 st %o0, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
400063a0: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
400063a4: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
400063a8: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
400063ac: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
400063b0: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
400063b4: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
400063b8: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
400063bc: 10 80 00 2a b 40006464 <rtems_fdisk_ioctl+0xcf0> <== NOT EXECUTED
400063c0: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
400063c4: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
400063c8: 9e 03 c0 03 add %o7, %g3, %o7 <== NOT EXECUTED
400063cc: f0 03 e0 04 ld [ %o7 + 4 ], %i0 <== NOT EXECUTED
400063d0: b8 10 20 00 clr %i4 <== NOT EXECUTED
400063d4: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
400063d8: 88 10 20 00 clr %g4 <== NOT EXECUTED
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
400063dc: 10 80 00 1d b 40006450 <rtems_fdisk_ioctl+0xcdc> <== NOT EXECUTED
400063e0: c2 26 a0 10 st %g1, [ %i2 + 0x10 ] <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
400063e4: d8 06 a0 14 ld [ %i2 + 0x14 ], %o4 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
400063e8: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
data->page_count += sc->pages;
400063ec: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
400063f0: 88 01 20 01 inc %g4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
400063f4: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
400063f8: d8 06 a0 2c ld [ %i2 + 0x2c ], %o4 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
400063fc: da 26 a0 14 st %o5, [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40006400: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
40006404: b8 07 20 30 add %i4, 0x30, %i4 <== NOT EXECUTED
40006408: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_active += sc->pages_active;
4000640c: d8 06 a0 30 ld [ %i2 + 0x30 ], %o4 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
40006410: da 26 a0 2c st %o5, [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active += sc->pages_active;
40006414: da 00 60 1c ld [ %g1 + 0x1c ], %o5 <== NOT EXECUTED
40006418: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_used += sc->pages_used;
4000641c: d8 06 a0 34 ld [ %i2 + 0x34 ], %o4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
40006420: da 26 a0 30 st %o5, [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used += sc->pages_used;
40006424: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
40006428: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
4000642c: d8 06 a0 38 ld [ %i2 + 0x38 ], %o4 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
40006430: da 26 a0 34 st %o5, [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
40006434: da 00 60 24 ld [ %g1 + 0x24 ], %o5 <== NOT EXECUTED
data->seg_erases += sc->erased;
40006438: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 <== NOT EXECUTED
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
data->pages_bad += sc->pages_bad;
4000643c: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
40006440: da 26 a0 38 st %o5, [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases += sc->erased;
40006444: da 06 a0 28 ld [ %i2 + 0x28 ], %o5 <== NOT EXECUTED
40006448: 82 03 40 01 add %o5, %g1, %g1 <== NOT EXECUTED
4000644c: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
40006450: 80 a1 00 18 cmp %g4, %i0 <== NOT EXECUTED
40006454: 32 bf ff e4 bne,a 400063e4 <rtems_fdisk_ioctl+0xc70> <== NOT EXECUTED
40006458: c2 03 c0 00 ld [ %o7 ], %g1 <== NOT EXECUTED
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
4000645c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40006460: 86 00 e0 0c add %g3, 0xc, %g3 <== NOT EXECUTED
40006464: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
40006468: 32 bf ff d7 bne,a 400063c4 <rtems_fdisk_ioctl+0xc50> <== NOT EXECUTED
4000646c: de 07 60 2c ld [ %i5 + 0x2c ], %o7 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
40006470: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
40006474: c2 26 a0 3c st %g1, [ %i2 + 0x3c ] <== NOT EXECUTED
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
(rtems_fdisk_monitor_data*) argp);
break;
40006478: 10 80 01 09 b 4000689c <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
4000647c: c0 24 00 00 clr [ %l0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
40006480: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
break;
40006484: 10 80 01 06 b 4000689c <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
40006488: f4 20 60 6c st %i2, [ %g1 + 0x6c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
4000648c: 40 00 67 2e call 40020144 <__errno>
40006490: 01 00 00 00 nop
40006494: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40006498: d0 27 bf ec st %o0, [ %fp + -20 ]
4000649c: ba 00 40 1b add %g1, %i3, %i5
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
400064a0: c4 07 60 6c ld [ %i5 + 0x6c ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
400064a4: d4 00 40 1b ld [ %g1 + %i3 ], %o2
400064a8: d6 07 60 04 ld [ %i5 + 4 ], %o3
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
400064ac: c4 27 bf e8 st %g2, [ %fp + -24 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
400064b0: 84 10 20 03 mov 3, %g2
rtems_fdisk_printf (fd,
400064b4: 90 10 00 1d mov %i5, %o0
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
400064b8: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
rtems_fdisk_printf (fd,
400064bc: 13 10 00 c8 sethi %hi(0x40032000), %o1
400064c0: 7f ff f8 d6 call 40004818 <rtems_fdisk_printf>
400064c4: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 400323b8 <__FUNCTION__.6193+0xbb0>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
400064c8: d4 07 60 1c ld [ %i5 + 0x1c ], %o2
400064cc: 90 10 00 1d mov %i5, %o0
400064d0: 13 10 00 c8 sethi %hi(0x40032000), %o1
400064d4: 7f ff f8 d1 call 40004818 <rtems_fdisk_printf>
400064d8: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 400323e0 <__FUNCTION__.6193+0xbd8>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
400064dc: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
400064e0: 90 10 00 1d mov %i5, %o0
400064e4: 13 10 00 c8 sethi %hi(0x40032000), %o1
400064e8: 7f ff f8 cc call 40004818 <rtems_fdisk_printf>
400064ec: 92 12 63 f0 or %o1, 0x3f0, %o1 ! 400323f0 <__FUNCTION__.6193+0xbe8>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
400064f0: d4 07 60 24 ld [ %i5 + 0x24 ], %o2
400064f4: 90 10 00 1d mov %i5, %o0
400064f8: 13 10 00 c9 sethi %hi(0x40032400), %o1
400064fc: 7f ff f8 c7 call 40004818 <rtems_fdisk_printf>
40006500: 92 12 60 08 or %o1, 8, %o1 ! 40032408 <__FUNCTION__.6193+0xc00>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
40006504: d4 07 60 70 ld [ %i5 + 0x70 ], %o2
40006508: 90 10 00 1d mov %i5, %o0
4000650c: 13 10 00 c9 sethi %hi(0x40032400), %o1
40006510: 7f ff f8 c2 call 40004818 <rtems_fdisk_printf>
40006514: 92 12 60 20 or %o1, 0x20, %o1 ! 40032420 <__FUNCTION__.6193+0xc18>
count = rtems_fdisk_segment_count_queue (&fd->available);
40006518: 7f ff f8 40 call 40004618 <rtems_fdisk_segment_count_queue>
4000651c: 90 07 60 34 add %i5, 0x34, %o0
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
40006520: d6 07 60 3c ld [ %i5 + 0x3c ], %o3
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
40006524: b8 10 00 08 mov %o0, %i4
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
40006528: 13 10 00 c9 sethi %hi(0x40032400), %o1
4000652c: 94 10 00 1c mov %i4, %o2
40006530: 92 12 60 30 or %o1, 0x30, %o1
40006534: 7f ff f8 b9 call 40004818 <rtems_fdisk_printf>
40006538: 90 10 00 1d mov %i5, %o0
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
4000653c: 7f ff f8 37 call 40004618 <rtems_fdisk_segment_count_queue>
40006540: 90 07 60 40 add %i5, 0x40, %o0
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
40006544: d6 07 60 48 ld [ %i5 + 0x48 ], %o3
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
40006548: 94 10 00 08 mov %o0, %o2
total += count;
4000654c: b8 02 00 1c add %o0, %i4, %i4
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
40006550: 13 10 00 c9 sethi %hi(0x40032400), %o1
40006554: 90 10 00 1d mov %i5, %o0
40006558: 7f ff f8 b0 call 40004818 <rtems_fdisk_printf>
4000655c: 92 12 60 50 or %o1, 0x50, %o1
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
40006560: 7f ff f8 2e call 40004618 <rtems_fdisk_segment_count_queue>
40006564: 90 07 60 4c add %i5, 0x4c, %o0
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
40006568: d6 07 60 54 ld [ %i5 + 0x54 ], %o3
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
4000656c: 94 10 00 08 mov %o0, %o2
total += count;
40006570: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
40006574: 13 10 00 c9 sethi %hi(0x40032400), %o1
40006578: 90 10 00 1d mov %i5, %o0
4000657c: 7f ff f8 a7 call 40004818 <rtems_fdisk_printf>
40006580: 92 12 60 68 or %o1, 0x68, %o1
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
40006584: 7f ff f8 25 call 40004618 <rtems_fdisk_segment_count_queue>
40006588: 90 07 60 58 add %i5, 0x58, %o0
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
4000658c: d6 07 60 60 ld [ %i5 + 0x60 ], %o3
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
40006590: 94 10 00 08 mov %o0, %o2
total += count;
40006594: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
40006598: 13 10 00 c9 sethi %hi(0x40032400), %o1
4000659c: 90 10 00 1d mov %i5, %o0
400065a0: 7f ff f8 9e call 40004818 <rtems_fdisk_printf>
400065a4: 92 12 60 80 or %o1, 0x80, %o1
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
400065a8: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
400065ac: 84 10 20 00 clr %g2
400065b0: 82 10 20 00 clr %g1
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
400065b4: 10 80 00 07 b 400065d0 <rtems_fdisk_ioctl+0xe5c>
400065b8: 96 10 20 00 clr %o3
for (device = 0; device < fd->device_count; device++)
400065bc: 82 00 60 01 inc %g1
count += fd->devices[device].segment_count;
400065c0: 88 01 00 02 add %g4, %g2, %g4
400065c4: c8 01 20 04 ld [ %g4 + 4 ], %g4
400065c8: 84 00 a0 0c add %g2, 0xc, %g2
400065cc: 96 02 c0 04 add %o3, %g4, %o3
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
400065d0: 80 a0 40 03 cmp %g1, %g3
400065d4: 32 bf ff fa bne,a 400065bc <rtems_fdisk_ioctl+0xe48>
400065d8: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
400065dc: 19 10 00 c7 sethi %hi(0x40031c00), %o4
400065e0: 80 a7 00 0b cmp %i4, %o3
400065e4: 12 80 00 04 bne 400065f4 <rtems_fdisk_ioctl+0xe80> <== NEVER TAKEN
400065e8: 98 13 23 60 or %o4, 0x360, %o4
400065ec: 19 10 00 c7 sethi %hi(0x40031c00), %o4
400065f0: 98 13 23 58 or %o4, 0x358, %o4 ! 40031f58 <__FUNCTION__.6193+0x750>
400065f4: 94 10 00 1c mov %i4, %o2
400065f8: 90 10 00 1d mov %i5, %o0
400065fc: 13 10 00 c9 sethi %hi(0x40032400), %o1
40006600: 7f ff f8 86 call 40004818 <rtems_fdisk_printf>
40006604: 92 12 60 98 or %o1, 0x98, %o1 ! 40032498 <__FUNCTION__.6193+0xc90>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
40006608: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
4000660c: 90 10 00 1d mov %i5, %o0
40006610: 13 10 00 c9 sethi %hi(0x40032400), %o1
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
rtems_fdisk_printf (fd,
40006614: 2d 10 00 c9 sethi %hi(0x40032400), %l6
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
40006618: 92 12 60 b8 or %o1, 0xb8, %o1
4000661c: 7f ff f8 7f call 40004818 <rtems_fdisk_printf>
40006620: 2f 10 00 c9 sethi %hi(0x40032400), %l7
40006624: b4 10 20 00 clr %i2
for (device = 0; device < fd->device_count; device++)
40006628: b2 10 20 00 clr %i1
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
rtems_fdisk_printf (fd,
4000662c: ac 15 a0 f0 or %l6, 0xf0, %l6
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
40006630: 10 80 00 7b b 4000681c <rtems_fdisk_ioctl+0x10a8>
40006634: ae 15 e1 20 or %l7, 0x120, %l7
for (device = 0; device < fd->device_count; device++)
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
40006638: 90 10 00 1d mov %i5, %o0
4000663c: 13 10 00 c9 sethi %hi(0x40032400), %o1
40006640: 7f ff f8 76 call 40004818 <rtems_fdisk_printf>
40006644: 92 12 60 c8 or %o1, 0xc8, %o1 ! 400324c8 <__FUNCTION__.6193+0xcc0>
rtems_fdisk_printf (fd, " Segment count\t%ld",
40006648: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
4000664c: 90 10 00 1d mov %i5, %o0
40006650: 82 00 40 1a add %g1, %i2, %g1
40006654: d4 00 60 04 ld [ %g1 + 4 ], %o2
40006658: 13 10 00 c9 sethi %hi(0x40032400), %o1
4000665c: a0 10 20 00 clr %l0
40006660: 92 12 60 d8 or %o1, 0xd8, %o1
40006664: 7f ff f8 6d call 40004818 <rtems_fdisk_printf>
40006668: b0 10 20 00 clr %i0
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
4000666c: 10 80 00 65 b 40006800 <rtems_fdisk_ioctl+0x108c>
40006670: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
40006674: 90 10 00 1d mov %i5, %o0
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
40006678: b8 07 00 10 add %i4, %l0, %i4
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
4000667c: 94 07 bf f8 add %fp, -8, %o2
40006680: 92 10 00 1c mov %i4, %o1
40006684: 7f ff f7 f9 call 40004668 <rtems_fdisk_queue_status>
40006688: a2 10 20 00 clr %l1
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
uint32_t used = 0;
4000668c: a6 10 20 00 clr %l3
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
40006690: a8 10 20 00 clr %l4
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
40006694: a4 10 20 00 clr %l2
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
40006698: 10 80 00 35 b 4000676c <rtems_fdisk_ioctl+0xff8>
4000669c: aa 10 20 00 clr %l5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
400066a0: 85 2d 60 03 sll %l5, 3, %g2
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
400066a4: 84 03 c0 02 add %o7, %g2, %g2
400066a8: 90 10 00 02 mov %g2, %o0
400066ac: 7f ff f8 17 call 40004708 <rtems_fdisk_page_desc_erased>
400066b0: c4 27 bf d0 st %g2, [ %fp + -48 ]
400066b4: 80 8a 20 ff btst 0xff, %o0
400066b8: 02 80 00 04 be 400066c8 <rtems_fdisk_ioctl+0xf54>
400066bc: c4 07 bf d0 ld [ %fp + -48 ], %g2
erased++;
400066c0: 10 80 00 0c b 400066f0 <rtems_fdisk_ioctl+0xf7c>
400066c4: a4 04 a0 01 inc %l2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
400066c8: 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],
400066cc: 80 88 a0 01 btst 1, %g2
400066d0: 32 80 00 09 bne,a 400066f4 <rtems_fdisk_ioctl+0xf80> <== NEVER TAKEN
400066d4: 84 10 20 00 clr %g2 <== NOT EXECUTED
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
400066d8: 80 88 a0 02 btst 2, %g2
400066dc: 32 80 00 04 bne,a 400066ec <rtems_fdisk_ioctl+0xf78>
400066e0: a8 05 20 01 inc %l4
RTEMS_FDISK_PAGE_USED))
used++;
400066e4: 10 80 00 03 b 400066f0 <rtems_fdisk_ioctl+0xf7c>
400066e8: a6 04 e0 01 inc %l3
else
{
active++;
is_active = true;
400066ec: a2 10 20 01 mov 1, %l1
}
}
for (block = 0; block < fd->block_count; block++)
400066f0: 84 10 20 00 clr %g2
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
400066f4: 10 80 00 19 b 40006758 <rtems_fdisk_ioctl+0xfe4>
400066f8: 9a 0c 60 ff and %l1, 0xff, %o5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
400066fc: 9f 28 a0 03 sll %g2, 3, %o7
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
40006700: 96 03 00 0f add %o4, %o7, %o3
40006704: de 03 00 0f ld [ %o4 + %o7 ], %o7
40006708: 80 a3 c0 1c cmp %o7, %i4
4000670c: 32 80 00 13 bne,a 40006758 <rtems_fdisk_ioctl+0xfe4>
40006710: 84 00 a0 01 inc %g2
40006714: de 02 e0 04 ld [ %o3 + 4 ], %o7
40006718: 80 a3 c0 15 cmp %o7, %l5
4000671c: 32 80 00 0f bne,a 40006758 <rtems_fdisk_ioctl+0xfe4>
40006720: 84 00 a0 01 inc %g2
(fd->blocks[block].page == page) && !is_active)
40006724: 80 a3 60 00 cmp %o5, 0
40006728: 32 80 00 0c bne,a 40006758 <rtems_fdisk_ioctl+0xfe4> <== ALWAYS TAKEN
4000672c: 84 00 a0 01 inc %g2
rtems_fdisk_printf (fd,
40006730: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED
40006734: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
40006738: da 27 bf c4 st %o5, [ %fp + -60 ] <== NOT EXECUTED
4000673c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006740: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
40006744: 7f ff f8 35 call 40004818 <rtems_fdisk_printf> <== NOT EXECUTED
40006748: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
4000674c: da 07 bf c4 ld [ %fp + -60 ], %o5 <== NOT EXECUTED
40006750: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
40006754: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40006758: de 07 60 1c ld [ %i5 + 0x1c ], %o7
4000675c: 80 a0 80 0f cmp %g2, %o7
40006760: 2a bf ff e7 bcs,a 400066fc <rtems_fdisk_ioctl+0xf88>
40006764: d8 07 60 18 ld [ %i5 + 0x18 ], %o4
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
40006768: aa 05 60 01 inc %l5
4000676c: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
40006770: 80 a5 40 0c cmp %l5, %o4
40006774: 2a bf ff cb bcs,a 400066a0 <rtems_fdisk_ioctl+0xf2c>
40006778: de 07 20 10 ld [ %i4 + 0x10 ], %o7
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
4000677c: de 07 60 1c ld [ %i5 + 0x1c ], %o7
40006780: 82 10 20 00 clr %g1
40006784: 10 80 00 08 b 400067a4 <rtems_fdisk_ioctl+0x1030>
40006788: 84 10 20 00 clr %g2
{
if (fd->blocks[block].segment == sc)
4000678c: 9b 28 60 03 sll %g1, 3, %o5
40006790: da 02 c0 0d ld [ %o3 + %o5 ], %o5
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
40006794: 82 00 60 01 inc %g1
{
if (fd->blocks[block].segment == sc)
count++;
40006798: 9a 1b 40 1c xor %o5, %i4, %o5
4000679c: 80 a0 00 0d cmp %g0, %o5
400067a0: 84 60 bf ff subx %g2, -1, %g2
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400067a4: 80 a0 40 0f cmp %g1, %o7
400067a8: 32 bf ff f9 bne,a 4000678c <rtems_fdisk_ioctl+0x1018>
400067ac: d6 07 60 18 ld [ %i5 + 0x18 ], %o3
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
sc->pages_used + sc->pages_bad),
400067b0: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
400067b4: da 07 20 1c ld [ %i4 + 0x1c ], %o5
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
400067b8: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
400067bc: e8 23 a0 5c st %l4, [ %sp + 0x5c ]
400067c0: e6 23 a0 64 st %l3, [ %sp + 0x64 ]
400067c4: e4 23 a0 68 st %l2, [ %sp + 0x68 ]
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
400067c8: c6 07 20 24 ld [ %i4 + 0x24 ], %g3
400067cc: 82 03 40 01 add %o5, %g1, %g1
400067d0: 82 00 40 03 add %g1, %g3, %g1
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
400067d4: 82 23 00 01 sub %o4, %g1, %g1
400067d8: 94 10 00 18 mov %i0, %o2
400067dc: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
400067e0: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
400067e4: 90 10 00 1d mov %i5, %o0
400067e8: 92 10 00 17 mov %l7, %o1
400067ec: 96 07 bf f8 add %fp, -8, %o3
400067f0: 7f ff f8 0a call 40004818 <rtems_fdisk_printf>
400067f4: b0 06 20 01 inc %i0
400067f8: a0 04 20 30 add %l0, 0x30, %l0
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
400067fc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40006800: 84 00 40 1a add %g1, %i2, %g2
40006804: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40006808: 80 a6 00 02 cmp %i0, %g2
4000680c: 2a bf ff 9a bcs,a 40006674 <rtems_fdisk_ioctl+0xf00>
40006810: f8 00 40 1a ld [ %g1 + %i2 ], %i4
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
for (device = 0; device < fd->device_count; device++)
40006814: b2 06 60 01 inc %i1
40006818: b4 06 a0 0c add %i2, 0xc, %i2
4000681c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40006820: 80 a6 40 01 cmp %i1, %g1
40006824: 0a bf ff 85 bcs 40006638 <rtems_fdisk_ioctl+0xec4>
40006828: 94 10 00 19 mov %i1, %o2
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
4000682c: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
40006830: 90 10 00 1d mov %i5, %o0
40006834: 13 10 00 c9 sethi %hi(0x40032400), %o1
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40006838: 33 10 00 c9 sethi %hi(0x40032400), %i1
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
4000683c: 92 12 61 60 or %o1, 0x160, %o1
40006840: 7f ff f7 f6 call 40004818 <rtems_fdisk_printf>
40006844: b4 10 20 00 clr %i2
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40006848: 10 80 00 0a b 40006870 <rtems_fdisk_ioctl+0x10fc>
4000684c: b2 16 61 70 or %i1, 0x170, %i1
40006850: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40006854: da 07 20 20 ld [ %i4 + 0x20 ], %o5
40006858: 94 10 00 1a mov %i2, %o2
4000685c: 90 10 00 1d mov %i5, %o0
40006860: 7f ff f7 ee call 40004818 <rtems_fdisk_printf>
40006864: 92 10 00 19 mov %i1, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
40006868: f8 07 00 00 ld [ %i4 ], %i4
count++;
4000686c: b4 06 a0 01 inc %i2
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
40006870: 80 a7 20 00 cmp %i4, 0
40006874: 32 bf ff f7 bne,a 40006850 <rtems_fdisk_ioctl+0x10dc>
40006878: d6 07 20 08 ld [ %i4 + 8 ], %o3
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
4000687c: c2 07 bf e8 ld [ %fp + -24 ], %g1
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
40006880: c4 07 bf ec ld [ %fp + -20 ], %g2
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
40006884: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
break;
40006888: 10 80 00 05 b 4000689c <rtems_fdisk_ioctl+0x1128>
4000688c: c0 20 80 00 clr [ %g2 ]
default:
rtems_blkdev_ioctl (dd, req, argp);
40006890: 92 10 00 19 mov %i1, %o1
40006894: 40 00 3a f8 call 40015474 <rtems_blkdev_ioctl>
40006898: 94 10 00 1a mov %i2, %o2
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
4000689c: 03 10 01 1c sethi %hi(0x40047000), %g1
400068a0: c2 00 60 98 ld [ %g1 + 0x98 ], %g1 ! 40047098 <rtems_flashdisks>
400068a4: b6 00 40 1b add %g1, %i3, %i3
400068a8: 40 00 16 4f call 4000c1e4 <rtems_semaphore_release>
400068ac: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
400068b0: 80 a2 20 00 cmp %o0, 0
400068b4: 02 80 00 06 be 400068cc <rtems_fdisk_ioctl+0x1158> <== ALWAYS TAKEN
400068b8: 01 00 00 00 nop
errno = EIO;
400068bc: 40 00 66 22 call 40020144 <__errno> <== NOT EXECUTED
400068c0: 01 00 00 00 nop <== NOT EXECUTED
400068c4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
400068c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
400068cc: 40 00 66 1e call 40020144 <__errno>
400068d0: 01 00 00 00 nop
400068d4: c2 02 00 00 ld [ %o0 ], %g1
400068d8: 80 a0 00 01 cmp %g0, %g1
400068dc: b0 60 20 00 subx %g0, 0, %i0
400068e0: 81 c7 e0 08 ret
400068e4: 81 e8 00 00 restore
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
400068e8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
400068ec: a2 04 60 01 inc %l1
400068f0: 10 bf fc 85 b 40005b04 <rtems_fdisk_ioctl+0x390>
400068f4: a0 04 00 01 add %l0, %g1, %l0
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
400068f8: 10 bf fc 89 b 40005b1c <rtems_fdisk_ioctl+0x3a8> <== NOT EXECUTED
400068fc: a4 04 a0 01 inc %l2 <== NOT EXECUTED
40004a8c <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)
{
40004a8c: 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",
40004a90: 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)
{
40004a94: ba 10 00 18 mov %i0, %i5
40004a98: 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",
40004a9c: d4 06 60 08 ld [ %i1 + 8 ], %o2
40004aa0: d6 06 60 0c ld [ %i1 + 0xc ], %o3
40004aa4: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
40004aa8: da 06 60 1c ld [ %i1 + 0x1c ], %o5
40004aac: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
40004ab0: 80 a0 60 00 cmp %g1, 0
40004ab4: 02 80 00 05 be 40004ac8 <rtems_fdisk_queue_segment+0x3c> <== ALWAYS TAKEN
40004ab8: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
40004abc: 05 10 00 c6 sethi %hi(0x40031800), %g2 <== NOT EXECUTED
40004ac0: 10 80 00 04 b 40004ad0 <rtems_fdisk_queue_segment+0x44> <== NOT EXECUTED
40004ac4: 84 10 a2 f0 or %g2, 0x2f0, %g2 ! 40031af0 <__FUNCTION__.6193+0x2e8><== NOT EXECUTED
40004ac8: 05 10 00 c6 sethi %hi(0x40031800), %g2
40004acc: 84 10 a2 f8 or %g2, 0x2f8, %g2 ! 40031af8 <__FUNCTION__.6193+0x2f0>
40004ad0: c2 06 80 00 ld [ %i2 ], %g1
40004ad4: 80 a0 60 00 cmp %g1, 0
40004ad8: 02 80 00 04 be 40004ae8 <rtems_fdisk_queue_segment+0x5c>
40004adc: 03 10 00 c6 sethi %hi(0x40031800), %g1
40004ae0: 10 80 00 04 b 40004af0 <rtems_fdisk_queue_segment+0x64>
40004ae4: 82 10 63 00 or %g1, 0x300, %g1 ! 40031b00 <__FUNCTION__.6193+0x2f8>
40004ae8: 03 10 00 c6 sethi %hi(0x40031800), %g1
40004aec: 82 10 63 08 or %g1, 0x308, %g1 ! 40031b08 <__FUNCTION__.6193+0x300>
40004af0: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
40004af4: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
40004af8: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40004afc: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
40004b00: 90 10 00 1d mov %i5, %o0
40004b04: 13 10 00 c6 sethi %hi(0x40031800), %o1
40004b08: 7f ff ff 24 call 40004798 <rtems_fdisk_info>
40004b0c: 92 12 63 10 or %o1, 0x310, %o1 ! 40031b10 <__FUNCTION__.6193+0x308>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
40004b10: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
40004b14: 80 a0 60 00 cmp %g1, 0
40004b18: 02 80 00 09 be 40004b3c <rtems_fdisk_queue_segment+0xb0> <== ALWAYS TAKEN
40004b1c: 92 10 00 1a mov %i2, %o1
{
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
40004b20: b0 07 60 58 add %i5, 0x58, %i0 <== NOT EXECUTED
40004b24: 7f ff fe c6 call 4000463c <rtems_fdisk_segment_queue_present><== NOT EXECUTED
40004b28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40004b2c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40004b30: 12 80 00 32 bne 40004bf8 <rtems_fdisk_queue_segment+0x16c><== NOT EXECUTED
40004b34: 01 00 00 00 nop <== NOT EXECUTED
40004b38: 30 80 00 2e b,a 40004bf0 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
40004b3c: b8 07 60 34 add %i5, 0x34, %i4
40004b40: 7f ff fe 84 call 40004550 <rtems_fdisk_segment_queue_remove>
40004b44: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
40004b48: 92 10 00 1a mov %i2, %o1
40004b4c: b0 07 60 40 add %i5, 0x40, %i0
40004b50: 7f ff fe 80 call 40004550 <rtems_fdisk_segment_queue_remove>
40004b54: 90 10 00 18 mov %i0, %o0
* If they are and the driver has been configured to background
* erase place the segment on the used queue. If not configured
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
40004b58: 7f ff fe f6 call 40004730 <rtems_fdisk_seg_pages_available>
40004b5c: 90 10 00 1a mov %i2, %o0
40004b60: b6 92 20 00 orcc %o0, 0, %i3
40004b64: 32 80 00 1d bne,a 40004bd8 <rtems_fdisk_queue_segment+0x14c>
40004b68: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
{
if (sc->pages_active)
40004b6c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
40004b70: 80 a0 60 00 cmp %g1, 0
40004b74: 22 80 00 0d be,a 40004ba8 <rtems_fdisk_queue_segment+0x11c><== NEVER TAKEN
40004b78: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
while (seg)
40004b7c: 10 80 00 07 b 40004b98 <rtems_fdisk_queue_segment+0x10c>
40004b80: f2 07 60 40 ld [ %i5 + 0x40 ], %i1
{
if (sc->pages_used > seg->pages_used)
40004b84: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40004b88: 80 a0 80 01 cmp %g2, %g1
40004b8c: 18 80 00 17 bgu 40004be8 <rtems_fdisk_queue_segment+0x15c>
40004b90: 01 00 00 00 nop
break;
seg = seg->next;
40004b94: 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)
40004b98: 80 a6 60 00 cmp %i1, 0
40004b9c: 32 bf ff fa bne,a 40004b84 <rtems_fdisk_queue_segment+0xf8>
40004ba0: c4 06 a0 20 ld [ %i2 + 0x20 ], %g2
40004ba4: 30 80 00 13 b,a 40004bf0 <rtems_fdisk_queue_segment+0x164>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
40004ba8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40004bac: 12 80 00 11 bne 40004bf0 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
40004bb0: b0 07 60 4c add %i5, 0x4c, %i0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
40004bb4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40004bb8: 7f ff ff 75 call 4000498c <rtems_fdisk_erase_segment> <== NOT EXECUTED
40004bbc: 93 e8 00 1a restore %g0, %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
rtems_fdisk_seg_pages_available (seg))
40004bc0: 7f ff fe dc call 40004730 <rtems_fdisk_seg_pages_available>
40004bc4: 90 10 00 19 mov %i1, %o0
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
40004bc8: 80 a6 c0 08 cmp %i3, %o0
40004bcc: 0a 80 00 07 bcs 40004be8 <rtems_fdisk_queue_segment+0x15c>
40004bd0: b0 10 00 1c mov %i4, %i0
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
40004bd4: 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)
40004bd8: 80 a6 60 00 cmp %i1, 0
40004bdc: 12 bf ff f9 bne 40004bc0 <rtems_fdisk_queue_segment+0x134>
40004be0: b0 10 00 1c mov %i4, %i0
40004be4: 30 80 00 03 b,a 40004bf0 <rtems_fdisk_queue_segment+0x164>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
40004be8: 7f ff fe 77 call 400045c4 <rtems_fdisk_segment_queue_insert_before>
40004bec: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
40004bf0: 7f ff fe 46 call 40004508 <rtems_fdisk_segment_queue_push_tail>
40004bf4: 93 e8 00 1a restore %g0, %i2, %o1
40004bf8: 81 c7 e0 08 ret <== NOT EXECUTED
40004bfc: 81 e8 00 00 restore <== NOT EXECUTED
40004de8 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
40004de8: 9d e3 bf 98 save %sp, -104, %sp
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
40004dec: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
40004df0: 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;
40004df4: c0 26 20 38 clr [ %i0 + 0x38 ]
40004df8: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
40004dfc: 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;
40004e00: c0 26 20 44 clr [ %i0 + 0x44 ]
40004e04: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
40004e08: 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;
40004e0c: c0 26 20 50 clr [ %i0 + 0x50 ]
40004e10: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
40004e14: 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;
40004e18: c0 26 20 5c clr [ %i0 + 0x5c ]
40004e1c: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
40004e20: 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));
40004e24: 92 10 20 00 clr %o1
40004e28: 95 2a a0 03 sll %o2, 3, %o2
40004e2c: 40 00 71 a1 call 400214b0 <memset>
40004e30: 27 10 00 c6 sethi %hi(0x40031800), %l3
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
40004e34: 29 10 00 c7 sethi %hi(0x40031c00), %l4
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
40004e38: 2b 10 00 c7 sethi %hi(0x40031c00), %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40004e3c: 2d 10 00 c7 sethi %hi(0x40031c00), %l6
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40004e40: 2f 10 00 c7 sethi %hi(0x40031c00), %l7
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
40004e44: ba 10 00 18 mov %i0, %i5
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
40004e48: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
40004e4c: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
40004e50: a2 10 20 00 clr %l1
40004e54: 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);
40004e58: a6 14 e3 c0 or %l3, 0x3c0, %l3
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
40004e5c: a8 15 20 a8 or %l4, 0xa8, %l4
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
40004e60: aa 15 60 78 or %l5, 0x78, %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40004e64: ac 15 a0 30 or %l6, 0x30, %l6
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
40004e68: 10 80 00 b3 b 40005134 <rtems_fdisk_recover_block_mappings+0x34c>
40004e6c: ae 15 e0 50 or %l7, 0x50, %l7
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40004e70: 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];
40004e74: b8 07 00 12 add %i4, %l2, %i4
const rtems_fdisk_segment_desc* sd = sc->descriptor;
40004e78: f6 07 20 04 ld [ %i4 + 4 ], %i3
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40004e7c: 96 10 00 10 mov %l0, %o3
40004e80: 92 10 00 13 mov %l3, %o1
40004e84: 7f ff fe 45 call 40004798 <rtems_fdisk_info>
40004e88: 90 10 00 1d mov %i5, %o0
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40004e8c: d0 06 e0 08 ld [ %i3 + 8 ], %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
40004e90: f4 07 60 14 ld [ %i5 + 0x14 ], %i2
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40004e94: 7f ff f5 fa call 4000267c <.udiv>
40004e98: 92 10 00 1a mov %i2, %o1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
40004e9c: 92 10 00 1a mov %i2, %o1
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40004ea0: b6 10 00 08 mov %o0, %i3
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
40004ea4: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
40004ea8: 7f ff f5 f5 call 4000267c <.udiv>
40004eac: 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)
40004eb0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
40004eb4: b0 02 20 01 add %o0, 1, %i0
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
40004eb8: 90 26 c0 18 sub %i3, %i0, %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
40004ebc: f0 27 20 18 st %i0, [ %i4 + 0x18 ]
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
40004ec0: 80 a2 00 01 cmp %o0, %g1
40004ec4: 08 80 00 03 bleu 40004ed0 <rtems_fdisk_recover_block_mappings+0xe8>
40004ec8: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
fd->starvation_threshold = sc->pages;
40004ecc: d0 27 60 24 st %o0, [ %i5 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
40004ed0: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
40004ed4: c0 27 20 1c clr [ %i4 + 0x1c ]
sc->pages_used = 0;
40004ed8: c0 27 20 20 clr [ %i4 + 0x20 ]
sc->pages_bad = 0;
40004edc: c0 27 20 24 clr [ %i4 + 0x24 ]
sc->failed = false;
if (!sc->page_descriptors)
40004ee0: 80 a0 60 00 cmp %g1, 0
40004ee4: 12 80 00 08 bne 40004f04 <rtems_fdisk_recover_block_mappings+0x11c><== NEVER TAKEN
40004ee8: c0 27 20 28 clr [ %i4 + 0x28 ]
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
40004eec: 92 10 00 1a mov %i2, %o1
40004ef0: 7f ff f5 a9 call 40002594 <.umul>
40004ef4: 90 10 00 18 mov %i0, %o0
40004ef8: 40 00 0b a4 call 40007d88 <malloc>
40004efc: 01 00 00 00 nop
40004f00: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
if (!sc->page_descriptors)
40004f04: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
40004f08: 80 a6 e0 00 cmp %i3, 0
40004f0c: 32 80 00 05 bne,a 40004f20 <rtems_fdisk_recover_block_mappings+0x138><== ALWAYS TAKEN
40004f10: 90 10 00 18 mov %i0, %o0
rtems_fdisk_abort ("no memory for page descriptors");
40004f14: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
40004f18: 40 00 07 bb call 40006e04 <rtems_fdisk_abort.constprop.0> <== NOT EXECUTED
40004f1c: 90 12 22 98 or %o0, 0x298, %o0 ! 40031a98 <__FUNCTION__.6193+0x290><== 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,
40004f20: 7f ff f5 9d call 40002594 <.umul>
40004f24: 92 10 00 1a mov %i2, %o1
40004f28: 92 10 00 1c mov %i4, %o1
40004f2c: 98 10 00 08 mov %o0, %o4
40004f30: 94 10 20 00 clr %o2
40004f34: 90 10 00 1d mov %i5, %o0
40004f38: 7f ff ff 32 call 40004c00 <rtems_fdisk_seg_read>
40004f3c: 96 10 00 1b mov %i3, %o3
sc->pages_desc * fd->block_size);
if (ret)
40004f40: b0 92 20 00 orcc %o0, 0, %i0
40004f44: 22 80 00 6a be,a 400050ec <rtems_fdisk_recover_block_mappings+0x304><== ALWAYS TAKEN
40004f48: b4 10 20 00 clr %i2
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
40004f4c: 40 00 76 43 call 40022858 <strerror> <== NOT EXECUTED
40004f50: 01 00 00 00 nop <== NOT EXECUTED
40004f54: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40004f58: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40004f5c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40004f60: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
40004f64: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40004f68: 7f ff fe 6c call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40004f6c: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
40004f70: 81 c7 e0 08 ret <== NOT EXECUTED
40004f74: 81 e8 00 00 restore <== NOT EXECUTED
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
40004f78: 7f ff fd e4 call 40004708 <rtems_fdisk_page_desc_erased>
40004f7c: 90 10 00 1b mov %i3, %o0
40004f80: 80 8a 20 ff btst 0xff, %o0
40004f84: 22 80 00 2b be,a 40005030 <rtems_fdisk_recover_block_mappings+0x248><== NEVER TAKEN
40004f88: c2 16 e0 02 lduh [ %i3 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
page * fd->block_size, fd->block_size);
40004f8c: f0 07 60 14 ld [ %i5 + 0x14 ], %i0
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
40004f90: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
40004f94: 92 10 00 18 mov %i0, %o1
40004f98: 7f ff f5 7f call 40002594 <.umul>
40004f9c: 90 06 80 08 add %i2, %o0, %o0
40004fa0: 92 10 00 1c mov %i4, %o1
40004fa4: 94 10 00 08 mov %o0, %o2
40004fa8: 96 10 00 18 mov %i0, %o3
40004fac: 7f ff ff 37 call 40004c88 <rtems_fdisk_seg_blank_check>
40004fb0: 90 10 00 1d mov %i5, %o0
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
40004fb4: 80 a2 20 00 cmp %o0, 0
40004fb8: 32 80 00 06 bne,a 40004fd0 <rtems_fdisk_recover_block_mappings+0x1e8><== NEVER TAKEN
40004fbc: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
40004fc0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40004fc4: 82 00 60 01 inc %g1
40004fc8: 10 80 00 47 b 400050e4 <rtems_fdisk_recover_block_mappings+0x2fc>
40004fcc: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40004fd0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
40004fd4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40004fd8: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
40004fdc: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
40004fe0: 7f ff fe 2e call 40004898 <rtems_fdisk_warning> <== NOT EXECUTED
40004fe4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40004fe8: c2 16 e0 02 lduh [ %i3 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
40004fec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40004ff0: 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,
40004ff4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40004ff8: c2 36 e0 02 sth %g1, [ %i3 + 2 ] <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
40004ffc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40005000: 7f ff ff 69 call 40004da4 <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
40005004: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
page, pd);
if (ret)
40005008: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000500c: 22 80 00 0d be,a 40005040 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
40005010: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40005014: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
40005018: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000501c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40005020: 7f ff fe 3e call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005024: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
{
sc->pages_used++;
40005028: 10 80 00 06 b 40005040 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
4000502c: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
40005030: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40005034: 12 80 00 06 bne 4000504c <rtems_fdisk_recover_block_mappings+0x264><== NOT EXECUTED
40005038: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
{
sc->pages_used++;
4000503c: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
40005040: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005044: 10 80 00 28 b 400050e4 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
40005048: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
4000504c: 32 80 00 24 bne,a 400050dc <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
40005050: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
40005054: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
40005058: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4000505c: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
40005060: 2a 80 00 0a bcs,a 40005088 <rtems_fdisk_recover_block_mappings+0x2a0><== NOT EXECUTED
40005064: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
40005068: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000506c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
40005070: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005074: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
40005078: 7f ff fe 08 call 40004898 <rtems_fdisk_warning> <== NOT EXECUTED
4000507c: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
40005080: 10 80 00 17 b 400050dc <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
40005084: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
}
else if (fd->blocks[pd->block].segment)
40005088: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
4000508c: c4 00 40 0d ld [ %g1 + %o5 ], %g2 <== NOT EXECUTED
40005090: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40005094: 02 80 00 0c be 400050c4 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
40005098: 86 00 40 0d add %g1, %o5, %g3 <== NOT EXECUTED
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
4000509c: d2 00 a0 08 ld [ %g2 + 8 ], %o1 <== NOT EXECUTED
400050a0: d4 00 a0 0c ld [ %g2 + 0xc ], %o2 <== NOT EXECUTED
400050a4: d6 00 e0 04 ld [ %g3 + 4 ], %o3 <== NOT EXECUTED
400050a8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
400050ac: f4 23 a0 5c st %i2, [ %sp + 0x5c ] <== NOT EXECUTED
400050b0: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
400050b4: 7f ff fe 19 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
400050b8: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
400050bc: 10 80 00 08 b 400050dc <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
400050c0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
400050c4: f8 20 40 0d st %i4, [ %g1 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
400050c8: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
fd->blocks[pd->block].page = page;
400050cc: f4 20 e0 04 st %i2, [ %g3 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
400050d0: 82 00 60 01 inc %g1 <== NOT EXECUTED
400050d4: 10 80 00 04 b 400050e4 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
400050d8: c2 27 20 1c st %g1, [ %i4 + 0x1c ] <== NOT EXECUTED
}
}
else
sc->pages_bad++;
400050dc: 82 00 60 01 inc %g1 <== NOT EXECUTED
400050e0: c2 27 20 24 st %g1, [ %i4 + 0x24 ] <== NOT EXECUTED
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
400050e4: b4 06 a0 01 inc %i2
400050e8: b6 06 e0 08 add %i3, 8, %i3
400050ec: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
400050f0: 80 a6 80 01 cmp %i2, %g1
400050f4: 0a bf ff a1 bcs 40004f78 <rtems_fdisk_recover_block_mappings+0x190>
400050f8: 90 10 00 1d mov %i5, %o0
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
400050fc: 92 10 00 1c mov %i4, %o1
40005100: 7f ff fe 63 call 40004a8c <rtems_fdisk_queue_segment>
40005104: a0 04 20 01 inc %l0
40005108: 10 80 00 03 b 40005114 <rtems_fdisk_recover_block_mappings+0x32c>
4000510c: a4 04 a0 30 add %l2, 0x30, %l2
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
40005110: a0 10 20 00 clr %l0
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
40005114: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40005118: 84 00 40 11 add %g1, %l1, %g2
4000511c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40005120: 80 a4 00 02 cmp %l0, %g2
40005124: 2a bf ff 53 bcs,a 40004e70 <rtems_fdisk_recover_block_mappings+0x88>
40005128: f8 00 40 11 ld [ %g1 + %l1 ], %i4
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
4000512c: b2 06 60 01 inc %i1
40005130: a2 04 60 0c add %l1, 0xc, %l1
40005134: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40005138: 80 a6 40 01 cmp %i1, %g1
4000513c: 0a bf ff f5 bcs 40005110 <rtems_fdisk_recover_block_mappings+0x328>
40005140: a4 10 20 00 clr %l2
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
}
40005144: 81 c7 e0 08 ret
40005148: 91 e8 20 00 restore %g0, 0, %o0
400051b8 <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)
{
400051b8: 9d e3 bf 80 save %sp, -128, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
400051bc: 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);
400051c0: 82 06 20 34 add %i0, 0x34, %g1
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
400051c4: aa 10 00 19 mov %i1, %l5
400051c8: a2 10 00 1a mov %i2, %l1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
400051cc: c0 27 bf fc clr [ %fp + -4 ]
for (spage = 0; spage < ssc->pages; spage++)
400051d0: b8 10 20 00 clr %i4
400051d4: 10 80 00 c2 b 400054dc <rtems_fdisk_recycle_segment+0x324>
400051d8: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
400051dc: ad 2f 20 03 sll %i4, 3, %l6
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
400051e0: 80 a4 60 00 cmp %l1, 0
400051e4: 12 80 00 0b bne 40005210 <rtems_fdisk_recycle_segment+0x58>
400051e8: a0 05 c0 16 add %l7, %l6, %l0
400051ec: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
400051f0: 80 a0 e0 00 cmp %g3, 0
400051f4: 22 80 00 08 be,a 40005214 <rtems_fdisk_recycle_segment+0x5c><== ALWAYS TAKEN
400051f8: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
400051fc: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
40005200: 7f ff fd c6 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005204: 90 12 20 d8 or %o0, 0xd8, %o0 ! 40031cd8 <__FUNCTION__.6193+0x4d0><== 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;
40005208: 10 80 00 ca b 40005530 <rtems_fdisk_recycle_segment+0x378><== NOT EXECUTED
4000520c: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
40005210: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
40005214: 80 88 e0 01 btst 1, %g3
40005218: 12 80 00 a8 bne 400054b8 <rtems_fdisk_recycle_segment+0x300><== NEVER TAKEN
4000521c: 80 88 e0 02 btst 2, %g3
40005220: 02 80 00 a6 be 400054b8 <rtems_fdisk_recycle_segment+0x300>
40005224: ba 10 20 00 clr %i5
* Find the next available page in a segment.
*/
static uint32_t
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
40005228: e6 04 60 10 ld [ %l1 + 0x10 ], %l3
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
4000522c: 10 80 00 08 b 4000524c <rtems_fdisk_recycle_segment+0x94>
40005230: e8 04 60 14 ld [ %l1 + 0x14 ], %l4
if (rtems_fdisk_page_desc_erased (pd))
40005234: 7f ff fd 35 call 40004708 <rtems_fdisk_page_desc_erased>
40005238: 01 00 00 00 nop
4000523c: 80 8a 20 ff btst 0xff, %o0
40005240: 12 80 00 08 bne 40005260 <rtems_fdisk_recycle_segment+0xa8>
40005244: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
40005248: ba 07 60 01 inc %i5
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
4000524c: 91 2f 60 03 sll %i5, 3, %o0
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
40005250: 80 a7 40 14 cmp %i5, %l4
40005254: 12 bf ff f8 bne 40005234 <rtems_fdisk_recycle_segment+0x7c><== ALWAYS TAKEN
40005258: 90 04 c0 08 add %l3, %o0, %o0
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
4000525c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
40005260: b3 2f 60 03 sll %i5, 3, %i1
active++;
40005264: 82 00 60 01 inc %g1
40005268: c2 27 bf fc st %g1, [ %fp + -4 ]
if (dpage >= dsc->pages)
4000526c: 80 a7 40 14 cmp %i5, %l4
40005270: 0a 80 00 14 bcs 400052c0 <rtems_fdisk_recycle_segment+0x108><== ALWAYS TAKEN
40005274: b4 04 c0 19 add %l3, %i1, %i2
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
40005278: 7f ff fd 2e call 40004730 <rtems_fdisk_seg_pages_available><== NOT EXECUTED
4000527c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40005280: d2 04 60 08 ld [ %l1 + 8 ], %o1 <== NOT EXECUTED
40005284: d4 04 60 0c ld [ %l1 + 0xc ], %o2 <== NOT EXECUTED
40005288: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4000528c: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
40005290: 7f ff fd a2 call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005294: 90 12 21 00 or %o0, 0x100, %o0 ! 40031d00 <__FUNCTION__.6193+0x4f8><== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
40005298: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
4000529c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400052a0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
400052a4: 7f ff fd fa call 40004a8c <rtems_fdisk_queue_segment> <== NOT EXECUTED
400052a8: c6 24 60 28 st %g3, [ %l1 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
400052ac: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
400052b0: 7f ff fc 77 call 4000448c <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
400052b4: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return EIO;
400052b8: 10 80 00 9e b 40005530 <rtems_fdisk_recycle_segment+0x378><== NOT EXECUTED
400052bc: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
400052c0: da 04 60 08 ld [ %l1 + 8 ], %o5
400052c4: c6 04 60 0c ld [ %l1 + 0xc ], %g3
400052c8: d4 05 60 08 ld [ %l5 + 8 ], %o2
400052cc: d6 05 60 0c ld [ %l5 + 0xc ], %o3
400052d0: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
400052d4: 98 10 00 1c mov %i4, %o4
400052d8: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
400052dc: 90 10 00 18 mov %i0, %o0
400052e0: 13 10 00 c7 sethi %hi(0x40031c00), %o1
400052e4: 7f ff fd 2d call 40004798 <rtems_fdisk_info>
400052e8: 92 12 61 30 or %o1, 0x130, %o1 ! 40031d30 <__FUNCTION__.6193+0x528>
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
400052ec: c8 04 60 18 ld [ %l1 + 0x18 ], %g4
400052f0: c6 05 60 18 ld [ %l5 + 0x18 ], %g3
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
400052f4: da 04 60 08 ld [ %l1 + 8 ], %o5
400052f8: de 04 60 0c ld [ %l1 + 0xc ], %o7
400052fc: d4 05 60 08 ld [ %l5 + 8 ], %o2
40005300: d6 05 60 0c ld [ %l5 + 0xc ], %o3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
40005304: 88 07 40 04 add %i5, %g4, %g4
40005308: 86 07 00 03 add %i4, %g3, %g3
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
4000530c: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
40005310: 98 10 00 03 mov %g3, %o4
40005314: c8 27 bf f0 st %g4, [ %fp + -16 ]
40005318: de 23 a0 5c st %o7, [ %sp + 0x5c ]
4000531c: c6 27 bf f4 st %g3, [ %fp + -12 ]
40005320: 90 10 00 18 mov %i0, %o0
40005324: 13 10 00 c7 sethi %hi(0x40031c00), %o1
40005328: 7f ff fd 3c call 40004818 <rtems_fdisk_printf>
4000532c: 92 12 61 58 or %o1, 0x158, %o1 ! 40031d58 <__FUNCTION__.6193+0x550>
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,
40005330: c6 07 bf f4 ld [ %fp + -12 ], %g3
page * fd->block_size, buffer, fd->block_size);
40005334: e8 06 20 14 ld [ %i0 + 0x14 ], %l4
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
40005338: 90 10 00 03 mov %g3, %o0
4000533c: 7f ff f4 96 call 40002594 <.umul>
40005340: 92 10 00 14 mov %l4, %o1
40005344: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
40005348: 94 10 00 08 mov %o0, %o2
4000534c: 98 10 00 14 mov %l4, %o4
40005350: 90 10 00 18 mov %i0, %o0
40005354: 7f ff fe 2b call 40004c00 <rtems_fdisk_seg_read>
40005358: 92 10 00 15 mov %l5, %o1
src_sc->device, src_sc->segment, src_page,
dst_sc->device, dst_sc->segment, dst_page);
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
4000535c: a8 92 20 00 orcc %o0, 0, %l4
40005360: 12 80 00 0a bne 40005388 <rtems_fdisk_recycle_segment+0x1d0><== NEVER TAKEN
40005364: c8 07 bf f0 ld [ %fp + -16 ], %g4
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
40005368: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
4000536c: 90 10 00 18 mov %i0, %o0
40005370: 92 10 00 11 mov %l1, %o1
40005374: 7f ff ff 76 call 4000514c <rtems_fdisk_seg_write_page>
40005378: 94 10 00 04 mov %g4, %o2
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
4000537c: a8 92 20 00 orcc %o0, 0, %l4
40005380: 22 80 00 0e be,a 400053b8 <rtems_fdisk_recycle_segment+0x200><== ALWAYS TAKEN
40005384: c6 05 c0 16 ld [ %l7 + %l6 ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
40005388: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
4000538c: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
40005390: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
40005394: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
40005398: 40 00 75 30 call 40022858 <strerror> <== NOT EXECUTED
4000539c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
400053a0: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
400053a4: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
400053a8: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
400053ac: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
400053b0: 10 80 00 17 b 4000540c <rtems_fdisk_recycle_segment+0x254><== NOT EXECUTED
400053b4: 90 12 21 88 or %o0, 0x188, %o0 ! 40031d88 <__FUNCTION__.6193+0x580><== NOT EXECUTED
return ret;
}
*dpd = *spd;
ret = rtems_fdisk_seg_write_page_desc (fd,
400053b8: 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;
400053bc: c6 24 c0 19 st %g3, [ %l3 + %i1 ]
400053c0: c6 04 20 04 ld [ %l0 + 4 ], %g3
ret = rtems_fdisk_seg_write_page_desc (fd,
400053c4: 92 10 00 11 mov %l1, %o1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
400053c8: c6 26 a0 04 st %g3, [ %i2 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
400053cc: 94 10 00 1d mov %i5, %o2
400053d0: 7f ff fe 75 call 40004da4 <rtems_fdisk_seg_write_page_desc>
400053d4: 96 10 00 1a mov %i2, %o3
dsc,
dpage, dpd);
if (ret)
400053d8: a8 92 20 00 orcc %o0, 0, %l4
400053dc: 22 80 00 1a be,a 40005444 <rtems_fdisk_recycle_segment+0x28c><== ALWAYS TAKEN
400053e0: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
400053e4: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
400053e8: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
400053ec: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
400053f0: 40 00 75 1a call 40022858 <strerror> <== NOT EXECUTED
400053f4: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
400053f8: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
400053fc: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
40005400: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
40005404: 11 10 00 c7 sethi %hi(0x40031c00), %o0 <== NOT EXECUTED
40005408: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 40031dd0 <__FUNCTION__.6193+0x5c8><== NOT EXECUTED
4000540c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40005410: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005414: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
40005418: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000541c: 7f ff fd 3f call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005420: 9a 10 00 1b mov %i3, %o5 <== NOT EXECUTED
"%02d-%03d-%03d: copy pd failed: %s (%d)",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage,
strerror (ret), ret);
rtems_fdisk_queue_segment (fd, dsc);
40005424: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005428: 7f ff fd 99 call 40004a8c <rtems_fdisk_queue_segment> <== NOT EXECUTED
4000542c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
40005430: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
40005434: 7f ff fc 16 call 4000448c <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
40005438: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return ret;
4000543c: 81 c7 e0 08 ret <== NOT EXECUTED
40005440: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
40005444: c8 06 20 18 ld [ %i0 + 0x18 ], %g4
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
40005448: 86 00 e0 01 inc %g3
4000544c: c6 24 60 1c st %g3, [ %l1 + 0x1c ]
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
40005450: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
40005454: 90 10 00 18 mov %i0, %o0
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
40005458: 86 00 ff ff add %g3, -1, %g3
4000545c: c6 25 60 1c st %g3, [ %l5 + 0x1c ]
ssc->pages_used++;
40005460: c6 05 60 20 ld [ %l5 + 0x20 ], %g3
40005464: 86 00 e0 01 inc %g3
40005468: c6 25 60 20 st %g3, [ %l5 + 0x20 ]
fd->blocks[spd->block].segment = dsc;
4000546c: c6 04 20 04 ld [ %l0 + 4 ], %g3
40005470: 87 28 e0 03 sll %g3, 3, %g3
40005474: 9e 01 00 03 add %g4, %g3, %o7
40005478: e2 21 00 03 st %l1, [ %g4 + %g3 ]
fd->blocks[spd->block].page = dpage;
4000547c: fa 23 e0 04 st %i5, [ %o7 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
40005480: 7f ff fd 83 call 40004a8c <rtems_fdisk_queue_segment>
40005484: 92 10 00 11 mov %l1, %o1
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
40005488: 7f ff fc aa call 40004730 <rtems_fdisk_seg_pages_available>
4000548c: 90 10 00 11 mov %l1, %o0
if (dst_pages == 0)
40005490: 80 a2 20 00 cmp %o0, 0
40005494: 32 80 00 06 bne,a 400054ac <rtems_fdisk_recycle_segment+0x2f4>
40005498: c6 06 c0 00 ld [ %i3 ], %g3
dsc = rtems_fdisk_seg_most_available (&fd->available);
4000549c: 7f ff fc ad call 40004750 <rtems_fdisk_seg_most_available>
400054a0: d0 07 bf f8 ld [ %fp + -8 ], %o0
400054a4: a2 10 00 08 mov %o0, %l1
(*pages)--;
400054a8: c6 06 c0 00 ld [ %i3 ], %g3
400054ac: 86 00 ff ff add %g3, -1, %g3
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
400054b0: 10 80 00 0a b 400054d8 <rtems_fdisk_recycle_segment+0x320>
400054b4: c6 26 c0 00 st %g3, [ %i3 ]
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
400054b8: 7f ff fc 94 call 40004708 <rtems_fdisk_page_desc_erased>
400054bc: 90 10 00 10 mov %l0, %o0
400054c0: 80 8a 20 ff btst 0xff, %o0
400054c4: 22 80 00 05 be,a 400054d8 <rtems_fdisk_recycle_segment+0x320><== ALWAYS TAKEN
400054c8: a4 04 a0 01 inc %l2
{
--fd->erased_blocks;
400054cc: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 <== NOT EXECUTED
400054d0: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
400054d4: c6 26 20 28 st %g3, [ %i0 + 0x28 ] <== NOT EXECUTED
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
400054d8: b8 07 20 01 inc %i4
400054dc: c6 05 60 14 ld [ %l5 + 0x14 ], %g3
400054e0: 80 a7 00 03 cmp %i4, %g3
400054e4: 2a bf ff 3e bcs,a 400051dc <rtems_fdisk_recycle_segment+0x24>
400054e8: ee 05 60 10 ld [ %l5 + 0x10 ], %l7
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
400054ec: d4 05 60 08 ld [ %l5 + 8 ], %o2
400054f0: d6 05 60 0c ld [ %l5 + 0xc ], %o3
400054f4: da 07 bf fc ld [ %fp + -4 ], %o5
400054f8: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
400054fc: 90 10 00 18 mov %i0, %o0
40005500: 13 10 00 c7 sethi %hi(0x40031c00), %o1
40005504: 98 10 00 1b mov %i3, %o4
40005508: 7f ff fc c4 call 40004818 <rtems_fdisk_printf>
4000550c: 92 12 62 18 or %o1, 0x218, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
40005510: d2 05 60 1c ld [ %l5 + 0x1c ], %o1
40005514: 80 a2 60 00 cmp %o1, 0
40005518: 02 80 00 04 be 40005528 <rtems_fdisk_recycle_segment+0x370><== ALWAYS TAKEN
4000551c: 11 10 00 c7 sethi %hi(0x40031c00), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
40005520: 7f ff fc fe call 40004918 <rtems_fdisk_error> <== NOT EXECUTED
40005524: 90 12 22 40 or %o0, 0x240, %o0 ! 40031e40 <__FUNCTION__.6193+0x638><== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
40005528: 7f ff fd 19 call 4000498c <rtems_fdisk_erase_segment>
4000552c: 93 e8 00 15 restore %g0, %l5, %o1
return ret;
}
40005530: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
40005534: 81 c7 e0 08 ret <== NOT EXECUTED
40005538: 81 e8 00 00 restore <== NOT EXECUTED
40004d0c <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)
{
40004d0c: 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;
40004d10: e0 06 60 08 ld [ %i1 + 8 ], %l0
segment = sc->segment;
40004d14: 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;
40004d18: 85 2c 20 04 sll %l0, 4, %g2
40004d1c: 83 2c 20 02 sll %l0, 2, %g1
40004d20: 82 20 80 01 sub %g2, %g1, %g1
40004d24: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40004d28: 89 2f 60 06 sll %i5, 6, %g4
40004d2c: 86 00 80 01 add %g2, %g1, %g3
40004d30: c4 00 80 01 ld [ %g2 + %g1 ], %g2
40004d34: 83 2f 60 04 sll %i5, 4, %g1
40004d38: 82 21 00 01 sub %g4, %g1, %g1
40004d3c: 82 00 80 01 add %g2, %g1, %g1
40004d40: e2 00 60 04 ld [ %g1 + 4 ], %l1
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
40004d44: c2 00 e0 08 ld [ %g3 + 8 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
40004d48: 90 10 00 18 mov %i0, %o0
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
40004d4c: e4 00 60 08 ld [ %g1 + 8 ], %l2
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
40004d50: 94 10 00 10 mov %l0, %o2
40004d54: 96 10 00 1d mov %i5, %o3
40004d58: 98 10 00 1a mov %i2, %o4
40004d5c: 9a 10 00 1c mov %i4, %o5
40004d60: 13 10 00 c6 sethi %hi(0x40031800), %o1
40004d64: 7f ff fe ad call 40004818 <rtems_fdisk_printf>
40004d68: 92 12 63 98 or %o1, 0x398, %o1 ! 40031b98 <__FUNCTION__.6193+0x390>
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
40004d6c: c2 04 a0 04 ld [ %l2 + 4 ], %g1
40004d70: 90 10 00 11 mov %l1, %o0
40004d74: 92 10 00 10 mov %l0, %o1
40004d78: 94 10 00 1d mov %i5, %o2
40004d7c: 96 10 00 1a mov %i2, %o3
40004d80: 98 10 00 1b mov %i3, %o4
40004d84: 9f c0 40 00 call %g1
40004d88: 9a 10 00 1c mov %i4, %o5
if (ret)
40004d8c: b0 92 20 00 orcc %o0, 0, %i0
40004d90: 02 80 00 03 be 40004d9c <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
40004d94: 82 10 20 01 mov 1, %g1
sc->failed = true;
40004d98: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
40004d9c: 81 c7 e0 08 ret
40004da0: 81 e8 00 00 restore
4000514c <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)
{
4000514c: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
40005150: c2 06 20 08 ld [ %i0 + 8 ], %g1
40005154: 80 88 60 08 btst 8, %g1
40005158: 32 80 00 0b bne,a 40005184 <rtems_fdisk_seg_write_page+0x38><== ALWAYS TAKEN
4000515c: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
{
int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
if (ret)
return ret;
}
--fd->erased_blocks;
40005160: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
40005164: 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;
40005168: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
4000516c: 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;
40005170: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
40005174: 7f ff f5 08 call 40002594 <.umul>
40005178: 92 10 00 1c mov %i4, %o1
4000517c: 7f ff fe e4 call 40004d0c <rtems_fdisk_seg_write>
40005180: 95 e8 00 08 restore %g0, %o0, %o2
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
40005184: 90 10 00 1a mov %i2, %o0
40005188: 7f ff f5 03 call 40002594 <.umul>
4000518c: 92 10 00 1d mov %i5, %o1
40005190: 92 10 00 19 mov %i1, %o1
40005194: 94 10 00 08 mov %o0, %o2
40005198: 96 10 00 1d mov %i5, %o3
4000519c: 7f ff fe bb call 40004c88 <rtems_fdisk_seg_blank_check>
400051a0: 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)
400051a4: 80 a2 20 00 cmp %o0, 0
400051a8: 22 bf ff ef be,a 40005164 <rtems_fdisk_seg_write_page+0x18><== ALWAYS TAKEN
400051ac: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return ret;
}
--fd->erased_blocks;
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
}
400051b0: 81 c7 e0 08 ret <== NOT EXECUTED
400051b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40004da4 <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)
{
40004da4: 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))
40004da8: c2 06 20 08 ld [ %i0 + 8 ], %g1
40004dac: 80 88 60 08 btst 8, %g1
40004db0: 12 80 00 04 bne 40004dc0 <rtems_fdisk_seg_write_page_desc+0x1c><== ALWAYS TAKEN
40004db4: b5 2e a0 03 sll %i2, 3, %i2
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
40004db8: 7f ff ff d5 call 40004d0c <rtems_fdisk_seg_write>
40004dbc: 99 e8 20 08 restore %g0, 8, %o4
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = page * sizeof (rtems_fdisk_page_desc);
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
40004dc0: 90 10 00 18 mov %i0, %o0
40004dc4: 92 10 00 19 mov %i1, %o1
40004dc8: 94 10 00 1a mov %i2, %o2
40004dcc: 7f ff ff af call 40004c88 <rtems_fdisk_seg_blank_check>
40004dd0: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
40004dd4: 80 a2 20 00 cmp %o0, 0
40004dd8: 02 bf ff f8 be 40004db8 <rtems_fdisk_seg_write_page_desc+0x14><== ALWAYS TAKEN
40004ddc: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
page_desc, sizeof (rtems_fdisk_page_desc));
}
40004de0: 81 c7 e0 08 ret <== NOT EXECUTED
40004de4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400045c4 <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)
400045c4: 80 a2 60 00 cmp %o1, 0
400045c8: 02 80 00 10 be 40004608 <rtems_fdisk_segment_queue_insert_before+0x44><== NEVER TAKEN
400045cc: 84 10 00 08 mov %o0, %g2
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
400045d0: 10 80 00 0b b 400045fc <rtems_fdisk_segment_queue_insert_before+0x38>
400045d4: c2 02 00 00 ld [ %o0 ], %g1
{
if (item == it)
400045d8: 32 80 00 08 bne,a 400045f8 <rtems_fdisk_segment_queue_insert_before+0x34>
400045dc: 84 10 00 01 mov %g1, %g2
{
sc->next = item;
400045e0: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
queue->count++;
400045e4: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
*prev = sc;
400045e8: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
400045ec: 82 00 60 01 inc %g1
return;
400045f0: 81 c3 e0 08 retl
400045f4: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = &it->next;
it = it->next;
400045f8: c2 00 40 00 ld [ %g1 ], %g1
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
400045fc: 80 a0 60 00 cmp %g1, 0
40004600: 12 bf ff f6 bne 400045d8 <rtems_fdisk_segment_queue_insert_before+0x14><== ALWAYS TAKEN
40004604: 80 a2 40 01 cmp %o1, %g1
prev = &it->next;
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
40004608: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4000460c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40004610: 7f ff ff be call 40004508 <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
40004614: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400044c8 <rtems_fdisk_segment_queue_pop_head>:
/**
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
400044c8: 82 10 00 08 mov %o0, %g1
if (queue->head)
400044cc: d0 02 00 00 ld [ %o0 ], %o0
400044d0: 80 a2 20 00 cmp %o0, 0
400044d4: 02 80 00 0b be 40004500 <rtems_fdisk_segment_queue_pop_head+0x38><== NEVER TAKEN
400044d8: 01 00 00 00 nop
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400044dc: c4 02 00 00 ld [ %o0 ], %g2
if (!queue->head)
400044e0: 80 a0 a0 00 cmp %g2, 0
400044e4: 12 80 00 03 bne 400044f0 <rtems_fdisk_segment_queue_pop_head+0x28>
400044e8: c4 20 40 00 st %g2, [ %g1 ]
queue->tail = 0;
400044ec: c0 20 60 04 clr [ %g1 + 4 ]
queue->count--;
400044f0: c4 00 60 08 ld [ %g1 + 8 ], %g2
400044f4: 84 00 bf ff add %g2, -1, %g2
400044f8: c4 20 60 08 st %g2, [ %g1 + 8 ]
sc->next = 0;
400044fc: c0 22 00 00 clr [ %o0 ]
return sc;
}
return 0;
}
40004500: 81 c3 e0 08 retl
4000448c <rtems_fdisk_segment_queue_push_head>:
*/
static void
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
4000448c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
40004490: 02 80 00 0c be 400044c0 <rtems_fdisk_segment_queue_push_head+0x34><== NOT EXECUTED
40004494: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = queue->head;
40004498: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
4000449c: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
400044a0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
400044a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400044a8: 12 80 00 03 bne 400044b4 <rtems_fdisk_segment_queue_push_head+0x28><== NOT EXECUTED
400044ac: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED
queue->tail = sc;
400044b0: d2 22 20 04 st %o1, [ %o0 + 4 ] <== NOT EXECUTED
queue->count++;
400044b4: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
400044b8: 82 00 60 01 inc %g1 <== NOT EXECUTED
400044bc: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
400044c0: 81 c3 e0 08 retl <== NOT EXECUTED
40004508 <rtems_fdisk_segment_queue_push_tail>:
*/
static void
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
40004508: 80 a2 60 00 cmp %o1, 0
4000450c: 02 80 00 0f be 40004548 <rtems_fdisk_segment_queue_push_tail+0x40><== NEVER TAKEN
40004510: 01 00 00 00 nop
{
sc->next = 0;
if (queue->head)
40004514: c2 02 00 00 ld [ %o0 ], %g1
40004518: 80 a0 60 00 cmp %g1, 0
4000451c: 02 80 00 06 be 40004534 <rtems_fdisk_segment_queue_push_tail+0x2c>
40004520: c0 22 40 00 clr [ %o1 ]
{
queue->tail->next = sc;
40004524: c2 02 20 04 ld [ %o0 + 4 ], %g1
40004528: d2 20 40 00 st %o1, [ %g1 ]
queue->tail = sc;
4000452c: 10 80 00 04 b 4000453c <rtems_fdisk_segment_queue_push_tail+0x34>
40004530: d2 22 20 04 st %o1, [ %o0 + 4 ]
}
else
{
queue->head = queue->tail = sc;
40004534: d2 22 20 04 st %o1, [ %o0 + 4 ]
40004538: d2 22 00 00 st %o1, [ %o0 ]
}
queue->count++;
4000453c: c2 02 20 08 ld [ %o0 + 8 ], %g1
40004540: 82 00 60 01 inc %g1
40004544: c2 22 20 08 st %g1, [ %o0 + 8 ]
40004548: 81 c3 e0 08 retl
40004550 <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;
40004550: c2 02 00 00 ld [ %o0 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
40004554: 10 80 00 17 b 400045b0 <rtems_fdisk_segment_queue_remove+0x60>
40004558: 84 10 20 00 clr %g2
{
if (sc == it)
4000455c: 32 80 00 14 bne,a 400045ac <rtems_fdisk_segment_queue_remove+0x5c>
40004560: 84 10 00 01 mov %g1, %g2
{
if (prev == 0)
40004564: 80 a0 a0 00 cmp %g2, 0
40004568: 12 80 00 07 bne 40004584 <rtems_fdisk_segment_queue_remove+0x34>
4000456c: c2 02 40 00 ld [ %o1 ], %g1
{
queue->head = sc->next;
if (queue->head == 0)
40004570: 80 a0 60 00 cmp %g1, 0
40004574: 12 80 00 09 bne 40004598 <rtems_fdisk_segment_queue_remove+0x48>
40004578: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
4000457c: 10 80 00 07 b 40004598 <rtems_fdisk_segment_queue_remove+0x48>
40004580: c0 22 20 04 clr [ %o0 + 4 ]
}
else
{
prev->next = sc->next;
40004584: c2 20 80 00 st %g1, [ %g2 ]
if (queue->tail == sc)
40004588: c2 02 20 04 ld [ %o0 + 4 ], %g1
4000458c: 80 a0 40 09 cmp %g1, %o1
40004590: 22 80 00 02 be,a 40004598 <rtems_fdisk_segment_queue_remove+0x48><== ALWAYS TAKEN
40004594: c4 22 20 04 st %g2, [ %o0 + 4 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
40004598: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
4000459c: c0 22 40 00 clr [ %o1 ]
queue->count--;
400045a0: 82 00 7f ff add %g1, -1, %g1
break;
400045a4: 81 c3 e0 08 retl
400045a8: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = it;
it = it->next;
400045ac: c2 00 40 00 ld [ %g1 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
400045b0: 80 a0 60 00 cmp %g1, 0
400045b4: 12 bf ff ea bne 4000455c <rtems_fdisk_segment_queue_remove+0xc>
400045b8: 80 a2 40 01 cmp %o1, %g1
400045bc: 81 c3 e0 08 retl
40004898 <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, ...)
{
40004898: 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);
4000489c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
400048a0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
400048a4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
400048a8: 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)
400048ac: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
400048b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400048b4: 02 80 00 17 be 40004910 <rtems_fdisk_warning+0x78> <== NOT EXECUTED
400048b8: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
400048bc: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
400048c0: 3b 10 00 da sethi %hi(0x40036800), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
400048c4: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
400048c8: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
400048cc: 11 10 00 c6 sethi %hi(0x40031800), %o0 <== NOT EXECUTED
400048d0: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
400048d4: 40 00 70 6b call 40020a80 <fputs> <== NOT EXECUTED
400048d8: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
400048dc: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
400048e0: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
400048e4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
400048e8: 40 00 93 62 call 40029670 <vfprintf> <== NOT EXECUTED
400048ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
400048f0: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
400048f4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
400048f8: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
400048fc: 40 00 70 2d call 400209b0 <fputc> <== NOT EXECUTED
40004900: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
40004904: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
40004908: 40 00 6f 12 call 40020550 <fflush> <== NOT EXECUTED
4000490c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40004910: 81 c7 e0 08 ret <== NOT EXECUTED
40004914: 81 e8 00 00 restore <== NOT EXECUTED
4000b970 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
4000b970: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
4000b974: 7f ff ff 05 call 4000b588 <geteuid>
4000b978: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
4000b97c: 91 2a 20 10 sll %o0, 0x10, %o0
4000b980: 91 32 20 10 srl %o0, 0x10, %o0
4000b984: 80 a2 00 1a cmp %o0, %i2
4000b988: 22 80 00 12 be,a 4000b9d0 <rtems_filesystem_check_access+0x60>
4000b98c: b1 2e 20 06 sll %i0, 6, %i0
4000b990: 80 a2 20 00 cmp %o0, 0
4000b994: 12 80 00 04 bne 4000b9a4 <rtems_filesystem_check_access+0x34>
4000b998: 01 00 00 00 nop
perm_flags <<= RTEMS_FS_USR_SHIFT;
4000b99c: 10 80 00 0d b 4000b9d0 <rtems_filesystem_check_access+0x60>
4000b9a0: b1 2e 20 06 sll %i0, 6, %i0
} else {
gid_t task_gid = getegid();
4000b9a4: 7f ff fe f5 call 4000b578 <getegid>
4000b9a8: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
4000b9ac: 91 2a 20 10 sll %o0, 0x10, %o0
4000b9b0: 91 32 20 10 srl %o0, 0x10, %o0
4000b9b4: 80 a2 00 1b cmp %o0, %i3
4000b9b8: 22 80 00 06 be,a 4000b9d0 <rtems_filesystem_check_access+0x60>
4000b9bc: b1 2e 20 03 sll %i0, 3, %i0
4000b9c0: 80 a2 20 00 cmp %o0, 0
4000b9c4: 32 80 00 04 bne,a 4000b9d4 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
4000b9c8: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
4000b9cc: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
4000b9d0: b0 2e 00 19 andn %i0, %i1, %i0
}
4000b9d4: 80 a0 00 18 cmp %g0, %i0
4000b9d8: b0 60 3f ff subx %g0, -1, %i0
4000b9dc: 81 c7 e0 08 ret
4000b9e0: 81 e8 00 00 restore
40004450 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40004450: 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 );
40004454: 3b 10 00 78 sethi %hi(0x4001e000), %i5
40004458: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 ! 4001e078 <rtems_libio_semaphore>
4000445c: 92 10 20 00 clr %o1
40004460: 40 00 0a c4 call 40006f70 <rtems_semaphore_obtain>
40004464: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40004468: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
4000446c: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
40004470: d0 07 60 78 ld [ %i5 + 0x78 ], %o0
next->previous = previous;
40004474: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40004478: 40 00 0b 07 call 40007094 <rtems_semaphore_release>
4000447c: 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);
40004480: 40 00 00 4d call 400045b4 <rtems_filesystem_global_location_release>
40004484: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
40004488: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000448c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40004490: 9f c0 40 00 call %g1
40004494: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
40004498: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
4000449c: 80 a2 20 00 cmp %o0, 0
400044a0: 02 80 00 09 be 400044c4 <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
400044a4: 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 );
400044a8: 40 00 0b 28 call 40007148 <rtems_event_system_send>
400044ac: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
400044b0: 80 a2 20 00 cmp %o0, 0
400044b4: 02 80 00 04 be 400044c4 <rtems_filesystem_do_unmount+0x74><== ALWAYS TAKEN
400044b8: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
400044bc: 40 00 0c 8a call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
400044c0: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
}
}
free(mt_entry);
400044c4: 7f ff fa c2 call 40002fcc <free>
400044c8: 81 e8 00 00 restore
4000ba1c <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
)
{
4000ba1c: 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);
4000ba20: 23 10 00 71 sethi %hi(0x4001c400), %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);
4000ba24: 3b 10 00 70 sethi %hi(0x4001c000), %i5
rtems_filesystem_eval_path_error(ctx, EINVAL);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
4000ba28: a0 06 20 18 add %i0, 0x18, %l0
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
4000ba2c: a2 14 63 10 or %l1, 0x310, %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);
4000ba30: ba 17 62 78 or %i5, 0x278, %i5
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
4000ba34: 40 00 00 99 call 4000bc98 <rtems_filesystem_eval_path_next_token>
4000ba38: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
4000ba3c: f8 06 20 0c ld [ %i0 + 0xc ], %i4
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
4000ba40: 80 a7 20 00 cmp %i4, 0
4000ba44: 02 80 00 54 be 4000bb94 <rtems_filesystem_eval_path_generic+0x178>
4000ba48: f6 06 20 08 ld [ %i0 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
4000ba4c: c2 06 80 00 ld [ %i2 ], %g1
4000ba50: 90 10 00 18 mov %i0, %o0
4000ba54: 9f c0 40 00 call %g1
4000ba58: 92 10 00 19 mov %i1, %o1
4000ba5c: 80 8a 20 ff btst 0xff, %o0
4000ba60: 02 80 00 75 be 4000bc34 <rtems_filesystem_eval_path_generic+0x218>
4000ba64: 80 a7 20 01 cmp %i4, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
4000ba68: 12 80 00 06 bne 4000ba80 <rtems_filesystem_eval_path_generic+0x64>
4000ba6c: 82 10 20 00 clr %g1
4000ba70: c2 4e c0 00 ldsb [ %i3 ], %g1
4000ba74: 82 18 60 2e xor %g1, 0x2e, %g1
4000ba78: 80 a0 00 01 cmp %g0, %g1
4000ba7c: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
4000ba80: 80 a0 60 00 cmp %g1, 0
4000ba84: 02 80 00 0f be 4000bac0 <rtems_filesystem_eval_path_generic+0xa4>
4000ba88: 80 a7 20 02 cmp %i4, 2
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000ba8c: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000ba90: 80 a0 60 00 cmp %g1, 0
4000ba94: 22 80 00 04 be,a 4000baa4 <rtems_filesystem_eval_path_generic+0x88>
4000ba98: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
4000ba9c: 10 80 00 40 b 4000bb9c <rtems_filesystem_eval_path_generic+0x180>
4000baa0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
4000baa4: 80 88 61 00 btst 0x100, %g1
4000baa8: 32 80 00 04 bne,a 4000bab8 <rtems_filesystem_eval_path_generic+0x9c>
4000baac: 90 10 00 18 mov %i0, %o0
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
4000bab0: 10 80 00 3b b 4000bb9c <rtems_filesystem_eval_path_generic+0x180>
4000bab4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
4000bab8: 10 80 00 5b b 4000bc24 <rtems_filesystem_eval_path_generic+0x208>
4000babc: 92 10 20 16 mov 0x16, %o1
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000bac0: 12 80 00 0a bne 4000bae8 <rtems_filesystem_eval_path_generic+0xcc>
4000bac4: 82 10 20 00 clr %g1
4000bac8: c4 4e c0 00 ldsb [ %i3 ], %g2
4000bacc: 80 a0 a0 2e cmp %g2, 0x2e
4000bad0: 12 80 00 07 bne 4000baec <rtems_filesystem_eval_path_generic+0xd0>
4000bad4: 80 a0 60 00 cmp %g1, 0
4000bad8: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
4000badc: 82 18 60 2e xor %g1, 0x2e, %g1
4000bae0: 80 a0 00 01 cmp %g0, %g1
4000bae4: 82 60 3f ff subx %g0, -1, %g1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
4000bae8: 80 a0 60 00 cmp %g1, 0
4000baec: 22 80 00 36 be,a 4000bbc4 <rtems_filesystem_eval_path_generic+0x1a8>
4000baf0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
4000baf4: 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;
4000baf8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
4000bafc: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
4000bb00: 80 a0 40 02 cmp %g1, %g2
4000bb04: 12 80 00 07 bne 4000bb20 <rtems_filesystem_eval_path_generic+0x104>
4000bb08: 90 10 20 00 clr %o0
4000bb0c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000bb10: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000bb14: 9f c0 40 00 call %g1
4000bb18: 90 10 00 10 mov %l0, %o0
4000bb1c: 90 0a 20 ff and %o0, 0xff, %o0
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
4000bb20: 80 8a 20 01 btst 1, %o0
4000bb24: 22 80 00 04 be,a 4000bb34 <rtems_filesystem_eval_path_generic+0x118>
4000bb28: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
4000bb2c: 10 80 00 1c b 4000bb9c <rtems_filesystem_eval_path_generic+0x180>
4000bb30: c2 06 a0 04 ld [ %i2 + 4 ], %g1
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *mt_fs_root =
&mt_entry->mt_fs_root->location;
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
4000bb34: 90 10 00 10 mov %l0, %o0
4000bb38: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000bb3c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
4000bb40: 9f c0 80 00 call %g2
4000bb44: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
} else if (is_fs_root(currentloc)) {
4000bb48: 80 8a 20 ff btst 0xff, %o0
4000bb4c: 22 80 00 19 be,a 4000bbb0 <rtems_filesystem_eval_path_generic+0x194>
4000bb50: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
4000bb54: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
4000bb58: c2 02 60 20 ld [ %o1 + 0x20 ], %g1
4000bb5c: 80 a0 60 00 cmp %g1, 0
4000bb60: 22 80 00 0f be,a 4000bb9c <rtems_filesystem_eval_path_generic+0x180><== NEVER TAKEN
4000bb64: 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;
4000bb68: c2 06 20 0c ld [ %i0 + 0xc ], %g1
ctx->path -= tokenlen;
4000bb6c: c4 06 00 00 ld [ %i0 ], %g2
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
4000bb70: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
4000bb74: 84 20 80 01 sub %g2, %g1, %g2
4000bb78: c4 26 00 00 st %g2, [ %i0 ]
ctx->pathlen += tokenlen;
4000bb7c: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
4000bb80: 90 10 00 18 mov %i0, %o0
4000bb84: 82 00 80 01 add %g2, %g1, %g1
4000bb88: 92 02 60 20 add %o1, 0x20, %o1
4000bb8c: 7f ff e1 ba call 40004274 <rtems_filesystem_eval_path_restart>
4000bb90: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000bb94: 81 c7 e0 08 ret
4000bb98: 81 e8 00 00 restore
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
4000bb9c: 90 10 00 18 mov %i0, %o0
4000bba0: 92 10 00 19 mov %i1, %o1
4000bba4: 94 10 00 1d mov %i5, %o2
4000bba8: 10 80 00 0b b 4000bbd4 <rtems_filesystem_eval_path_generic+0x1b8>
4000bbac: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
4000bbb0: 90 10 00 18 mov %i0, %o0
4000bbb4: 92 10 00 19 mov %i1, %o1
4000bbb8: 94 10 00 11 mov %l1, %o2
4000bbbc: 10 80 00 06 b 4000bbd4 <rtems_filesystem_eval_path_generic+0x1b8>
4000bbc0: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
4000bbc4: 90 10 00 18 mov %i0, %o0
4000bbc8: 92 10 00 19 mov %i1, %o1
4000bbcc: 94 10 00 1b mov %i3, %o2
4000bbd0: 96 10 00 1c mov %i4, %o3
4000bbd4: 9f c0 40 00 call %g1
4000bbd8: 01 00 00 00 nop
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000bbdc: 80 a2 20 02 cmp %o0, 2
4000bbe0: 12 80 00 18 bne 4000bc40 <rtems_filesystem_eval_path_generic+0x224>
4000bbe4: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000bbe8: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000bbec: 80 a0 60 00 cmp %g1, 0
4000bbf0: 02 80 00 16 be 4000bc48 <rtems_filesystem_eval_path_generic+0x22c>
4000bbf4: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
4000bbf8: 40 00 00 16 call 4000bc50 <rtems_filesystem_eval_path_eat_delimiter>
4000bbfc: 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
4000bc00: 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 (
4000bc04: 80 88 60 80 btst 0x80, %g1
4000bc08: 02 80 00 06 be 4000bc20 <rtems_filesystem_eval_path_generic+0x204>
4000bc0c: 90 10 00 18 mov %i0, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
4000bc10: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000bc14: 80 a0 60 00 cmp %g1, 0
4000bc18: 02 80 00 0c be 4000bc48 <rtems_filesystem_eval_path_generic+0x22c>
4000bc1c: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000bc20: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
4000bc24: 7f ff e0 af call 40003ee0 <rtems_filesystem_eval_path_error>
4000bc28: 01 00 00 00 nop
4000bc2c: 81 c7 e0 08 ret
4000bc30: 81 e8 00 00 restore
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
4000bc34: 90 10 00 18 mov %i0, %o0
4000bc38: 10 bf ff fb b 4000bc24 <rtems_filesystem_eval_path_generic+0x208>
4000bc3c: 92 10 20 14 mov 0x14, %o1
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
4000bc40: 02 bf ff 7d be 4000ba34 <rtems_filesystem_eval_path_generic+0x18>
4000bc44: 01 00 00 00 nop
4000bc48: 81 c7 e0 08 ret
4000bc4c: 81 e8 00 00 restore
400042d8 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
400042d8: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
400042dc: 80 a6 a0 00 cmp %i2, 0
400042e0: 02 80 00 26 be 40004378 <rtems_filesystem_eval_path_recursive+0xa0><== NEVER TAKEN
400042e4: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
400042e8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400042ec: 80 a0 60 1f cmp %g1, 0x1f
400042f0: 34 80 00 23 bg,a 4000437c <rtems_filesystem_eval_path_recursive+0xa4>
400042f4: b2 10 20 5c mov 0x5c, %i1
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
400042f8: c2 4e 40 00 ldsb [ %i1 ], %g1
const char *saved_path = ctx->path;
400042fc: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
40004300: 80 a0 60 5c cmp %g1, 0x5c
40004304: 02 80 00 05 be 40004318 <rtems_filesystem_eval_path_recursive+0x40><== NEVER TAKEN
40004308: f8 06 20 04 ld [ %i0 + 4 ], %i4
4000430c: 80 a0 60 2f cmp %g1, 0x2f
40004310: 32 80 00 06 bne,a 40004328 <rtems_filesystem_eval_path_recursive+0x50>
40004314: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
40004318: 90 10 00 1d mov %i5, %o0
4000431c: 7f ff ff d6 call 40004274 <rtems_filesystem_eval_path_restart>
40004320: 92 07 60 30 add %i5, 0x30, %o1
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
40004324: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
40004328: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
++ctx->recursionlevel;
4000432c: 82 00 60 01 inc %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
ctx->pathlen = pathlen;
40004330: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
40004334: 10 80 00 06 b 4000434c <rtems_filesystem_eval_path_recursive+0x74>
40004338: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
4000433c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40004340: c2 00 60 08 ld [ %g1 + 8 ], %g1
40004344: 9f c0 40 00 call %g1
40004348: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
4000434c: c2 07 60 04 ld [ %i5 + 4 ], %g1
40004350: 80 a0 60 00 cmp %g1, 0
40004354: 32 bf ff fa bne,a 4000433c <rtems_filesystem_eval_path_recursive+0x64>
40004358: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
4000435c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
40004360: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
40004364: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
40004368: 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;
4000436c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
40004370: 81 c7 e0 08 ret
40004374: 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);
40004378: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
4000437c: 7f ff fe d9 call 40003ee0 <rtems_filesystem_eval_path_error>
40004380: 81 e8 00 00 restore
40004150 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
40004150: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
40004154: 40 00 2f cd call 40010088 <strlen>
40004158: 90 10 00 19 mov %i1, %o0
4000415c: 10 80 00 09 b 40004180 <rtems_filesystem_eval_path_start_with_parent+0x30>
40004160: 94 10 00 08 mov %o0, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
40004164: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
40004168: 80 a0 a0 5c cmp %g2, 0x5c
4000416c: 02 80 00 28 be 4000420c <rtems_filesystem_eval_path_start_with_parent+0xbc><== NEVER TAKEN
40004170: 80 a0 a0 2f cmp %g2, 0x2f
40004174: 02 80 00 27 be 40004210 <rtems_filesystem_eval_path_start_with_parent+0xc0>
40004178: 80 a2 20 00 cmp %o0, 0
return pathlen;
}
pathlen = i;
4000417c: 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) {
40004180: 80 a2 a0 00 cmp %o2, 0
40004184: 12 bf ff f8 bne 40004164 <rtems_filesystem_eval_path_start_with_parent+0x14>
40004188: 82 02 bf ff add %o2, -1, %g1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
4000418c: 80 a2 20 00 cmp %o0, 0
40004190: 02 80 00 0a be 400041b8 <rtems_filesystem_eval_path_start_with_parent+0x68>
40004194: ba 10 00 19 mov %i1, %i5
40004198: a0 10 00 08 mov %o0, %l0
if (parentpathlen == 0) {
parentpath = ".";
4000419c: 33 10 00 70 sethi %hi(0x4001c000), %i1
parentpathlen = 1;
400041a0: 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 = ".";
400041a4: 10 80 00 09 b 400041c8 <rtems_filesystem_eval_path_start_with_parent+0x78>
400041a8: 92 16 62 78 or %i1, 0x278, %o1
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
400041ac: a0 22 00 0a sub %o0, %o2, %l0
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
400041b0: 10 80 00 06 b 400041c8 <rtems_filesystem_eval_path_start_with_parent+0x78>
400041b4: 92 10 00 19 mov %i1, %o1
400041b8: 92 10 00 19 mov %i1, %o1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
400041bc: 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;
400041c0: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
400041c4: 94 10 20 00 clr %o2
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
400041c8: 03 10 00 75 sethi %hi(0x4001d400), %g1
400041cc: da 00 63 2c ld [ %g1 + 0x32c ], %o5 ! 4001d72c <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
400041d0: 96 10 00 1c mov %i4, %o3
400041d4: 98 03 60 04 add %o5, 4, %o4
400041d8: 7f ff ff 94 call 40004028 <eval_path_start>
400041dc: 90 10 00 18 mov %i0, %o0
400041e0: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
400041e4: 40 00 1c 9c call 4000b454 <rtems_filesystem_location_clone>
400041e8: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
400041ec: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
400041f0: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
400041f4: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
400041f8: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
400041fc: 7f ff ff 71 call 40003fc0 <rtems_filesystem_eval_path_continue>
40004200: b0 06 20 18 add %i0, 0x18, %i0
40004204: 81 c7 e0 08 ret
40004208: 81 e8 00 00 restore
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
4000420c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004210: 32 bf ff e7 bne,a 400041ac <rtems_filesystem_eval_path_start_with_parent+0x5c><== ALWAYS TAKEN
40004214: 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;
40004218: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
4000421c: a0 10 20 00 clr %l0 <== NOT EXECUTED
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
40004220: 10 bf ff ea b 400041c8 <rtems_filesystem_eval_path_start_with_parent+0x78><== NOT EXECUTED
40004224: ba 10 20 00 clr %i5 <== NOT EXECUTED
4000b7d8 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000b7d8: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
4000b7dc: f0 27 bf f8 st %i0, [ %fp + -8 ]
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000b7e0: 80 a6 20 00 cmp %i0, 0
4000b7e4: 02 80 00 06 be 4000b7fc <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
4000b7e8: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_iterate( find_handler, &fa );
4000b7ec: 11 10 00 2d sethi %hi(0x4000b400), %o0
4000b7f0: 92 07 bf f8 add %fp, -8, %o1
4000b7f4: 7f ff ff ce call 4000b72c <rtems_filesystem_iterate>
4000b7f8: 90 12 22 c8 or %o0, 0x2c8, %o0
}
return fa.mount_h;
}
4000b7fc: f0 07 bf fc ld [ %fp + -4 ], %i0
4000b800: 81 c7 e0 08 ret
4000b804: 81 e8 00 00 restore
40002c98 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40002c98: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40002c9c: 05 10 00 6d sethi %hi(0x4001b400), %g2
40002ca0: 82 10 a3 a4 or %g2, 0x3a4, %g1 ! 4001b7a4 <rtems_filesystem_root_configuration>
40002ca4: d0 00 a3 a4 ld [ %g2 + 0x3a4 ], %o0
40002ca8: d2 00 60 04 ld [ %g1 + 4 ], %o1
40002cac: d4 00 60 08 ld [ %g1 + 8 ], %o2
40002cb0: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40002cb4: 40 00 02 21 call 40003538 <mount>
40002cb8: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40002cbc: 80 a2 20 00 cmp %o0, 0
40002cc0: 22 80 00 05 be,a 40002cd4 <rtems_filesystem_initialize+0x3c><== ALWAYS TAKEN
40002cc4: 11 10 00 6f sethi %hi(0x4001bc00), %o0
rtems_fatal_error_occurred( 0xABCD0002 );
40002cc8: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
40002ccc: 10 80 00 09 b 40002cf0 <rtems_filesystem_initialize+0x58> <== NOT EXECUTED
40002cd0: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <LEON_REG+0x2bcd0002><== NOT EXECUTED
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
40002cd4: 92 10 21 ff mov 0x1ff, %o1
40002cd8: 40 00 01 d0 call 40003418 <mkdir>
40002cdc: 90 12 21 08 or %o0, 0x108, %o0
if ( rv != 0 )
40002ce0: 80 a2 20 00 cmp %o0, 0
40002ce4: 02 80 00 05 be 40002cf8 <rtems_filesystem_initialize+0x60><== ALWAYS TAKEN
40002ce8: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
rtems_fatal_error_occurred( 0xABCD0003 );
40002cec: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <LEON_REG+0x2bcd0003><== NOT EXECUTED
40002cf0: 40 00 12 7d call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002cf4: 01 00 00 00 nop <== NOT EXECUTED
40002cf8: 81 c7 e0 08 ret
40002cfc: 81 e8 00 00 restore
4000b72c <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
4000b72c: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
4000b730: 39 10 00 6d sethi %hi(0x4001b400), %i4
rtems_chain_node *node = NULL;
bool stop = false;
4000b734: ba 10 20 00 clr %i5
while ( table_entry->type && !stop ) {
4000b738: 10 80 00 06 b 4000b750 <rtems_filesystem_iterate+0x24>
4000b73c: b8 17 23 b8 or %i4, 0x3b8, %i4
stop = (*routine)( table_entry, routine_arg );
4000b740: 92 10 00 19 mov %i1, %o1
4000b744: 9f c6 00 00 call %i0
4000b748: b8 07 20 08 add %i4, 8, %i4
4000b74c: ba 10 00 08 mov %o0, %i5
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
4000b750: c2 07 00 00 ld [ %i4 ], %g1
4000b754: 80 a0 60 00 cmp %g1, 0
4000b758: 02 80 00 08 be 4000b778 <rtems_filesystem_iterate+0x4c>
4000b75c: 82 0f 60 ff and %i5, 0xff, %g1
4000b760: 80 a0 60 00 cmp %g1, 0
4000b764: 02 bf ff f7 be 4000b740 <rtems_filesystem_iterate+0x14>
4000b768: 90 10 00 1c mov %i4, %o0
4000b76c: b0 0f 60 ff and %i5, 0xff, %i0
4000b770: 81 c7 e0 08 ret
4000b774: 81 e8 00 00 restore
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
4000b778: 80 a0 60 00 cmp %g1, 0
4000b77c: 32 80 00 15 bne,a 4000b7d0 <rtems_filesystem_iterate+0xa4>
4000b780: b0 0f 60 ff and %i5, 0xff, %i0
rtems_libio_lock();
4000b784: 7f ff ff de call 4000b6fc <rtems_libio_lock>
4000b788: 37 10 00 75 sethi %hi(0x4001d400), %i3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000b78c: 03 10 00 75 sethi %hi(0x4001d400), %g1
4000b790: f8 00 63 dc ld [ %g1 + 0x3dc ], %i4 ! 4001d7dc <filesystem_chain>
for (
4000b794: 10 80 00 06 b 4000b7ac <rtems_filesystem_iterate+0x80>
4000b798: b6 16 e3 e0 or %i3, 0x3e0, %i3
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
4000b79c: 9f c6 00 00 call %i0
4000b7a0: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000b7a4: f8 07 00 00 ld [ %i4 ], %i4
4000b7a8: ba 10 00 08 mov %o0, %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
4000b7ac: 80 a7 00 1b cmp %i4, %i3
4000b7b0: 12 80 00 05 bne 4000b7c4 <rtems_filesystem_iterate+0x98>
4000b7b4: 80 8f 60 ff btst 0xff, %i5
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
4000b7b8: 7f ff ff d8 call 4000b718 <rtems_libio_unlock>
4000b7bc: b0 0f 60 ff and %i5, 0xff, %i0
4000b7c0: 30 80 00 04 b,a 4000b7d0 <rtems_filesystem_iterate+0xa4>
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
4000b7c4: 02 bf ff f6 be 4000b79c <rtems_filesystem_iterate+0x70> <== ALWAYS TAKEN
4000b7c8: 90 07 20 08 add %i4, 8, %o0
4000b7cc: 30 bf ff fb b,a 4000b7b8 <rtems_filesystem_iterate+0x8c> <== NOT EXECUTED
}
rtems_libio_unlock();
}
return stop;
}
4000b7d0: 81 c7 e0 08 ret
4000b7d4: 81 e8 00 00 restore
4000b454 <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000b454: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000b458: 90 10 00 18 mov %i0, %o0
4000b45c: 7f ff e3 e1 call 400043e0 <rtems_filesystem_location_copy>
4000b460: 92 10 00 19 mov %i1, %o1
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000b464: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000b468: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000b46c: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
4000b470: 9f c0 40 00 call %g1
4000b474: b0 10 00 08 mov %o0, %i0
if ( rv != 0 ) {
4000b478: 80 a2 20 00 cmp %o0, 0
4000b47c: 02 80 00 06 be 4000b494 <rtems_filesystem_location_clone+0x40><== ALWAYS TAKEN
4000b480: 90 10 00 18 mov %i0, %o0
rtems_filesystem_location_remove_from_mt_entry( clone );
4000b484: 7f ff e4 12 call 400044cc <rtems_filesystem_location_remove_from_mt_entry><== NOT EXECUTED
4000b488: 33 10 00 75 sethi %hi(0x4001d400), %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(
4000b48c: 7f ff e3 d5 call 400043e0 <rtems_filesystem_location_copy><== NOT EXECUTED
4000b490: 93 ee 63 5c restore %i1, 0x35c, %o1 <== NOT EXECUTED
4000b494: 81 c7 e0 08 ret
4000b498: 81 e8 00 00 restore
400044cc <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
400044cc: 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);
400044d0: 7f ff f6 f6 call 400020a8 <sparc_disable_interrupts>
400044d4: 01 00 00 00 nop
400044d8: b8 10 00 08 mov %o0, %i4
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400044dc: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
400044e0: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
400044e4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
next->previous = previous;
400044e8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
400044ec: 7f ff ff a6 call 40004384 <rtems_filesystem_is_ready_for_unmount>
400044f0: c4 20 40 00 st %g2, [ %g1 ]
400044f4: ba 10 00 08 mov %o0, %i5
rtems_filesystem_mt_entry_unlock(lock_context);
400044f8: 7f ff f6 f0 call 400020b8 <sparc_enable_interrupts>
400044fc: 90 10 00 1c mov %i4, %o0
if (do_unmount) {
40004500: 80 8f 60 ff btst 0xff, %i5
40004504: 02 80 00 05 be 40004518 <rtems_filesystem_location_remove_from_mt_entry+0x4c><== ALWAYS TAKEN
40004508: 01 00 00 00 nop
rtems_filesystem_do_unmount(loc->mt_entry);
4000450c: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
40004510: 7f ff ff d0 call 40004450 <rtems_filesystem_do_unmount> <== NOT EXECUTED
40004514: 81 e8 00 00 restore <== NOT EXECUTED
40004518: 81 c7 e0 08 ret
4000451c: 81 e8 00 00 restore
40004700 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
40004700: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40004704: 7f ff fb 06 call 4000331c <malloc>
40004708: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
4000470c: ba 92 20 00 orcc %o0, 0, %i5
40004710: 02 80 00 0b be 4000473c <rtems_filesystem_location_transform_to_global+0x3c><== NEVER TAKEN
40004714: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
40004718: c0 27 60 1c clr [ %i5 + 0x1c ]
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
4000471c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
40004720: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_copy(&global_loc->location, loc);
40004724: 7f ff ff 2f call 400043e0 <rtems_filesystem_location_copy>
40004728: 92 10 00 18 mov %i0, %o1
rtems_filesystem_location_remove_from_mt_entry(loc);
4000472c: 7f ff ff 68 call 400044cc <rtems_filesystem_location_remove_from_mt_entry>
40004730: 90 10 00 18 mov %i0, %o0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
40004734: 81 c7 e0 08 ret
40004738: 91 e8 00 1d restore %g0, %i5, %o0
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
rtems_filesystem_location_remove_from_mt_entry(loc);
} else {
rtems_filesystem_location_free(loc);
4000473c: 40 00 1b 58 call 4000b49c <rtems_filesystem_location_free><== NOT EXECUTED
40004740: 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 );
40004744: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
40004748: 7f ff ff bc call 40004638 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
4000474c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
40004750: 40 00 28 c7 call 4000ea6c <__errno> <== NOT EXECUTED
40004754: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40004758: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000475c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
40004760: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40004764: 81 c7 e0 08 ret <== NOT EXECUTED
40004768: 81 e8 00 00 restore <== NOT EXECUTED
40003540 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
40003540: 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 ) );
40003544: 40 00 01 05 call 40003958 <malloc>
40003548: 90 10 20 08 mov 8, %o0
*key = new_key;
4000354c: 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 ) );
40003550: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
40003554: c0 22 00 00 clr [ %o0 ]
new_key->dtor = dtor;
40003558: 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 );
4000355c: 92 10 00 1d mov %i5, %o1
40003560: 90 10 20 00 clr %o0
40003564: 94 10 00 19 mov %i1, %o2
40003568: 40 00 11 7f call 40007b64 <rtems_task_variable_add>
4000356c: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
40003570: 80 a2 20 00 cmp %o0, 0
40003574: 02 80 00 04 be 40003584 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
40003578: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
4000357c: 7f ff ff 85 call 40003390 <free> <== NOT EXECUTED
40003580: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
40003584: 81 c7 e0 08 ret
40003588: 81 e8 00 00 restore
40003598 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
40003598: 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 );
4000359c: 90 10 20 00 clr %o0
400035a0: 40 00 11 9c call 40007c10 <rtems_task_variable_delete>
400035a4: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
400035a8: 80 a2 20 00 cmp %o0, 0
400035ac: 12 80 00 06 bne 400035c4 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
400035b0: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
400035b4: 02 80 00 04 be 400035c4 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
400035b8: 01 00 00 00 nop
400035bc: 7f ff ff 75 call 40003390 <free>
400035c0: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
400035c4: 81 c7 e0 08 ret
400035c8: 91 e8 20 00 restore %g0, 0, %o0
400034dc <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))
{
400034dc: 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 ) {
400034e0: c2 06 00 00 ld [ %i0 ], %g1
400034e4: 80 a0 60 00 cmp %g1, 0
400034e8: 12 80 00 14 bne 40003538 <rtems_gxx_once+0x5c>
400034ec: 90 10 21 00 mov 0x100, %o0
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
400034f0: 92 10 21 00 mov 0x100, %o1
400034f4: 40 00 11 22 call 4000797c <rtems_task_mode>
400034f8: 94 07 bf fc add %fp, -4, %o2
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
400034fc: fa 06 00 00 ld [ %i0 ], %i5
40003500: 80 a7 60 00 cmp %i5, 0
40003504: 12 80 00 05 bne 40003518 <rtems_gxx_once+0x3c> <== NEVER TAKEN
40003508: d0 07 bf fc ld [ %fp + -4 ], %o0
*(volatile __gthread_once_t *)once = 1;
4000350c: 82 10 20 01 mov 1, %g1
40003510: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
40003514: d0 07 bf fc ld [ %fp + -4 ], %o0
40003518: 92 10 21 00 mov 0x100, %o1
4000351c: 40 00 11 18 call 4000797c <rtems_task_mode>
40003520: 94 07 bf fc add %fp, -4, %o2
if ( o == 0 )
40003524: 80 a7 60 00 cmp %i5, 0
40003528: 12 80 00 04 bne 40003538 <rtems_gxx_once+0x5c> <== NEVER TAKEN
4000352c: 01 00 00 00 nop
(*func)();
40003530: 9f c6 40 00 call %i1
40003534: 01 00 00 00 nop
}
return 0;
}
40003538: 81 c7 e0 08 ret
4000353c: 91 e8 20 00 restore %g0, 0, %o0
40003630 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
40003630: 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 );
40003634: d4 06 20 04 ld [ %i0 + 4 ], %o2
40003638: 90 10 20 00 clr %o0
4000363c: 40 00 11 4a call 40007b64 <rtems_task_variable_add>
40003640: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
40003644: 80 a2 20 00 cmp %o0, 0
40003648: 12 80 00 05 bne 4000365c <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
4000364c: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
40003650: f2 26 00 00 st %i1, [ %i0 ]
return 0;
40003654: 81 c7 e0 08 ret
40003658: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
4000365c: 81 c7 e0 08 ret <== NOT EXECUTED
40003660: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400083d8 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
400083d8: 9d e3 bf a0 save %sp, -96, %sp
if (
400083dc: 03 10 00 95 sethi %hi(0x40025400), %g1
400083e0: c2 00 63 18 ld [ %g1 + 0x318 ], %g1 ! 40025718 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
400083e4: ba 10 00 18 mov %i0, %i5
400083e8: b8 10 00 19 mov %i1, %i4
if (
400083ec: 80 a0 60 03 cmp %g1, 3
400083f0: 02 80 00 08 be 40008410 <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
400083f4: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
400083f8: 7f ff fb ef call 400073b4 <malloc_deferred_frees_process>
400083fc: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
40008400: 03 10 00 8f sethi %hi(0x40023c00), %g1
40008404: f0 00 61 c4 ld [ %g1 + 0x1c4 ], %i0 ! 40023dc4 <RTEMS_Malloc_Heap>
40008408: 40 00 17 aa call 4000e2b0 <_Protected_heap_Allocate_aligned_with_boundary>
4000840c: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
40008410: 7f ff fb dd call 40007384 <malloc_is_system_state_OK>
40008414: 01 00 00 00 nop
40008418: 80 8a 20 ff btst 0xff, %o0
4000841c: 12 bf ff f7 bne 400083f8 <rtems_heap_allocate_aligned_with_boundary+0x20>
40008420: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
40008424: 81 c7 e0 08 ret
40008428: 81 e8 00 00 restore
40003ad8 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
40003ad8: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
40003adc: 03 10 00 57 sethi %hi(0x40015c00), %g1
40003ae0: f8 00 63 c0 ld [ %g1 + 0x3c0 ], %i4 ! 40015fc0 <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_size % sbrk_amount;
40003ae4: 90 10 00 19 mov %i1, %o0
40003ae8: 92 10 00 1c mov %i4, %o1
40003aec: 40 00 3a 0d call 40012320 <.rem>
40003af0: ba 10 00 19 mov %i1, %i5
void *return_this = NULL;
if ( misaligned != 0 ) {
40003af4: 80 a2 20 00 cmp %o0, 0
40003af8: 02 80 00 05 be 40003b0c <rtems_heap_extend_via_sbrk+0x34>
40003afc: 80 a7 60 00 cmp %i5, 0
sbrk_size += sbrk_amount - misaligned;
40003b00: ba 27 00 08 sub %i4, %o0, %i5
40003b04: ba 06 40 1d add %i1, %i5, %i5
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
40003b08: 80 a7 60 00 cmp %i5, 0
40003b0c: 04 80 00 17 ble 40003b68 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40003b10: 80 a7 20 00 cmp %i4, 0
40003b14: 04 80 00 15 ble 40003b68 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40003b18: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
40003b1c: 7f ff f6 6e call 400014d4 <sbrk>
40003b20: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
40003b24: 80 a2 3f ff cmp %o0, -1
40003b28: 02 80 00 10 be 40003b68 <rtems_heap_extend_via_sbrk+0x90>
40003b2c: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
40003b30: 90 10 00 18 mov %i0, %o0
40003b34: 40 00 13 53 call 40008880 <_Protected_heap_Extend>
40003b38: 94 10 00 1d mov %i5, %o2
if ( ok ) {
40003b3c: 80 8a 20 ff btst 0xff, %o0
40003b40: 02 80 00 08 be 40003b60 <rtems_heap_extend_via_sbrk+0x88>
40003b44: 03 10 00 57 sethi %hi(0x40015c00), %g1
MSBUMP( space_available, sbrk_size );
40003b48: c4 00 63 90 ld [ %g1 + 0x390 ], %g2 ! 40015f90 <rtems_malloc_statistics>
40003b4c: b4 10 20 00 clr %i2
40003b50: ba 07 40 02 add %i5, %g2, %i5
40003b54: fa 20 63 90 st %i5, [ %g1 + 0x390 ]
40003b58: 40 00 13 3c call 40008848 <_Protected_heap_Allocate_aligned_with_boundary>
40003b5c: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( heap, alloc_size );
} else {
sbrk( -sbrk_size );
40003b60: 7f ff f6 5d call 400014d4 <sbrk>
40003b64: 90 20 00 1d neg %i5, %o0
}
}
}
return return_this;
}
40003b68: 81 c7 e0 08 ret
40003b6c: 91 e8 20 00 restore %g0, 0, %o0
40003e34 <rtems_heap_null_extend>:
Heap_Control *heap __attribute__((unused)),
size_t alloc_size __attribute__((unused))
)
{
return NULL;
}
40003e34: 81 c3 e0 08 retl
40003e38: 90 10 20 00 clr %o0
4000470c <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
4000470c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40004710: 7f ff fe d1 call 40004254 <partition_table_free> <== NOT EXECUTED
40004714: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40004718 <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 );
40004718: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4000471c: 7f ff ff 87 call 40004538 <partition_table_get> <== NOT EXECUTED
40004720: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40004724 <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)
{
40004724: 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));
40004728: 90 10 20 01 mov 1, %o0
4000472c: 92 10 21 28 mov 0x128, %o1
40004730: 40 00 02 09 call 40004f54 <calloc>
40004734: b6 10 20 1a mov 0x1a, %i3
if (disk_desc == NULL)
40004738: 80 a2 20 00 cmp %o0, 0
4000473c: 02 80 00 34 be 4000480c <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
40004740: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
40004744: 90 10 00 18 mov %i0, %o0
40004748: 7f ff ff 7c call 40004538 <partition_table_get>
4000474c: 92 10 00 1d mov %i5, %o1
if (rc != RTEMS_SUCCESSFUL)
40004750: b6 92 20 00 orcc %o0, 0, %i3
40004754: 02 80 00 06 be 4000476c <rtems_ide_part_table_initialize+0x48><== ALWAYS TAKEN
40004758: 23 10 00 90 sethi %hi(0x40024000), %l1
{
free(disk_desc);
4000475c: 40 00 02 36 call 40005034 <free> <== NOT EXECUTED
40004760: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
40004764: 81 c7 e0 08 ret <== NOT EXECUTED
40004768: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
4000476c: 27 10 00 90 sethi %hi(0x40024000), %l3
/* To avoid device numbers conflicts we have to use for logic disk the same
* device major number as ATA device has, and minor number that equals to
* sum of logic disk partition number and the minor number of physical disk
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
40004770: f2 07 40 00 ld [ %i5 ], %i1
40004774: e0 07 60 04 ld [ %i5 + 4 ], %l0
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40004778: b8 10 20 00 clr %i4
{
sprintf(name, "%s%d", dev_name, part_num + 1);
4000477c: b4 07 bf f0 add %fp, -16, %i2
40004780: a2 14 63 68 or %l1, 0x368, %l1
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40004784: 25 10 00 95 sethi %hi(0x40025400), %l2
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40004788: 10 80 00 1b b 400047f4 <rtems_ide_part_table_initialize+0xd0>
4000478c: a6 14 e3 70 or %l3, 0x370, %l3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40004790: 92 10 00 11 mov %l1, %o1
40004794: 90 10 00 1a mov %i2, %o0
40004798: 94 10 00 18 mov %i0, %o2
4000479c: 40 00 41 e0 call 40014f1c <sprintf>
400047a0: 96 10 00 1c mov %i4, %o3
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
400047a4: 83 2f 20 02 sll %i4, 2, %g1
400047a8: 82 07 40 01 add %i5, %g1, %g1
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
400047ac: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
if (part_desc == NULL)
400047b0: 80 a0 60 00 cmp %g1, 0
400047b4: 02 80 00 10 be 400047f4 <rtems_ide_part_table_initialize+0xd0>
400047b8: 92 07 00 10 add %i4, %l0, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
400047bc: d4 1f 40 00 ldd [ %i5 ], %o2
400047c0: d8 00 60 04 ld [ %g1 + 4 ], %o4
400047c4: da 00 60 08 ld [ %g1 + 8 ], %o5
400047c8: 90 10 00 19 mov %i1, %o0
400047cc: 7f ff fd 63 call 40003d58 <rtems_disk_create_log>
400047d0: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
400047d4: 96 92 20 00 orcc %o0, 0, %o3
400047d8: 22 80 00 08 be,a 400047f8 <rtems_ide_part_table_initialize+0xd4><== ALWAYS TAKEN
400047dc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
400047e0: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED
400047e4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
400047e8: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
400047ec: 40 00 3f bd call 400146e0 <fprintf> <== NOT EXECUTED
400047f0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
400047f4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
400047f8: 80 a7 00 01 cmp %i4, %g1
400047fc: 26 bf ff e5 bl,a 40004790 <rtems_ide_part_table_initialize+0x6c>
40004800: b8 07 20 01 inc %i4
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
continue;
}
}
partition_table_free(disk_desc);
40004804: 7f ff fe 94 call 40004254 <partition_table_free>
40004808: 90 10 00 1d mov %i5, %o0
return RTEMS_SUCCESSFUL;
}
4000480c: b0 10 00 1b mov %i3, %i0
40004810: 81 c7 e0 08 ret
40004814: 81 e8 00 00 restore
40009c64 <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)
{
40009c64: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
40009c68: ba 10 20 01 mov 1, %i5
40009c6c: 80 a6 20 00 cmp %i0, 0
40009c70: 02 80 00 0d be 40009ca4 <rtems_iterate_over_all_threads+0x40><== NEVER TAKEN
40009c74: 35 10 00 83 sethi %hi(0x40020c00), %i2
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
40009c78: 83 2f 60 02 sll %i5, 2, %g1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
40009c7c: 84 16 a1 b4 or %i2, 0x1b4, %g2
40009c80: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40009c84: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( !information )
40009c88: 80 a6 e0 00 cmp %i3, 0
40009c8c: 12 80 00 0f bne 40009cc8 <rtems_iterate_over_all_threads+0x64>
40009c90: b8 10 20 01 mov 1, %i4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
40009c94: ba 07 60 01 inc %i5
40009c98: 80 a7 60 04 cmp %i5, 4
40009c9c: 12 bf ff f8 bne 40009c7c <rtems_iterate_over_all_threads+0x18>
40009ca0: 83 2f 60 02 sll %i5, 2, %g1
40009ca4: 81 c7 e0 08 ret
40009ca8: 81 e8 00 00 restore
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
40009cac: 83 2f 20 02 sll %i4, 2, %g1
40009cb0: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
40009cb4: 80 a2 20 00 cmp %o0, 0
40009cb8: 02 80 00 04 be 40009cc8 <rtems_iterate_over_all_threads+0x64><== NEVER TAKEN
40009cbc: b8 07 20 01 inc %i4
continue;
(*routine)(the_thread);
40009cc0: 9f c6 00 00 call %i0
40009cc4: 01 00 00 00 nop
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
40009cc8: c2 16 e0 10 lduh [ %i3 + 0x10 ], %g1
40009ccc: 80 a7 00 01 cmp %i4, %g1
40009cd0: 28 bf ff f7 bleu,a 40009cac <rtems_iterate_over_all_threads+0x48>
40009cd4: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
40009cd8: 10 bf ff f0 b 40009c98 <rtems_iterate_over_all_threads+0x34>
40009cdc: ba 07 60 01 inc %i5
40003118 <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 )
{
40003118: 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)
4000311c: 03 10 00 75 sethi %hi(0x4001d400), %g1
40003120: fa 00 62 e4 ld [ %g1 + 0x2e4 ], %i5 ! 4001d6e4 <rtems_libio_number_iops>
40003124: 80 a7 60 00 cmp %i5, 0
40003128: 02 80 00 1b be 40003194 <rtems_libio_init+0x7c> <== NEVER TAKEN
4000312c: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
40003130: 90 10 00 1d mov %i5, %o0
40003134: 7f ff fe f3 call 40002d00 <calloc>
40003138: 92 10 20 38 mov 0x38, %o1
4000313c: 03 10 00 78 sethi %hi(0x4001e000), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
40003140: 80 a2 20 00 cmp %o0, 0
40003144: 12 80 00 04 bne 40003154 <rtems_libio_init+0x3c>
40003148: d0 20 60 70 st %o0, [ %g1 + 0x70 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
4000314c: 10 80 00 1c b 400031bc <rtems_libio_init+0xa4>
40003150: 90 10 20 1a mov 0x1a, %o0
iop = rtems_libio_iop_freelist = rtems_libio_iops;
40003154: 03 10 00 78 sethi %hi(0x4001e000), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
40003158: 84 10 00 08 mov %o0, %g2
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
4000315c: d0 20 60 74 st %o0, [ %g1 + 0x74 ]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
40003160: 10 80 00 03 b 4000316c <rtems_libio_init+0x54>
40003164: 82 10 20 00 clr %g1
iop->data1 = iop + 1;
40003168: c4 20 bf f8 st %g2, [ %g2 + -8 ]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
4000316c: 82 00 60 01 inc %g1
40003170: 80 a0 40 1d cmp %g1, %i5
40003174: 12 bf ff fd bne 40003168 <rtems_libio_init+0x50>
40003178: 84 00 a0 38 add %g2, 0x38, %g2
iop->data1 = iop + 1;
iop->data1 = NULL;
4000317c: 85 28 60 03 sll %g1, 3, %g2
40003180: 83 28 60 06 sll %g1, 6, %g1
40003184: 82 20 40 02 sub %g1, %g2, %g1
40003188: 90 02 00 01 add %o0, %g1, %o0
4000318c: c0 22 3f f8 clr [ %o0 + -8 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
40003190: 11 13 10 92 sethi %hi(0x4c424800), %o0
40003194: 92 10 20 01 mov 1, %o1
40003198: 90 12 21 4f or %o0, 0x14f, %o0
4000319c: 94 10 20 54 mov 0x54, %o2
400031a0: 96 10 20 00 clr %o3
400031a4: 19 10 00 78 sethi %hi(0x4001e000), %o4
400031a8: 40 00 0e d5 call 40006cfc <rtems_semaphore_create>
400031ac: 98 13 20 78 or %o4, 0x78, %o4 ! 4001e078 <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
400031b0: 80 a2 20 00 cmp %o0, 0
400031b4: 02 80 00 04 be 400031c4 <rtems_libio_init+0xac> <== ALWAYS TAKEN
400031b8: 03 10 00 75 sethi %hi(0x4001d400), %g1
rtems_fatal_error_occurred( rc );
400031bc: 40 00 11 4a call 400076e4 <rtems_fatal_error_occurred>
400031c0: 01 00 00 00 nop
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
400031c4: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1
400031c8: 80 a0 60 00 cmp %g1, 0
400031cc: 02 80 00 04 be 400031dc <rtems_libio_init+0xc4>
400031d0: 01 00 00 00 nop
(* rtems_fs_init_helper)();
400031d4: 9f c0 40 00 call %g1
400031d8: 01 00 00 00 nop
400031dc: 81 c7 e0 08 ret
400031e0: 81 e8 00 00 restore
400045a8 <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
400045a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
400045ac: 40 00 05 d9 call 40005d10 <rtems_task_self>
400045b0: 01 00 00 00 nop
rtems_user_env_t *old_env = rtems_current_user_env;
400045b4: 03 10 00 51 sethi %hi(0x40014400), %g1
400045b8: f8 00 63 9c ld [ %g1 + 0x39c ], %i4 ! 4001479c <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;
400045bc: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
400045c0: 80 a0 40 08 cmp %g1, %o0
400045c4: 12 80 00 07 bne 400045e0 <rtems_libio_set_private_env+0x38>
400045c8: b6 10 00 08 mov %o0, %i3
400045cc: 03 10 00 51 sethi %hi(0x40014400), %g1
400045d0: 82 10 63 a0 or %g1, 0x3a0, %g1 ! 400147a0 <rtems_global_user_env>
400045d4: 80 a7 00 01 cmp %i4, %g1
400045d8: 12 80 00 2b bne 40004684 <rtems_libio_set_private_env+0xdc><== ALWAYS TAKEN
400045dc: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
400045e0: 90 10 20 01 mov 1, %o0
400045e4: 92 10 20 2c mov 0x2c, %o1
400045e8: 40 00 13 15 call 4000923c <calloc>
400045ec: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
400045f0: 80 a2 20 00 cmp %o0, 0
400045f4: 02 80 00 24 be 40004684 <rtems_libio_set_private_env+0xdc>
400045f8: ba 10 00 08 mov %o0, %i5
*new_env = *old_env;
400045fc: 92 10 00 1c mov %i4, %o1
40004600: 40 00 1e 80 call 4000c000 <memcpy>
40004604: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
40004608: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
4000460c: f6 27 60 24 st %i3, [ %i5 + 0x24 ]
if (uses_global_env || uses_shared_env) {
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
40004610: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
40004614: 40 00 02 d4 call 40005164 <rtems_filesystem_global_location_obtain>
40004618: 90 07 20 04 add %i4, 4, %o0
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
4000461c: d0 27 60 04 st %o0, [ %i5 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
40004620: 40 00 02 d1 call 40005164 <rtems_filesystem_global_location_obtain>
40004624: 90 10 00 1c mov %i4, %o0
static inline bool rtems_filesystem_location_is_null(
const rtems_filesystem_location_info_t *loc
)
{
return loc->handlers == &rtems_filesystem_null_handlers;
40004628: c2 07 60 04 ld [ %i5 + 4 ], %g1
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
4000462c: d0 27 40 00 st %o0, [ %i5 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
40004630: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40004634: 03 10 00 4f sethi %hi(0x40013c00), %g1
40004638: 82 10 60 54 or %g1, 0x54, %g1 ! 40013c54 <rtems_filesystem_null_handlers>
4000463c: 80 a0 80 01 cmp %g2, %g1
40004640: 22 80 00 14 be,a 40004690 <rtems_libio_set_private_env+0xe8>
40004644: 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)
40004648: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
4000464c: 80 a0 80 01 cmp %g2, %g1
40004650: 02 80 00 0f be 4000468c <rtems_libio_set_private_env+0xe4><== NEVER TAKEN
40004654: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
40004658: 37 10 00 51 sethi %hi(0x40014400), %i3
4000465c: 15 10 00 11 sethi %hi(0x40004400), %o2
40004660: 92 16 e3 9c or %i3, 0x39c, %o1
40004664: 40 00 05 cb call 40005d90 <rtems_task_variable_add>
40004668: 94 12 a1 38 or %o2, 0x138, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
4000466c: b0 92 20 00 orcc %o0, 0, %i0
40004670: 32 80 00 08 bne,a 40004690 <rtems_libio_set_private_env+0xe8>
40004674: b0 10 20 05 mov 5, %i0
free_user_env_protected(old_env);
40004678: 7f ff ff c3 call 40004584 <free_user_env_protected>
4000467c: 90 10 00 1c mov %i4, %o0
rtems_current_user_env = new_env;
40004680: fa 26 e3 9c st %i5, [ %i3 + 0x39c ]
40004684: 81 c7 e0 08 ret
40004688: 81 e8 00 00 restore
4000468c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
40004690: 7f ff ff aa call 40004538 <free_user_env>
40004694: 90 10 00 1d mov %i5, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
40004698: 81 c7 e0 08 ret
4000469c: 81 e8 00 00 restore
400046a0 <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
400046a0: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
400046a4: 40 00 05 9b call 40005d10 <rtems_task_self>
400046a8: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
400046ac: 80 a2 00 18 cmp %o0, %i0
400046b0: 22 80 00 26 be,a 40004748 <rtems_libio_share_private_env+0xa8>
400046b4: b0 10 20 00 clr %i0
400046b8: 80 a6 20 00 cmp %i0, 0
400046bc: 22 80 00 23 be,a 40004748 <rtems_libio_share_private_env+0xa8>
400046c0: b0 10 20 00 clr %i0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
400046c4: 03 10 00 54 sethi %hi(0x40015000), %g1
400046c8: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 40015200 <_Thread_Dispatch_disable_level>
++level;
400046cc: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400046d0: c4 20 62 00 st %g2, [ %g1 + 0x200 ]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
400046d4: 13 10 00 51 sethi %hi(0x40014400), %o1
400046d8: 90 10 00 18 mov %i0, %o0
400046dc: 92 12 63 9c or %o1, 0x39c, %o1
400046e0: 40 00 05 fc call 40005ed0 <rtems_task_variable_get>
400046e4: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
400046e8: b0 92 20 00 orcc %o0, 0, %i0
400046ec: 32 80 00 06 bne,a 40004704 <rtems_libio_share_private_env+0x64>
400046f0: b0 10 20 0d mov 0xd, %i0
++env->reference_count;
400046f4: c2 07 bf fc ld [ %fp + -4 ], %g1
400046f8: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
400046fc: 84 00 a0 01 inc %g2
40004700: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
40004704: 40 00 0d ea call 40007eac <_Thread_Enable_dispatch>
40004708: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
4000470c: 80 a6 20 00 cmp %i0, 0
40004710: 12 80 00 0e bne 40004748 <rtems_libio_share_private_env+0xa8>
40004714: 90 10 20 00 clr %o0
sc = rtems_task_variable_add(
40004718: 3b 10 00 51 sethi %hi(0x40014400), %i5
4000471c: 15 10 00 11 sethi %hi(0x40004400), %o2
40004720: 92 17 63 9c or %i5, 0x39c, %o1
40004724: 40 00 05 9b call 40005d90 <rtems_task_variable_add>
40004728: 94 12 a1 38 or %o2, 0x138, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
4000472c: b0 92 20 00 orcc %o0, 0, %i0
40004730: 12 80 00 08 bne 40004750 <rtems_libio_share_private_env+0xb0><== NEVER TAKEN
40004734: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
40004738: 7f ff ff 93 call 40004584 <free_user_env_protected>
4000473c: d0 07 63 9c ld [ %i5 + 0x39c ], %o0
rtems_current_user_env = env;
40004740: c2 07 bf fc ld [ %fp + -4 ], %g1
40004744: c2 27 63 9c st %g1, [ %i5 + 0x39c ]
40004748: 81 c7 e0 08 ret
4000474c: 81 e8 00 00 restore
} else {
free_user_env_protected(env);
40004750: 7f ff ff 8d call 40004584 <free_user_env_protected> <== NOT EXECUTED
40004754: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40004758: 81 c7 e0 08 ret <== NOT EXECUTED
4000475c: 81 e8 00 00 restore <== NOT EXECUTED
4000b5cc <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000b5cc: 84 0a 20 06 and %o0, 6, %g2
return flags;
}
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
4000b5d0: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000b5d4: 80 a0 a0 06 cmp %g2, 6
4000b5d8: 02 80 00 07 be 4000b5f4 <rtems_libio_to_fcntl_flags+0x28>
4000b5dc: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
4000b5e0: 80 88 60 02 btst 2, %g1
4000b5e4: 12 80 00 04 bne 4000b5f4 <rtems_libio_to_fcntl_flags+0x28><== ALWAYS TAKEN
4000b5e8: 90 10 20 00 clr %o0
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
4000b5ec: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
4000b5f0: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
4000b5f4: 80 88 60 01 btst 1, %g1
4000b5f8: 02 80 00 04 be 4000b608 <rtems_libio_to_fcntl_flags+0x3c>
4000b5fc: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
4000b600: 05 00 00 10 sethi %hi(0x4000), %g2
4000b604: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
4000b608: 32 80 00 02 bne,a 4000b610 <rtems_libio_to_fcntl_flags+0x44>
4000b60c: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
4000b610: 80 88 64 00 btst 0x400, %g1
4000b614: 32 80 00 02 bne,a 4000b61c <rtems_libio_to_fcntl_flags+0x50>
4000b618: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
4000b61c: 81 c3 e0 08 retl
40004760 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
40004760: 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) {
40004764: 3b 10 00 51 sethi %hi(0x40014400), %i5
40004768: c2 07 63 9c ld [ %i5 + 0x39c ], %g1 ! 4001479c <rtems_current_user_env>
4000476c: 39 10 00 51 sethi %hi(0x40014400), %i4
40004770: b8 17 23 a0 or %i4, 0x3a0, %i4 ! 400147a0 <rtems_global_user_env>
40004774: 80 a0 40 1c cmp %g1, %i4
40004778: 02 80 00 0a be 400047a0 <rtems_libio_use_global_env+0x40>
4000477c: 92 17 63 9c or %i5, 0x39c, %o1
sc = rtems_task_variable_delete(
40004780: 40 00 05 af call 40005e3c <rtems_task_variable_delete>
40004784: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
40004788: 80 a2 20 00 cmp %o0, 0
4000478c: 22 80 00 05 be,a 400047a0 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
40004790: f8 27 63 9c st %i4, [ %i5 + 0x39c ]
rtems_fatal_error_occurred(0xdeadbeef);
40004794: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
40004798: 40 00 06 5d call 4000610c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000479c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
400047a0: 81 c7 e0 08 ret
400047a4: 81 e8 00 00 restore
4000771c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
4000771c: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
40007720: 03 10 00 8f sethi %hi(0x40023c00), %g1
40007724: d0 00 61 c4 ld [ %g1 + 0x1c4 ], %o0 ! 40023dc4 <RTEMS_Malloc_Heap>
40007728: 92 10 00 18 mov %i0, %o1
4000772c: 40 00 1b 0c call 4000e35c <_Protected_heap_Get_block_size>
40007730: 94 07 bf fc add %fp, -4, %o2
40007734: 80 8a 20 ff btst 0xff, %o0
40007738: 02 80 00 08 be 40007758 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
4000773c: 03 10 00 94 sethi %hi(0x40025000), %g1
MSBUMP(lifetime_freed, size);
40007740: c8 07 bf fc ld [ %fp + -4 ], %g4
40007744: 82 10 60 90 or %g1, 0x90, %g1
40007748: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
4000774c: 86 80 c0 04 addcc %g3, %g4, %g3
40007750: 84 40 a0 00 addx %g2, 0, %g2
40007754: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
40007758: 81 c7 e0 08 ret
4000775c: 81 e8 00 00 restore
40007760 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
40007760: 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 )
40007764: 80 a6 20 00 cmp %i0, 0
40007768: 02 80 00 14 be 400077b8 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
4000776c: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
40007770: 03 10 00 8f sethi %hi(0x40023c00), %g1
40007774: d0 00 61 c4 ld [ %g1 + 0x1c4 ], %o0 ! 40023dc4 <RTEMS_Malloc_Heap>
40007778: 92 10 00 18 mov %i0, %o1
4000777c: 40 00 1a f8 call 4000e35c <_Protected_heap_Get_block_size>
40007780: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
40007784: 03 10 00 94 sethi %hi(0x40025000), %g1
40007788: c8 07 bf fc ld [ %fp + -4 ], %g4
4000778c: 82 10 60 90 or %g1, 0x90, %g1
40007790: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
40007794: 86 80 c0 04 addcc %g3, %g4, %g3
40007798: 84 40 a0 00 addx %g2, 0, %g2
4000779c: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
400077a0: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
400077a4: 84 20 c0 02 sub %g3, %g2, %g2
if (current_depth > s->max_depth)
400077a8: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
400077ac: 80 a0 80 03 cmp %g2, %g3
400077b0: 38 80 00 02 bgu,a 400077b8 <rtems_malloc_statistics_at_malloc+0x58>
400077b4: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
400077b8: 81 c7 e0 08 ret
400077bc: 81 e8 00 00 restore
4000f7b0 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
4000f7b0: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
4000f7b4: ba 96 20 00 orcc %i0, 0, %i5
4000f7b8: 12 80 00 04 bne 4000f7c8 <rtems_memalign+0x18>
4000f7bc: 03 10 00 6a sethi %hi(0x4001a800), %g1
return EINVAL;
4000f7c0: 81 c7 e0 08 ret
4000f7c4: 91 e8 20 16 restore %g0, 0x16, %o0
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4000f7c8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4000f7cc: 80 a0 60 03 cmp %g1, 3
4000f7d0: 02 80 00 0f be 4000f80c <rtems_memalign+0x5c>
4000f7d4: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
4000f7d8: 7f ff d3 1c call 40004448 <malloc_deferred_frees_process>
4000f7dc: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
4000f7e0: 03 10 00 65 sethi %hi(0x40019400), %g1
4000f7e4: d0 00 63 38 ld [ %g1 + 0x338 ], %o0 ! 40019738 <RTEMS_Malloc_Heap>
4000f7e8: 92 10 00 1a mov %i2, %o1
4000f7ec: 94 10 00 19 mov %i1, %o2
4000f7f0: 7f ff e9 de call 40009f68 <_Protected_heap_Allocate_aligned_with_boundary>
4000f7f4: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
4000f7f8: 80 a2 20 00 cmp %o0, 0
4000f7fc: 12 80 00 0a bne 4000f824 <rtems_memalign+0x74>
4000f800: b8 10 00 08 mov %o0, %i4
4000f804: 81 c7 e0 08 ret
4000f808: 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() )
4000f80c: 7f ff d3 03 call 40004418 <malloc_is_system_state_OK>
4000f810: 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()) &&
4000f814: 80 8a 20 ff btst 0xff, %o0
4000f818: 02 bf ff ea be 4000f7c0 <rtems_memalign+0x10> <== NEVER TAKEN
4000f81c: 01 00 00 00 nop
4000f820: 30 bf ff ee b,a 4000f7d8 <rtems_memalign+0x28>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
4000f824: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000f828: c2 00 62 40 ld [ %g1 + 0x240 ], %g1 ! 40019e40 <rtems_malloc_statistics_helpers>
4000f82c: 80 a0 60 00 cmp %g1, 0
4000f830: 22 80 00 06 be,a 4000f848 <rtems_memalign+0x98>
4000f834: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
4000f838: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000f83c: 9f c0 40 00 call %g1
4000f840: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
4000f844: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
4000f848: 81 c7 e0 08 ret
4000f84c: 91 e8 20 00 restore %g0, 0, %o0
40008ae8 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
40008ae8: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
40008aec: 40 00 65 c3 call 400221f8 <strdup>
40008af0: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
40008af4: b6 92 20 00 orcc %o0, 0, %i3
40008af8: 32 80 00 04 bne,a 40008b08 <rtems_mkdir+0x20>
40008afc: c2 4e c0 00 ldsb [ %i3 ], %g1
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
40008b00: 81 c7 e0 08 ret
40008b04: 91 e8 3f ff restore %g0, -1, %o0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
40008b08: b8 10 20 01 mov 1, %i4
++p;
40008b0c: 82 18 60 2f xor %g1, 0x2f, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
40008b10: b0 10 20 00 clr %i0
++p;
40008b14: 80 a0 00 01 cmp %g0, %g1
retval = 0;
break;
}
}
if (!last)
*p = '/';
40008b18: a0 10 20 2f mov 0x2f, %l0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
40008b1c: b4 66 ff ff subx %i3, -1, %i2
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
40008b20: 82 10 20 01 mov 1, %g1
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
40008b24: 23 00 00 3c sethi %hi(0xf000), %l1
40008b28: 25 00 00 10 sethi %hi(0x4000), %l2
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
40008b2c: c6 4e 80 00 ldsb [ %i2 ], %g3
40008b30: 80 a0 e0 00 cmp %g3, 0
40008b34: 22 80 00 07 be,a 40008b50 <rtems_mkdir+0x68>
40008b38: 84 10 20 01 mov 1, %g2
last = 1;
else if (p[0] != '/')
40008b3c: 80 a0 e0 2f cmp %g3, 0x2f
40008b40: 12 80 00 4f bne 40008c7c <rtems_mkdir+0x194>
40008b44: 84 10 20 00 clr %g2
continue;
*p = '\0';
40008b48: 10 80 00 03 b 40008b54 <rtems_mkdir+0x6c>
40008b4c: c0 2e 80 00 clrb [ %i2 ]
40008b50: c0 2e 80 00 clrb [ %i2 ]
if (!last && p[1] == '\0')
40008b54: 80 a0 a0 00 cmp %g2, 0
40008b58: 12 80 00 05 bne 40008b6c <rtems_mkdir+0x84>
40008b5c: ba 10 20 01 mov 1, %i5
40008b60: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
40008b64: 80 a0 00 02 cmp %g0, %g2
40008b68: ba 60 3f ff subx %g0, -1, %i5
last = 1;
if (first) {
40008b6c: 80 a0 60 00 cmp %g1, 0
40008b70: 02 80 00 08 be 40008b90 <rtems_mkdir+0xa8>
40008b74: 80 a7 60 00 cmp %i5, 0
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
40008b78: 40 00 0a 19 call 4000b3dc <umask>
40008b7c: 90 10 20 00 clr %o0
40008b80: b0 10 00 08 mov %o0, %i0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
40008b84: 40 00 0a 16 call 4000b3dc <umask>
40008b88: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
40008b8c: 80 a7 60 00 cmp %i5, 0
40008b90: 02 80 00 05 be 40008ba4 <rtems_mkdir+0xbc>
40008b94: 92 10 21 ff mov 0x1ff, %o1
(void)umask(oumask);
40008b98: 40 00 0a 11 call 4000b3dc <umask>
40008b9c: 90 10 00 18 mov %i0, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40008ba0: 92 10 00 19 mov %i1, %o1
40008ba4: 7f ff fc b8 call 40007e84 <mkdir>
40008ba8: 90 10 00 1b mov %i3, %o0
40008bac: 80 a2 20 00 cmp %o0, 0
40008bb0: 16 80 00 2d bge 40008c64 <rtems_mkdir+0x17c>
40008bb4: 80 a7 60 00 cmp %i5, 0
if (errno == EEXIST || errno == EISDIR) {
40008bb8: 40 00 5d 63 call 40020144 <__errno>
40008bbc: 01 00 00 00 nop
40008bc0: c2 02 00 00 ld [ %o0 ], %g1
40008bc4: 80 a0 60 11 cmp %g1, 0x11
40008bc8: 12 80 00 09 bne 40008bec <rtems_mkdir+0x104>
40008bcc: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
40008bd0: 40 00 00 3d call 40008cc4 <stat>
40008bd4: 92 07 bf b8 add %fp, -72, %o1
40008bd8: 80 a2 20 00 cmp %o0, 0
40008bdc: 16 80 00 0c bge 40008c0c <rtems_mkdir+0x124> <== ALWAYS TAKEN
40008be0: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
40008be4: 10 80 00 2b b 40008c90 <rtems_mkdir+0x1a8> <== NOT EXECUTED
40008be8: b8 10 20 00 clr %i4 <== NOT EXECUTED
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
40008bec: 40 00 5d 56 call 40020144 <__errno>
40008bf0: 01 00 00 00 nop
40008bf4: c2 02 00 00 ld [ %o0 ], %g1
40008bf8: 80 a0 60 15 cmp %g1, 0x15
40008bfc: 02 bf ff f5 be 40008bd0 <rtems_mkdir+0xe8> <== NEVER TAKEN
40008c00: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
retval = 0;
40008c04: 10 80 00 23 b 40008c90 <rtems_mkdir+0x1a8>
40008c08: b8 10 20 00 clr %i4
break;
} else if (!S_ISDIR(sb.st_mode)) {
40008c0c: 82 08 40 11 and %g1, %l1, %g1
40008c10: 80 a0 40 12 cmp %g1, %l2
40008c14: 02 80 00 0f be 40008c50 <rtems_mkdir+0x168>
40008c18: 80 a7 60 00 cmp %i5, 0
if (last)
40008c1c: 02 80 00 08 be 40008c3c <rtems_mkdir+0x154>
40008c20: 01 00 00 00 nop
errno = EEXIST;
40008c24: 40 00 5d 48 call 40020144 <__errno>
40008c28: b8 10 20 00 clr %i4 ! 0 <PROM_START>
40008c2c: 82 10 20 11 mov 0x11, %g1
40008c30: c2 22 00 00 st %g1, [ %o0 ]
40008c34: 10 80 00 17 b 40008c90 <rtems_mkdir+0x1a8>
40008c38: ba 10 20 01 mov 1, %i5
else
errno = ENOTDIR;
40008c3c: 40 00 5d 42 call 40020144 <__errno>
40008c40: b8 10 20 00 clr %i4
40008c44: 82 10 20 14 mov 0x14, %g1
40008c48: 10 80 00 12 b 40008c90 <rtems_mkdir+0x1a8>
40008c4c: c2 22 00 00 st %g1, [ %o0 ]
retval = 0;
break;
}
if (last)
40008c50: 32 80 00 09 bne,a 40008c74 <rtems_mkdir+0x18c>
40008c54: b8 10 20 02 mov 2, %i4
retval = 0;
break;
}
}
if (!last)
*p = '/';
40008c58: e0 2e 80 00 stb %l0, [ %i2 ]
40008c5c: 10 80 00 07 b 40008c78 <rtems_mkdir+0x190>
40008c60: 84 10 20 00 clr %g2
} else {
retval = 0;
break;
}
}
if (!last)
40008c64: 22 bf ff fe be,a 40008c5c <rtems_mkdir+0x174>
40008c68: e0 2e 80 00 stb %l0, [ %i2 ]
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
40008c6c: 10 80 00 03 b 40008c78 <rtems_mkdir+0x190>
40008c70: 84 10 20 01 mov 1, %g2
40008c74: 84 10 20 01 mov 1, %g2
40008c78: 82 10 20 00 clr %g1
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
40008c7c: 80 a0 a0 00 cmp %g2, 0
40008c80: 02 bf ff ab be 40008b2c <rtems_mkdir+0x44>
40008c84: b4 06 a0 01 inc %i2
40008c88: 10 80 00 03 b 40008c94 <rtems_mkdir+0x1ac>
40008c8c: ba 10 20 01 mov 1, %i5
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
40008c90: 82 10 20 00 clr %g1
}
}
if (!last)
*p = '/';
}
if (!first && !last)
40008c94: 80 97 40 01 orcc %i5, %g1, %g0
40008c98: 12 80 00 04 bne 40008ca8 <rtems_mkdir+0x1c0>
40008c9c: 01 00 00 00 nop
(void)umask(oumask);
40008ca0: 40 00 09 cf call 4000b3dc <umask>
40008ca4: 90 10 00 18 mov %i0, %o0
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
40008ca8: 7f ff fa a7 call 40007744 <free>
40008cac: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
40008cb0: 80 a7 20 00 cmp %i4, 0
40008cb4: 02 bf ff 93 be 40008b00 <rtems_mkdir+0x18>
40008cb8: 01 00 00 00 nop
}
40008cbc: 81 c7 e0 08 ret
40008cc0: 91 e8 20 00 restore %g0, 0, %o0
40002f7c <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
40002f7c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40002f80: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
40002f84: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40002f88: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
40002f8c: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
40002f90: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40002f94: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40002f98: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40002f9c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40002fa0: 7f ff ff 75 call 40002d74 <rtems_verror> <== NOT EXECUTED
40002fa4: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
40002fa8: 90 10 20 00 clr %o0 <== NOT EXECUTED
40002fac: 13 10 00 6f sethi %hi(0x4001bc00), %o1 <== NOT EXECUTED
40002fb0: 7f ff ff d1 call 40002ef4 <rtems_error> <== NOT EXECUTED
40002fb4: 92 12 61 50 or %o1, 0x150, %o1 ! 4001bd50 <IMFS_node_control_default+0xa0><== NOT EXECUTED
_exit(errno);
40002fb8: 40 00 2e ad call 4000ea6c <__errno> <== NOT EXECUTED
40002fbc: 01 00 00 00 nop <== NOT EXECUTED
40002fc0: 40 00 02 3f call 400038bc <_exit> <== NOT EXECUTED
40002fc4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40008430 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
40008430: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
40008434: 80 a6 20 00 cmp %i0, 0
40008438: 02 80 00 38 be 40008518 <rtems_partition_create+0xe8>
4000843c: 82 10 20 03 mov 3, %g1
return RTEMS_INVALID_NAME;
if ( !starting_address )
40008440: 80 a6 60 00 cmp %i1, 0
40008444: 02 80 00 35 be 40008518 <rtems_partition_create+0xe8>
40008448: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
4000844c: 80 a7 60 00 cmp %i5, 0
40008450: 02 80 00 32 be 40008518 <rtems_partition_create+0xe8> <== NEVER TAKEN
40008454: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
40008458: 02 80 00 30 be 40008518 <rtems_partition_create+0xe8>
4000845c: 82 10 20 08 mov 8, %g1
40008460: 80 a6 a0 00 cmp %i2, 0
40008464: 02 80 00 2d be 40008518 <rtems_partition_create+0xe8>
40008468: 80 a6 80 1b cmp %i2, %i3
4000846c: 0a 80 00 2b bcs 40008518 <rtems_partition_create+0xe8>
40008470: 80 8e e0 07 btst 7, %i3
40008474: 12 80 00 29 bne 40008518 <rtems_partition_create+0xe8>
40008478: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
4000847c: 12 80 00 27 bne 40008518 <rtems_partition_create+0xe8>
40008480: 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;
40008484: 03 10 00 8b sethi %hi(0x40022c00), %g1
40008488: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 40022c10 <_Thread_Dispatch_disable_level>
++level;
4000848c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008490: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
* 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 );
40008494: 23 10 00 8a sethi %hi(0x40022800), %l1
40008498: 40 00 07 08 call 4000a0b8 <_Objects_Allocate>
4000849c: 90 14 62 0c or %l1, 0x20c, %o0 ! 40022a0c <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
400084a0: a0 92 20 00 orcc %o0, 0, %l0
400084a4: 32 80 00 06 bne,a 400084bc <rtems_partition_create+0x8c>
400084a8: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
400084ac: 40 00 0c 03 call 4000b4b8 <_Thread_Enable_dispatch>
400084b0: 01 00 00 00 nop
return RTEMS_TOO_MANY;
400084b4: 10 80 00 19 b 40008518 <rtems_partition_create+0xe8>
400084b8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5>
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
400084bc: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
400084c0: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
400084c4: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
400084c8: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
400084cc: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
400084d0: 40 00 45 b3 call 40019b9c <.udiv>
400084d4: 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,
400084d8: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
400084dc: 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,
400084e0: 96 10 00 1b mov %i3, %o3
400084e4: b8 04 20 24 add %l0, 0x24, %i4
400084e8: 40 00 04 74 call 400096b8 <_Chain_Initialize>
400084ec: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
400084f0: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400084f4: a2 14 62 0c or %l1, 0x20c, %l1
400084f8: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
400084fc: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008500: 85 28 a0 02 sll %g2, 2, %g2
40008504: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
40008508: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
4000850c: 40 00 0b eb call 4000b4b8 <_Thread_Enable_dispatch>
40008510: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
40008514: 82 10 20 00 clr %g1
}
40008518: 81 c7 e0 08 ret
4000851c: 91 e8 00 01 restore %g0, %g1, %o0
40015c10 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
40015c10: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
40015c14: 11 10 00 f4 sethi %hi(0x4003d000), %o0
40015c18: 92 10 00 18 mov %i0, %o1
40015c1c: 90 12 23 84 or %o0, 0x384, %o0
40015c20: 40 00 14 2b call 4001accc <_Objects_Get>
40015c24: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
40015c28: c2 07 bf fc ld [ %fp + -4 ], %g1
40015c2c: 80 a0 60 00 cmp %g1, 0
40015c30: 12 80 00 21 bne 40015cb4 <rtems_partition_return_buffer+0xa4>
40015c34: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
40015c38: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
40015c3c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40015c40: 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 ) &&
40015c44: 80 a6 40 01 cmp %i1, %g1
40015c48: 18 80 00 0b bgu 40015c74 <rtems_partition_return_buffer+0x64><== NEVER TAKEN
40015c4c: 82 10 20 00 clr %g1
40015c50: 80 a6 40 08 cmp %i1, %o0
40015c54: 0a 80 00 09 bcs 40015c78 <rtems_partition_return_buffer+0x68>
40015c58: 80 a0 60 00 cmp %g1, 0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
40015c5c: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
40015c60: 40 00 58 3d call 4002bd54 <.urem>
40015c64: 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 ) &&
40015c68: 80 a0 00 08 cmp %g0, %o0
40015c6c: 10 80 00 02 b 40015c74 <rtems_partition_return_buffer+0x64>
40015c70: 82 60 3f ff subx %g0, -1, %g1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
40015c74: 80 a0 60 00 cmp %g1, 0
40015c78: 02 80 00 0b be 40015ca4 <rtems_partition_return_buffer+0x94>
40015c7c: 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 );
40015c80: 40 00 0c 98 call 40018ee0 <_Chain_Append>
40015c84: 92 10 00 19 mov %i1, %o1
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
40015c88: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
40015c8c: 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;
40015c90: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
40015c94: 40 00 17 b9 call 4001bb78 <_Thread_Enable_dispatch>
40015c98: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
40015c9c: 81 c7 e0 08 ret
40015ca0: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
40015ca4: 40 00 17 b5 call 4001bb78 <_Thread_Enable_dispatch>
40015ca8: b0 10 20 09 mov 9, %i0
40015cac: 81 c7 e0 08 ret
40015cb0: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40015cb4: 81 c7 e0 08 ret
40015cb8: 91 e8 20 04 restore %g0, 4, %o0
40032844 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
40032844: 9d e3 bf 98 save %sp, -104, %sp
40032848: 11 10 01 8f sethi %hi(0x40063c00), %o0
4003284c: 92 10 00 18 mov %i0, %o1
40032850: 90 12 20 98 or %o0, 0x98, %o0
40032854: 7f ff 56 c1 call 40008358 <_Objects_Get>
40032858: 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 ) {
4003285c: c2 07 bf fc ld [ %fp + -4 ], %g1
40032860: 80 a0 60 00 cmp %g1, 0
40032864: 12 80 00 6a bne 40032a0c <rtems_rate_monotonic_period+0x1c8>
40032868: ba 10 00 08 mov %o0, %i5
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
4003286c: 37 10 01 8d sethi %hi(0x40063400), %i3
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
40032870: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
40032874: b6 16 e2 d0 or %i3, 0x2d0, %i3
40032878: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4003287c: 80 a0 80 01 cmp %g2, %g1
40032880: 02 80 00 06 be 40032898 <rtems_rate_monotonic_period+0x54>
40032884: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
40032888: 7f ff 5a 35 call 4000915c <_Thread_Enable_dispatch>
4003288c: b0 10 20 17 mov 0x17, %i0
40032890: 81 c7 e0 08 ret
40032894: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
40032898: 12 80 00 0d bne 400328cc <rtems_rate_monotonic_period+0x88>
4003289c: 01 00 00 00 nop
switch ( the_period->state ) {
400328a0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400328a4: 80 a0 60 04 cmp %g1, 4
400328a8: 18 80 00 05 bgu 400328bc <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
400328ac: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400328b0: 05 10 01 74 sethi %hi(0x4005d000), %g2
400328b4: 84 10 a0 78 or %g2, 0x78, %g2 ! 4005d078 <CSWTCH.24>
400328b8: f0 08 80 01 ldub [ %g2 + %g1 ], %i0
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
400328bc: 7f ff 5a 28 call 4000915c <_Thread_Enable_dispatch>
400328c0: 01 00 00 00 nop
400328c4: 81 c7 e0 08 ret
400328c8: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
400328cc: 7f ff 3d 5a call 40001e34 <sparc_disable_interrupts>
400328d0: 01 00 00 00 nop
400328d4: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
400328d8: f8 07 60 38 ld [ %i5 + 0x38 ], %i4
400328dc: 80 a7 20 00 cmp %i4, 0
400328e0: 12 80 00 15 bne 40032934 <rtems_rate_monotonic_period+0xf0>
400328e4: 80 a7 20 02 cmp %i4, 2
_ISR_Enable( level );
400328e8: 7f ff 3d 57 call 40001e44 <sparc_enable_interrupts>
400328ec: 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 );
400328f0: 90 10 00 1d mov %i5, %o0
400328f4: 7f ff ff b8 call 400327d4 <_Rate_monotonic_Initiate_statistics>
400328f8: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
400328fc: 82 10 20 02 mov 2, %g1
40032900: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40032904: 03 10 00 ca sethi %hi(0x40032800), %g1
40032908: 82 10 62 18 or %g1, 0x218, %g1 ! 40032a18 <_Rate_monotonic_Timeout>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4003290c: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
40032910: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
the_watchdog->id = id;
40032914: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
40032918: c0 27 60 34 clr [ %i5 + 0x34 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4003291c: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40032920: 11 10 01 8c sethi %hi(0x40063000), %o0
40032924: 92 07 60 10 add %i5, 0x10, %o1
40032928: 7f ff 5d 1c call 40009d98 <_Watchdog_Insert>
4003292c: 90 12 22 58 or %o0, 0x258, %o0
40032930: 30 80 00 1b b,a 4003299c <rtems_rate_monotonic_period+0x158>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
40032934: 12 80 00 1e bne 400329ac <rtems_rate_monotonic_period+0x168>
40032938: 80 a7 20 04 cmp %i4, 4
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
4003293c: 7f ff ff 5d call 400326b0 <_Rate_monotonic_Update_statistics>
40032940: 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;
40032944: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
40032948: 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;
4003294c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
40032950: 7f ff 3d 3d call 40001e44 <sparc_enable_interrupts>
40032954: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
40032958: d0 06 e0 10 ld [ %i3 + 0x10 ], %o0
4003295c: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40032960: 13 00 00 10 sethi %hi(0x4000), %o1
40032964: 7f ff 5c 27 call 40009a00 <_Thread_Set_state>
40032968: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
4003296c: 7f ff 3d 32 call 40001e34 <sparc_disable_interrupts>
40032970: 01 00 00 00 nop
local_state = the_period->state;
40032974: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
40032978: f8 27 60 38 st %i4, [ %i5 + 0x38 ]
_ISR_Enable( level );
4003297c: 7f ff 3d 32 call 40001e44 <sparc_enable_interrupts>
40032980: 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 )
40032984: 80 a6 a0 03 cmp %i2, 3
40032988: 12 80 00 05 bne 4003299c <rtems_rate_monotonic_period+0x158>
4003298c: 01 00 00 00 nop
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40032990: d0 06 e0 10 ld [ %i3 + 0x10 ], %o0
40032994: 7f ff 59 1c call 40008e04 <_Thread_Clear_state>
40032998: 13 00 00 10 sethi %hi(0x4000), %o1
_Thread_Enable_dispatch();
4003299c: 7f ff 59 f0 call 4000915c <_Thread_Enable_dispatch>
400329a0: b0 10 20 00 clr %i0
400329a4: 81 c7 e0 08 ret
400329a8: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
400329ac: 12 bf ff b9 bne 40032890 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
400329b0: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
400329b4: 7f ff ff 3f call 400326b0 <_Rate_monotonic_Update_statistics>
400329b8: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
400329bc: 7f ff 3d 22 call 40001e44 <sparc_enable_interrupts>
400329c0: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
400329c4: 82 10 20 02 mov 2, %g1
400329c8: 92 07 60 10 add %i5, 0x10, %o1
400329cc: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
400329d0: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
400329d4: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
400329d8: 11 10 01 8c sethi %hi(0x40063000), %o0
400329dc: 7f ff 5c ef call 40009d98 <_Watchdog_Insert>
400329e0: 90 12 22 58 or %o0, 0x258, %o0 ! 40063258 <_Watchdog_Ticks_chain>
400329e4: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
400329e8: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
400329ec: 03 10 01 7b sethi %hi(0x4005ec00), %g1
400329f0: c2 00 63 34 ld [ %g1 + 0x334 ], %g1 ! 4005ef34 <_Scheduler+0x34>
400329f4: 9f c0 40 00 call %g1
400329f8: 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();
400329fc: 7f ff 59 d8 call 4000915c <_Thread_Enable_dispatch>
40032a00: 01 00 00 00 nop
40032a04: 81 c7 e0 08 ret
40032a08: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40032a0c: b0 10 20 04 mov 4, %i0
}
40032a10: 81 c7 e0 08 ret
40032a14: 81 e8 00 00 restore
400258dc <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
400258dc: 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 )
400258e0: 80 a6 60 00 cmp %i1, 0
400258e4: 02 80 00 75 be 40025ab8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
400258e8: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
400258ec: 13 10 01 68 sethi %hi(0x4005a000), %o1
400258f0: 9f c6 40 00 call %i1
400258f4: 92 12 62 d0 or %o1, 0x2d0, %o1 ! 4005a2d0 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
400258f8: 90 10 00 18 mov %i0, %o0
400258fc: 13 10 01 68 sethi %hi(0x4005a000), %o1
40025900: 9f c6 40 00 call %i1
40025904: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 4005a2f0 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
40025908: 90 10 00 18 mov %i0, %o0
4002590c: 13 10 01 68 sethi %hi(0x4005a000), %o1
40025910: 9f c6 40 00 call %i1
40025914: 92 12 63 18 or %o1, 0x318, %o1 ! 4005a318 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
40025918: 90 10 00 18 mov %i0, %o0
4002591c: 13 10 01 68 sethi %hi(0x4005a000), %o1
40025920: 9f c6 40 00 call %i1
40025924: 92 12 63 40 or %o1, 0x340, %o1 ! 4005a340 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
40025928: 90 10 00 18 mov %i0, %o0
4002592c: 13 10 01 68 sethi %hi(0x4005a000), %o1
40025930: 9f c6 40 00 call %i1
40025934: 92 12 63 90 or %o1, 0x390, %o1 ! 4005a390 <_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 ;
40025938: 03 10 01 8f sethi %hi(0x40063c00), %g1
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
4002593c: 39 10 01 68 sethi %hi(0x4005a000), %i4
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
40025940: 37 10 01 68 sethi %hi(0x4005a000), %i3
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
40025944: 35 10 01 69 sethi %hi(0x4005a400), %i2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
40025948: 21 10 01 6e sethi %hi(0x4005b800), %l0
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002594c: fa 00 60 a0 ld [ %g1 + 0xa0 ], %i5
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
40025950: b8 17 23 e0 or %i4, 0x3e0, %i4
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
40025954: b6 16 e3 f8 or %i3, 0x3f8, %i3
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
40025958: b4 16 a0 18 or %i2, 0x18, %i2
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002595c: 10 80 00 52 b 40025aa4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
40025960: a0 14 20 a0 or %l0, 0xa0, %l0
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
40025964: 40 00 32 75 call 40032338 <rtems_rate_monotonic_get_statistics>
40025968: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
4002596c: 80 a2 20 00 cmp %o0, 0
40025970: 32 80 00 4d bne,a 40025aa4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
40025974: ba 07 60 01 inc %i5
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
40025978: 92 07 bf b0 add %fp, -80, %o1
4002597c: 40 00 32 e0 call 400324fc <rtems_rate_monotonic_get_status>
40025980: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
40025984: d0 07 bf b0 ld [ %fp + -80 ], %o0
40025988: 92 10 20 05 mov 5, %o1
4002598c: 7f ff a2 51 call 4000e2d0 <rtems_object_get_name>
40025990: 94 07 bf a0 add %fp, -96, %o2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
40025994: d8 1f bf c8 ldd [ %fp + -56 ], %o4
40025998: 92 10 00 1c mov %i4, %o1
4002599c: 90 10 00 18 mov %i0, %o0
400259a0: 94 10 00 1d mov %i5, %o2
400259a4: 9f c6 40 00 call %i1
400259a8: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
400259ac: d2 07 bf c8 ld [ %fp + -56 ], %o1
400259b0: 80 a2 60 00 cmp %o1, 0
400259b4: 12 80 00 07 bne 400259d0 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
400259b8: 94 07 bf a8 add %fp, -88, %o2
(*print)( context, "\n" );
400259bc: 90 10 00 18 mov %i0, %o0
400259c0: 9f c6 40 00 call %i1
400259c4: 92 10 00 10 mov %l0, %o1
continue;
400259c8: 10 80 00 37 b 40025aa4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
400259cc: ba 07 60 01 inc %i5
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
400259d0: 40 00 03 2b call 4002667c <_Timespec_Divide_by_integer>
400259d4: 90 07 bf e0 add %fp, -32, %o0
(*print)( context,
400259d8: d0 07 bf d4 ld [ %fp + -44 ], %o0
400259dc: 40 00 a8 c8 call 4004fcfc <.div>
400259e0: 92 10 23 e8 mov 0x3e8, %o1
400259e4: a6 10 00 08 mov %o0, %l3
400259e8: d0 07 bf dc ld [ %fp + -36 ], %o0
400259ec: 40 00 a8 c4 call 4004fcfc <.div>
400259f0: 92 10 23 e8 mov 0x3e8, %o1
400259f4: c2 07 bf a8 ld [ %fp + -88 ], %g1
400259f8: a2 10 00 08 mov %o0, %l1
400259fc: d0 07 bf ac ld [ %fp + -84 ], %o0
40025a00: e8 07 bf d0 ld [ %fp + -48 ], %l4
40025a04: e4 07 bf d8 ld [ %fp + -40 ], %l2
40025a08: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40025a0c: 40 00 a8 bc call 4004fcfc <.div>
40025a10: 92 10 23 e8 mov 0x3e8, %o1
40025a14: 96 10 00 13 mov %l3, %o3
40025a18: 98 10 00 12 mov %l2, %o4
40025a1c: 9a 10 00 11 mov %l1, %o5
40025a20: 94 10 00 14 mov %l4, %o2
40025a24: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40025a28: 92 10 00 1b mov %i3, %o1
40025a2c: 9f c6 40 00 call %i1
40025a30: 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);
40025a34: d2 07 bf c8 ld [ %fp + -56 ], %o1
40025a38: 94 07 bf a8 add %fp, -88, %o2
40025a3c: 40 00 03 10 call 4002667c <_Timespec_Divide_by_integer>
40025a40: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
40025a44: d0 07 bf ec ld [ %fp + -20 ], %o0
40025a48: 40 00 a8 ad call 4004fcfc <.div>
40025a4c: 92 10 23 e8 mov 0x3e8, %o1
40025a50: a6 10 00 08 mov %o0, %l3
40025a54: d0 07 bf f4 ld [ %fp + -12 ], %o0
40025a58: 40 00 a8 a9 call 4004fcfc <.div>
40025a5c: 92 10 23 e8 mov 0x3e8, %o1
40025a60: c2 07 bf a8 ld [ %fp + -88 ], %g1
40025a64: a2 10 00 08 mov %o0, %l1
40025a68: d0 07 bf ac ld [ %fp + -84 ], %o0
40025a6c: e8 07 bf e8 ld [ %fp + -24 ], %l4
40025a70: e4 07 bf f0 ld [ %fp + -16 ], %l2
40025a74: 92 10 23 e8 mov 0x3e8, %o1
40025a78: 40 00 a8 a1 call 4004fcfc <.div>
40025a7c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40025a80: 92 10 00 1a mov %i2, %o1
40025a84: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40025a88: 94 10 00 14 mov %l4, %o2
40025a8c: 90 10 00 18 mov %i0, %o0
40025a90: 96 10 00 13 mov %l3, %o3
40025a94: 98 10 00 12 mov %l2, %o4
40025a98: 9f c6 40 00 call %i1
40025a9c: 9a 10 00 11 mov %l1, %o5
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
40025aa0: ba 07 60 01 inc %i5
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
40025aa4: 03 10 01 8f sethi %hi(0x40063c00), %g1
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
40025aa8: c2 00 60 a4 ld [ %g1 + 0xa4 ], %g1 ! 40063ca4 <_Rate_monotonic_Information+0xc>
40025aac: 80 a7 40 01 cmp %i5, %g1
40025ab0: 08 bf ff ad bleu 40025964 <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
40025ab4: 90 10 00 1d mov %i5, %o0
40025ab8: 81 c7 e0 08 ret
40025abc: 81 e8 00 00 restore
40007e08 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
40007e08: 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;
40007e0c: 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;
40007e10: 90 10 00 19 mov %i1, %o0
40007e14: 92 10 00 1d mov %i5, %o1
40007e18: 40 00 2d 6b call 400133c4 <.urem>
40007e1c: b6 10 00 19 mov %i1, %i3
if (excess > 0) {
40007e20: 80 a2 20 00 cmp %o0, 0
40007e24: 02 80 00 05 be 40007e38 <rtems_rbheap_allocate+0x30> <== ALWAYS TAKEN
40007e28: 80 a6 c0 19 cmp %i3, %i1
value += alignment - excess;
40007e2c: b6 06 40 1d add %i1, %i5, %i3 <== NOT EXECUTED
40007e30: b6 26 c0 08 sub %i3, %o0, %i3 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
40007e34: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
40007e38: 0a 80 00 04 bcs 40007e48 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
40007e3c: 80 a6 60 00 cmp %i1, 0
40007e40: 32 80 00 04 bne,a 40007e50 <rtems_rbheap_allocate+0x48>
40007e44: c2 06 00 00 ld [ %i0 ], %g1
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
40007e48: 81 c7 e0 08 ret
40007e4c: 91 e8 20 00 restore %g0, 0, %o0
rtems_chain_control *free_chain,
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
40007e50: 84 06 20 04 add %i0, 4, %g2
rtems_rbheap_chunk *big_enough = NULL;
40007e54: 10 80 00 06 b 40007e6c <rtems_rbheap_allocate+0x64>
40007e58: ba 10 20 00 clr %i5
while (current != tail && big_enough == NULL) {
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
40007e5c: 80 a0 c0 1b cmp %g3, %i3
40007e60: ba 40 3f ff addx %g0, -1, %i5
40007e64: ba 08 40 1d and %g1, %i5, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
40007e68: c2 00 40 00 ld [ %g1 ], %g1
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
40007e6c: 80 a7 60 00 cmp %i5, 0
40007e70: 12 80 00 04 bne 40007e80 <rtems_rbheap_allocate+0x78>
40007e74: 80 a0 40 02 cmp %g1, %g2
40007e78: 32 bf ff f9 bne,a 40007e5c <rtems_rbheap_allocate+0x54>
40007e7c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
40007e80: 80 a7 60 00 cmp %i5, 0
40007e84: 02 bf ff f1 be 40007e48 <rtems_rbheap_allocate+0x40>
40007e88: 01 00 00 00 nop
uintptr_t free_size = free_chunk->size;
40007e8c: f4 07 60 1c ld [ %i5 + 0x1c ], %i2
if (free_size > aligned_size) {
40007e90: 80 a6 80 1b cmp %i2, %i3
40007e94: 28 80 00 14 bleu,a 40007ee4 <rtems_rbheap_allocate+0xdc>
40007e98: c4 07 40 00 ld [ %i5 ], %g2
rtems_rbheap_chunk *new_chunk = get_chunk(control);
40007e9c: 7f ff ff 80 call 40007c9c <get_chunk>
40007ea0: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
40007ea4: b8 92 20 00 orcc %o0, 0, %i4
40007ea8: 02 bf ff e8 be 40007e48 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
40007eac: b4 26 80 1b sub %i2, %i3, %i2
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
40007eb0: 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;
40007eb4: f4 27 60 1c st %i2, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
40007eb8: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
40007ebc: b4 06 80 01 add %i2, %g1, %i2
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
40007ec0: c0 27 20 04 clr [ %i4 + 4 ]
40007ec4: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
40007ec8: c0 27 00 00 clr [ %i4 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
40007ecc: 90 06 20 18 add %i0, 0x18, %o0
40007ed0: 40 00 06 97 call 4000992c <_RBTree_Insert_unprotected>
40007ed4: 92 07 20 08 add %i4, 8, %o1
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
40007ed8: f0 07 20 18 ld [ %i4 + 0x18 ], %i0
40007edc: 81 c7 e0 08 ret
40007ee0: 81 e8 00 00 restore
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40007ee4: c2 07 60 04 ld [ %i5 + 4 ], %g1
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
40007ee8: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
40007eec: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40007ef0: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
40007ef4: c0 27 60 04 clr [ %i5 + 4 ]
40007ef8: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
40007efc: 81 c7 e0 08 ret
40007f00: 81 e8 00 00 restore
40008034 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
40008034: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
40008038: 7f ff ed ef call 400037f4 <malloc> <== NOT EXECUTED
4000803c: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
40008040: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008044: 02 80 00 07 be 40008060 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
40008048: 82 06 20 0c add %i0, 0xc, %g1 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000804c: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
40008050: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
40008054: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
the_node->next = before_node;
40008058: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
4000805c: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
40008060: 81 c7 e0 08 ret <== NOT EXECUTED
40008064: 81 e8 00 00 restore <== NOT EXECUTED
40007f04 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
40007f04: 9d e3 bf 80 save %sp, -128, %sp
40007f08: b6 10 00 18 mov %i0, %i3
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
40007f0c: 80 a6 60 00 cmp %i1, 0
40007f10: 02 80 00 45 be 40008024 <rtems_rbheap_free+0x120>
40007f14: b0 10 20 00 clr %i0
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
40007f18: 90 07 bf e0 add %fp, -32, %o0
40007f1c: 92 10 20 00 clr %o1
40007f20: 94 10 20 20 mov 0x20, %o2
40007f24: 40 00 21 0b call 40010350 <memset>
40007f28: b4 06 e0 18 add %i3, 0x18, %i2
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
40007f2c: ba 10 20 00 clr %i5
40007f30: f2 27 bf f8 st %i1, [ %fp + -8 ]
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
40007f34: 10 80 00 12 b 40007f7c <rtems_rbheap_free+0x78>
40007f38: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
40007f3c: 90 07 bf e8 add %fp, -24, %o0
40007f40: 9f c0 40 00 call %g1
40007f44: 92 10 00 1c mov %i4, %o1
if ( _RBTree_Is_equal( compare_result ) ) {
40007f48: 80 a2 20 00 cmp %o0, 0
40007f4c: 12 80 00 07 bne 40007f68 <rtems_rbheap_free+0x64>
40007f50: 83 3a 20 1f sra %o0, 0x1f, %g1
found = iter_node;
if ( the_rbtree->is_unique )
40007f54: c2 0e a0 14 ldub [ %i2 + 0x14 ], %g1
40007f58: 80 a0 60 00 cmp %g1, 0
40007f5c: 12 80 00 0c bne 40007f8c <rtems_rbheap_free+0x88> <== ALWAYS TAKEN
40007f60: ba 10 00 1c mov %i4, %i5
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
40007f64: 83 3a 20 1f sra %o0, 0x1f, %g1 <== NOT EXECUTED
40007f68: 90 20 40 08 sub %g1, %o0, %o0
40007f6c: 91 32 20 1f srl %o0, 0x1f, %o0
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
40007f70: 91 2a 20 02 sll %o0, 2, %o0
40007f74: b8 07 00 08 add %i4, %o0, %i4
40007f78: f8 07 20 04 ld [ %i4 + 4 ], %i4
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
40007f7c: 80 a7 20 00 cmp %i4, 0
40007f80: 32 bf ff ef bne,a 40007f3c <rtems_rbheap_free+0x38>
40007f84: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40007f88: b8 10 00 1d mov %i5, %i4
return rtems_rbheap_chunk_of_node(
40007f8c: ba 07 3f f8 add %i4, -8, %i5
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
40007f90: 80 a7 7f f8 cmp %i5, -8
40007f94: 02 80 00 24 be 40008024 <rtems_rbheap_free+0x120>
40007f98: 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);
40007f9c: c4 07 3f f8 ld [ %i4 + -8 ], %g2
40007fa0: 80 a0 a0 00 cmp %g2, 0
40007fa4: 12 80 00 05 bne 40007fb8 <rtems_rbheap_free+0xb4>
40007fa8: 82 10 20 00 clr %g1
40007fac: c2 07 60 04 ld [ %i5 + 4 ], %g1
40007fb0: 80 a0 00 01 cmp %g0, %g1
40007fb4: 82 60 3f ff subx %g0, -1, %g1
if (!rtems_rbheap_is_chunk_free(chunk)) {
40007fb8: 80 a0 60 00 cmp %g1, 0
40007fbc: 02 80 00 1a be 40008024 <rtems_rbheap_free+0x120>
40007fc0: b0 10 20 0e mov 0xe, %i0
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
40007fc4: b8 07 60 08 add %i5, 8, %i4
40007fc8: 92 10 20 00 clr %o1
40007fcc: 40 00 06 fd call 40009bc0 <_RBTree_Next_unprotected>
40007fd0: 90 10 00 1c mov %i4, %o0
40007fd4: 92 10 20 01 mov 1, %o1
40007fd8: b2 10 00 08 mov %o0, %i1
40007fdc: 40 00 06 f9 call 40009bc0 <_RBTree_Next_unprotected>
40007fe0: 90 10 00 1c mov %i4, %o0
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
40007fe4: 92 10 00 1a mov %i2, %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
40007fe8: 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);
40007fec: 94 10 00 1d mov %i5, %o2
40007ff0: 7f ff ff 02 call 40007bf8 <check_and_merge>
40007ff4: 90 10 00 1b mov %i3, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40007ff8: c2 06 c0 00 ld [ %i3 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40007ffc: f6 27 60 04 st %i3, [ %i5 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
40008000: fa 26 c0 00 st %i5, [ %i3 ]
the_node->next = before_node;
40008004: c2 27 40 00 st %g1, [ %i5 ]
before_node->previous = the_node;
40008008: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
4000800c: 90 10 00 1b mov %i3, %o0
40008010: 92 10 00 1a mov %i2, %o1
40008014: 94 10 00 1d mov %i5, %o2
40008018: 96 06 7f f8 add %i1, -8, %o3
4000801c: 7f ff fe f7 call 40007bf8 <check_and_merge>
40008020: b0 10 20 00 clr %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
40008024: 81 c7 e0 08 ret
40008028: 81 e8 00 00 restore
40018f28 <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)
{
40018f28: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
40018f2c: 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)
{
40018f30: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
40018f34: 80 a0 60 00 cmp %g1, 0
40018f38: 02 80 00 0f be 40018f74 <rtems_rfs_bitmap_load_map+0x4c>
40018f3c: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
40018f40: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
40018f44: d4 07 60 08 ld [ %i5 + 8 ], %o2
40018f48: d0 07 60 04 ld [ %i5 + 4 ], %o0
40018f4c: d2 07 40 00 ld [ %i5 ], %o1
40018f50: 40 00 06 e8 call 4001aaf0 <rtems_rfs_buffer_handle_request>
40018f54: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
40018f58: b0 92 20 00 orcc %o0, 0, %i0
40018f5c: 12 80 00 06 bne 40018f74 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
40018f60: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
40018f64: c2 07 40 00 ld [ %i5 ], %g1
40018f68: c2 00 60 08 ld [ %g1 + 8 ], %g1
40018f6c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40018f70: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
40018f74: 81 c7 e0 08 ret
40018f78: 81 e8 00 00 restore
400194f8 <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)
{
400194f8: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
400194fc: c0 2e 80 00 clrb [ %i2 ]
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
40019500: 10 80 00 2d b 400195b4 <rtems_rfs_bitmap_map_alloc+0xbc>
40019504: ba 10 00 19 mov %i1, %i5
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
40019508: 2a 80 00 07 bcs,a 40019524 <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
4001950c: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
break;
}
if (lower_seed >= 0)
40019510: 80 a6 60 00 cmp %i1, 0
40019514: 36 80 00 17 bge,a 40019570 <rtems_rfs_bitmap_map_alloc+0x78>
40019518: 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)
4001951c: 10 80 00 10 b 4001955c <rtems_rfs_bitmap_map_alloc+0x64>
40019520: c2 06 20 0c ld [ %i0 + 0xc ], %g1
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
40019524: 90 10 00 18 mov %i0, %o0
40019528: 92 10 00 1b mov %i3, %o1
4001952c: 94 10 00 1a mov %i2, %o2
40019530: 7f ff fe 93 call 40018f7c <rtems_rfs_search_map_for_clear_bit.constprop.1>
40019534: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
40019538: 80 a2 20 00 cmp %o0, 0
4001953c: 34 80 00 2d bg,a 400195f0 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
40019540: b0 10 20 00 clr %i0 <== NOT EXECUTED
40019544: c2 0e 80 00 ldub [ %i2 ], %g1
40019548: 80 a0 60 00 cmp %g1, 0
4001954c: 02 bf ff f2 be 40019514 <rtems_rfs_bitmap_map_alloc+0x1c>
40019550: 80 a6 60 00 cmp %i1, 0
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
40019554: 81 c7 e0 08 ret
40019558: 91 e8 20 00 restore %g0, 0, %o0
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
4001955c: 80 a7 40 01 cmp %i5, %g1
40019560: 2a 80 00 12 bcs,a 400195a8 <rtems_rfs_bitmap_map_alloc+0xb0>
40019564: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
40019568: 10 80 00 11 b 400195ac <rtems_rfs_bitmap_map_alloc+0xb4>
4001956c: 80 a6 60 00 cmp %i1, 0
}
if (lower_seed >= 0)
{
*bit = lower_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
40019570: 90 10 00 18 mov %i0, %o0
40019574: 92 10 00 1b mov %i3, %o1
40019578: 94 10 00 1a mov %i2, %o2
4001957c: 7f ff fe 80 call 40018f7c <rtems_rfs_search_map_for_clear_bit.constprop.1>
40019580: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
40019584: 80 a2 20 00 cmp %o0, 0
40019588: 34 80 00 1a bg,a 400195f0 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
4001958c: b0 10 20 00 clr %i0 <== NOT EXECUTED
40019590: c2 0e 80 00 ldub [ %i2 ], %g1
40019594: 80 a0 60 00 cmp %g1, 0
40019598: 22 bf ff f1 be,a 4001955c <rtems_rfs_bitmap_map_alloc+0x64>
4001959c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
400195a0: 81 c7 e0 08 ret
400195a4: 91 e8 20 00 restore %g0, 0, %o0
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
upper_seed += window;
if (lower_seed >= 0)
400195a8: 80 a6 60 00 cmp %i1, 0
400195ac: 36 80 00 02 bge,a 400195b4 <rtems_rfs_bitmap_map_alloc+0xbc>
400195b0: b2 06 78 00 add %i1, -2048, %i1
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
400195b4: 80 a7 60 00 cmp %i5, 0
400195b8: 06 80 00 07 bl 400195d4 <rtems_rfs_bitmap_map_alloc+0xdc>
400195bc: 80 a6 60 00 cmp %i1, 0
400195c0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400195c4: 80 a7 40 01 cmp %i5, %g1
400195c8: 2a bf ff d7 bcs,a 40019524 <rtems_rfs_bitmap_map_alloc+0x2c>
400195cc: fa 26 c0 00 st %i5, [ %i3 ]
|| ((lower_seed >= 0) && (lower_seed < control->size)))
400195d0: 80 a6 60 00 cmp %i1, 0
400195d4: 26 80 00 07 bl,a 400195f0 <rtems_rfs_bitmap_map_alloc+0xf8>
400195d8: b0 10 20 00 clr %i0
400195dc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400195e0: 80 a6 40 01 cmp %i1, %g1
400195e4: 0a bf ff c9 bcs 40019508 <rtems_rfs_bitmap_map_alloc+0x10>
400195e8: 80 a7 40 01 cmp %i5, %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
400195ec: b0 10 20 00 clr %i0
400195f0: 81 c7 e0 08 ret
400195f4: 81 e8 00 00 restore
400191fc <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
return mask;
}
400191fc: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
40019200: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
40019204: 81 c3 e0 08 retl <== NOT EXECUTED
40019208: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
4001920c <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
4001920c: 82 10 00 08 mov %o0, %g1
rtems_rfs_bitmap_element mask = 0;
if (end > start)
40019210: 80 a2 40 01 cmp %o1, %g1
40019214: 08 80 00 06 bleu 4001922c <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
40019218: 90 10 20 00 clr %o0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001921c: 92 20 40 09 sub %g1, %o1, %o1
40019220: 90 10 3f ff mov -1, %o0
40019224: 91 32 00 09 srl %o0, %o1, %o0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
40019228: 91 2a 00 01 sll %o0, %g1, %o0
return mask;
}
4001922c: 81 c3 e0 08 retl
40019960 <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)
{
40019960: 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);
40019964: 96 10 20 01 mov 1, %o3
40019968: 90 10 00 18 mov %i0, %o0
4001996c: 92 10 00 19 mov %i1, %o1
40019970: 40 00 04 60 call 4001aaf0 <rtems_rfs_buffer_handle_request>
40019974: 94 10 00 1a mov %i2, %o2
if (rc > 0)
40019978: 80 a2 20 00 cmp %o0, 0
4001997c: 14 80 00 26 bg 40019a14 <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
40019980: 87 2e e0 02 sll %i3, 2, %g3
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
40019984: c2 06 60 08 ld [ %i1 + 8 ], %g1
40019988: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
4001998c: 90 10 20 00 clr %o0
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
40019990: 84 01 00 03 add %g4, %g3, %g2
40019994: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
40019998: fa 08 a0 03 ldub [ %g2 + 3 ], %i5
4001999c: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
400199a0: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
400199a4: 83 28 60 18 sll %g1, 0x18, %g1
400199a8: 85 28 a0 08 sll %g2, 8, %g2
400199ac: 82 17 40 01 or %i5, %g1, %g1
400199b0: 87 28 e0 10 sll %g3, 0x10, %g3
400199b4: 82 10 40 03 or %g1, %g3, %g1
400199b8: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
400199bc: 84 38 00 01 xnor %g0, %g1, %g2
400199c0: 80 a0 00 02 cmp %g0, %g2
400199c4: 84 60 20 00 subx %g0, 0, %g2
400199c8: 82 08 40 02 and %g1, %g2, %g1
if (*result >= rtems_rfs_fs_blocks (fs))
400199cc: c4 06 20 04 ld [ %i0 + 4 ], %g2
400199d0: 80 a0 40 02 cmp %g1, %g2
400199d4: 0a 80 00 10 bcs 40019a14 <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
400199d8: c2 27 00 00 st %g1, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
400199dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
400199e0: 7f ff e4 6c call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
400199e4: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
400199e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400199ec: 22 80 00 09 be,a 40019a10 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
400199f0: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
400199f4: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
400199f8: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400199fc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40019a00: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
40019a04: 40 00 1f 29 call 400216a8 <printf> <== NOT EXECUTED
40019a08: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
40019a0c: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
40019a10: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
40019a14: 81 c7 e0 08 ret
40019a18: 91 e8 00 08 restore %g0, %o0, %o0
40019a80 <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)
{
40019a80: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
40019a84: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
40019a88: 32 80 00 06 bne,a 40019aa0 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
40019a8c: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
40019a90: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
40019a94: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
40019a98: 81 c7 e0 08 ret <== NOT EXECUTED
40019a9c: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
40019aa0: 94 10 20 00 clr %o2 <== NOT EXECUTED
40019aa4: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
40019aa8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40019aac: 40 00 53 86 call 4002e8c4 <__udivdi3> <== NOT EXECUTED
40019ab0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40019ab4: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
40019ab8: 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;
40019abc: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
40019ac0: 94 10 20 00 clr %o2 <== NOT EXECUTED
40019ac4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40019ac8: 40 00 54 53 call 4002ec14 <__umoddi3> <== NOT EXECUTED
40019acc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
40019ad0: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
40019ad4: 81 c7 e0 08 ret <== NOT EXECUTED
40019ad8: 81 e8 00 00 restore <== NOT EXECUTED
40019cc0 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
40019cc0: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
40019cc4: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
40019cc8: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
40019ccc: 80 a0 60 00 cmp %g1, 0
40019cd0: 02 80 00 61 be 40019e54 <rtems_rfs_block_map_close+0x194>
40019cd4: b0 10 20 00 clr %i0
40019cd8: d2 06 60 04 ld [ %i1 + 4 ], %o1
40019cdc: 80 a2 60 00 cmp %o1, 0
40019ce0: 22 80 00 5e be,a 40019e58 <rtems_rfs_block_map_close+0x198><== NEVER TAKEN
40019ce4: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
40019ce8: 7f ff dc f4 call 400110b8 <rtems_rfs_inode_load>
40019cec: 90 10 00 1d mov %i5, %o0
if (brc > 0)
40019cf0: b0 92 20 00 orcc %o0, 0, %i0
40019cf4: 14 80 00 59 bg 40019e58 <rtems_rfs_block_map_close+0x198> <== NEVER TAKEN
40019cf8: 92 06 60 38 add %i1, 0x38, %o1
40019cfc: 82 10 20 00 clr %g1
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40019d00: b8 10 20 01 mov 1, %i4
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
40019d04: c4 06 60 04 ld [ %i1 + 4 ], %g2
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
40019d08: 87 28 60 02 sll %g1, 2, %g3
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
40019d0c: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
40019d10: 86 06 40 03 add %i1, %g3, %g3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
40019d14: c6 00 e0 24 ld [ %g3 + 0x24 ], %g3
40019d18: 88 00 60 06 add %g1, 6, %g4
40019d1c: 89 29 20 02 sll %g4, 2, %g4
40019d20: b6 06 c0 04 add %i3, %g4, %i3
40019d24: b5 30 e0 18 srl %g3, 0x18, %i2
40019d28: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
40019d2c: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
40019d30: b5 30 e0 10 srl %g3, 0x10, %i2
40019d34: b6 06 c0 04 add %i3, %g4, %i3
40019d38: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
40019d3c: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
40019d40: b5 30 e0 08 srl %g3, 8, %i2
40019d44: b6 06 c0 04 add %i3, %g4, %i3
40019d48: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
40019d4c: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
40019d50: 82 00 60 01 inc %g1
40019d54: 88 06 c0 04 add %i3, %g4, %g4
40019d58: c6 29 20 07 stb %g3, [ %g4 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40019d5c: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
40019d60: 80 a0 60 05 cmp %g1, 5
40019d64: 12 bf ff e8 bne 40019d04 <rtems_rfs_block_map_close+0x44>
40019d68: 86 10 20 01 mov 1, %g3
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
40019d6c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40019d70: c4 06 60 08 ld [ %i1 + 8 ], %g2
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
40019d74: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019d78: b9 30 a0 18 srl %g2, 0x18, %i4
40019d7c: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
40019d80: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019d84: b9 30 a0 10 srl %g2, 0x10, %i4
40019d88: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
40019d8c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019d90: b9 30 a0 08 srl %g2, 8, %i4
40019d94: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
40019d98: c8 00 60 0c ld [ %g1 + 0xc ], %g4
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40019d9c: 90 10 00 1d mov %i5, %o0
40019da0: c4 29 20 0f stb %g2, [ %g4 + 0xf ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40019da4: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
40019da8: c2 06 60 04 ld [ %i1 + 4 ], %g1
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
40019dac: f8 0e 60 0e ldub [ %i1 + 0xe ], %i4
40019db0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40019db4: c8 06 60 0c ld [ %i1 + 0xc ], %g4
40019db8: f8 28 a0 0a stb %i4, [ %g2 + 0xa ]
40019dbc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40019dc0: 94 10 20 01 mov 1, %o2
40019dc4: c8 28 a0 0b stb %g4, [ %g2 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40019dc8: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
40019dcc: c2 06 60 04 ld [ %i1 + 4 ], %g1
40019dd0: 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);
40019dd4: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019dd8: b9 30 a0 18 srl %g2, 0x18, %i4
40019ddc: f8 29 20 30 stb %i4, [ %g4 + 0x30 ]
40019de0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019de4: b9 30 a0 10 srl %g2, 0x10, %i4
40019de8: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
40019dec: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019df0: b9 30 a0 08 srl %g2, 8, %i4
40019df4: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
40019df8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019dfc: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40019e00: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
40019e04: c2 06 60 04 ld [ %i1 + 4 ], %g1
40019e08: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
40019e0c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019e10: b9 30 a0 18 srl %g2, 0x18, %i4
40019e14: f8 29 20 34 stb %i4, [ %g4 + 0x34 ]
40019e18: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019e1c: b9 30 a0 10 srl %g2, 0x10, %i4
40019e20: f8 29 20 35 stb %i4, [ %g4 + 0x35 ]
40019e24: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019e28: b9 30 a0 08 srl %g2, 8, %i4
40019e2c: f8 29 20 36 stb %i4, [ %g4 + 0x36 ]
40019e30: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40019e34: c4 29 20 37 stb %g2, [ %g4 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40019e38: d2 06 60 04 ld [ %i1 + 4 ], %o1
40019e3c: 7f ff dd 02 call 40011244 <rtems_rfs_inode_unload>
40019e40: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
40019e44: c0 2e 40 00 clrb [ %i1 ]
40019e48: 82 38 00 08 xnor %g0, %o0, %g1
40019e4c: 83 38 60 1f sra %g1, 0x1f, %g1
40019e50: b0 0a 00 01 and %o0, %g1, %i0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40019e54: 92 06 60 38 add %i1, 0x38, %o1
}
}
map->inode = NULL;
40019e58: c0 26 60 04 clr [ %i1 + 4 ]
40019e5c: 40 00 02 b1 call 4001a920 <rtems_rfs_buffer_handle_release>
40019e60: 90 10 00 1d mov %i5, %o0
40019e64: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
40019e68: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
40019e6c: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
40019e70: 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);
40019e74: 40 00 02 ab call 4001a920 <rtems_rfs_buffer_handle_release>
40019e78: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
40019e7c: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
40019e80: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
40019e84: 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;
}
40019e88: 81 c7 e0 08 ret
40019e8c: 81 e8 00 00 restore
40019e90 <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)
{
40019e90: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
40019e94: 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))
40019e98: fa 06 80 00 ld [ %i2 ], %i5
40019e9c: 80 a7 60 00 cmp %i5, 0
40019ea0: 02 80 00 05 be 40019eb4 <rtems_rfs_block_map_find+0x24>
40019ea4: f8 06 60 08 ld [ %i1 + 8 ], %i4
40019ea8: 80 a7 20 00 cmp %i4, 0
40019eac: 02 80 00 53 be 40019ff8 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
40019eb0: 90 10 20 06 mov 6, %o0
40019eb4: 80 a7 40 1c cmp %i5, %i4
40019eb8: 1a 80 00 50 bcc 40019ff8 <rtems_rfs_block_map_find+0x168>
40019ebc: 90 10 20 06 mov 6, %o0
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
40019ec0: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40019ec4: 80 a7 40 01 cmp %i5, %g1
40019ec8: 12 80 00 08 bne 40019ee8 <rtems_rfs_block_map_find+0x58>
40019ecc: 80 a7 20 05 cmp %i4, 5
40019ed0: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40019ed4: 80 a0 60 00 cmp %g1, 0
40019ed8: 02 80 00 04 be 40019ee8 <rtems_rfs_block_map_find+0x58>
40019edc: 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];
40019ee0: 10 80 00 3d b 40019fd4 <rtems_rfs_block_map_find+0x144>
40019ee4: c2 26 c0 00 st %g1, [ %i3 ]
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
40019ee8: 38 80 00 08 bgu,a 40019f08 <rtems_rfs_block_map_find+0x78>
40019eec: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
{
*block = map->blocks[bpos->bno];
40019ef0: ba 07 60 08 add %i5, 8, %i5
40019ef4: bb 2f 60 02 sll %i5, 2, %i5
40019ef8: ba 06 40 1d add %i1, %i5, %i5
40019efc: c2 07 60 04 ld [ %i5 + 4 ], %g1
40019f00: 10 80 00 35 b 40019fd4 <rtems_rfs_block_map_find+0x144>
40019f04: 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;
40019f08: 90 10 00 1d mov %i5, %o0
40019f0c: 40 00 4f 9f call 4002dd88 <.urem>
40019f10: 92 10 00 10 mov %l0, %o1
singly = bpos->bno / fs->blocks_per_block;
40019f14: 92 10 00 10 mov %l0, %o1
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
40019f18: a2 10 00 08 mov %o0, %l1
singly = bpos->bno / fs->blocks_per_block;
40019f1c: 7f ff a1 d8 call 4000267c <.udiv>
40019f20: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
40019f24: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
40019f28: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
40019f2c: 80 a7 00 01 cmp %i4, %g1
40019f30: 18 80 00 09 bgu 40019f54 <rtems_rfs_block_map_find+0xc4> <== NEVER TAKEN
40019f34: ba 10 00 08 mov %o0, %i5
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
40019f38: ba 02 20 08 add %o0, 8, %i5
40019f3c: 92 06 60 38 add %i1, 0x38, %o1
40019f40: bb 2f 60 02 sll %i5, 2, %i5
40019f44: 90 10 00 18 mov %i0, %o0
40019f48: ba 06 40 1d add %i1, %i5, %i5
40019f4c: 10 80 00 1c b 40019fbc <rtems_rfs_block_map_find+0x12c>
40019f50: d4 07 60 04 ld [ %i5 + 4 ], %o2
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
40019f54: 40 00 4f 8d call 4002dd88 <.urem> <== NOT EXECUTED
40019f58: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
40019f5c: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
40019f60: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
40019f64: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
40019f68: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED
40019f6c: 1a 80 00 23 bcc 40019ff8 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
40019f70: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
40019f74: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40019f78: 7f ff a1 c1 call 4000267c <.udiv> <== NOT EXECUTED
40019f7c: 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,
40019f80: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
40019f84: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
40019f88: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
40019f8c: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
40019f90: b8 06 60 44 add %i1, 0x44, %i4 <== NOT EXECUTED
40019f94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40019f98: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40019f9c: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
40019fa0: 7f ff fe 70 call 40019960 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
40019fa4: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
40019fa8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019fac: 12 80 00 13 bne 40019ff8 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
40019fb0: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
40019fb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40019fb8: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
40019fbc: 96 10 00 11 mov %l1, %o3
40019fc0: 7f ff fe 68 call 40019960 <rtems_rfs_block_find_indirect>
40019fc4: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
40019fc8: 80 a2 20 00 cmp %o0, 0
40019fcc: 12 80 00 0b bne 40019ff8 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
40019fd0: 01 00 00 00 nop
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
40019fd4: c2 06 80 00 ld [ %i2 ], %g1
map->bpos.block = *block;
40019fd8: 90 10 20 00 clr %o0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
40019fdc: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
40019fe0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40019fe4: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
40019fe8: c2 06 a0 08 ld [ %i2 + 8 ], %g1
40019fec: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
map->bpos.block = *block;
40019ff0: c2 06 c0 00 ld [ %i3 ], %g1
40019ff4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
40019ff8: 81 c7 e0 08 ret
40019ffc: 91 e8 00 08 restore %g0, %o0, %o0
4001a0a8 <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)
{
4001a0a8: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001a0ac: 90 10 20 00 clr %o0
4001a0b0: 13 00 00 08 sethi %hi(0x2000), %o1
4001a0b4: 7f ff e2 b7 call 40012b90 <rtems_rfs_trace>
4001a0b8: ba 10 00 18 mov %i0, %i5
4001a0bc: 80 8a 20 ff btst 0xff, %o0
4001a0c0: 22 80 00 08 be,a 4001a0e0 <rtems_rfs_block_map_grow+0x38><== ALWAYS TAKEN
4001a0c4: c4 06 60 08 ld [ %i1 + 8 ], %g2
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
4001a0c8: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
4001a0cc: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001a0d0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001a0d4: 40 00 1d 75 call 400216a8 <printf> <== NOT EXECUTED
4001a0d8: 90 12 20 40 or %o0, 0x40, %o0 <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001a0dc: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001a0e0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
4001a0e4: 84 06 80 02 add %i2, %g2, %g2
4001a0e8: 80 a0 80 01 cmp %g2, %g1
4001a0ec: 1a 80 00 b2 bcc 4001a3b4 <rtems_rfs_block_map_grow+0x30c> <== NEVER TAKEN
4001a0f0: b0 10 20 1b mov 0x1b, %i0
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
4001a0f4: 10 80 00 d4 b 4001a444 <rtems_rfs_block_map_grow+0x39c>
4001a0f8: a0 10 20 00 clr %l0
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
4001a0fc: 90 10 00 1d mov %i5, %o0
4001a100: 94 10 20 00 clr %o2
4001a104: 7f ff da c5 call 40010c18 <rtems_rfs_group_bitmap_alloc>
4001a108: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
4001a10c: b0 92 20 00 orcc %o0, 0, %i0
4001a110: 14 80 00 d4 bg 4001a460 <rtems_rfs_block_map_grow+0x3b8>
4001a114: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
4001a118: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001a11c: 80 a7 20 04 cmp %i4, 4
4001a120: 38 80 00 08 bgu,a 4001a140 <rtems_rfs_block_map_grow+0x98>
4001a124: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
map->blocks[map->size.count] = block;
4001a128: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001a12c: b8 07 20 08 add %i4, 8, %i4
4001a130: b9 2f 20 02 sll %i4, 2, %i4
4001a134: b8 06 40 1c add %i1, %i4, %i4
4001a138: 10 80 00 b7 b 4001a414 <rtems_rfs_block_map_grow+0x36c>
4001a13c: c2 27 20 04 st %g1, [ %i4 + 4 ]
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
4001a140: 90 10 00 1c mov %i4, %o0
4001a144: 40 00 4f 11 call 4002dd88 <.urem>
4001a148: 92 10 00 18 mov %i0, %o1
singly = map->size.count / fs->blocks_per_block;
4001a14c: 92 10 00 18 mov %i0, %o1
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
4001a150: a4 10 00 08 mov %o0, %l2
singly = map->size.count / fs->blocks_per_block;
4001a154: 7f ff a1 4a call 4000267c <.udiv>
4001a158: 90 10 00 1c mov %i4, %o0
if (map->size.count < fs->block_map_singly_blocks)
4001a15c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
4001a160: 80 a7 00 01 cmp %i4, %g1
4001a164: 1a 80 00 1d bcc 4001a1d8 <rtems_rfs_block_map_grow+0x130> <== NEVER TAKEN
4001a168: ac 10 00 08 mov %o0, %l6
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
4001a16c: 80 a4 a0 00 cmp %l2, 0
4001a170: 22 80 00 07 be,a 4001a18c <rtems_rfs_block_map_grow+0xe4><== NEVER TAKEN
4001a174: b8 1f 20 05 xor %i4, 5, %i4 <== NOT EXECUTED
4001a178: 80 a4 a0 05 cmp %l2, 5
4001a17c: 12 80 00 10 bne 4001a1bc <rtems_rfs_block_map_grow+0x114>
4001a180: 80 a2 20 00 cmp %o0, 0
4001a184: 12 80 00 0e bne 4001a1bc <rtems_rfs_block_map_grow+0x114> <== NEVER TAKEN
4001a188: b8 1f 20 05 xor %i4, 5, %i4
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001a18c: 80 a0 00 1c cmp %g0, %i4
&map->singly_buffer,
&map->blocks[singly],
4001a190: 96 05 a0 08 add %l6, 8, %o3
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001a194: 90 10 00 1d mov %i5, %o0
&map->singly_buffer,
&map->blocks[singly],
4001a198: 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,
4001a19c: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
4001a1a0: 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,
4001a1a4: 94 10 00 11 mov %l1, %o2
4001a1a8: 96 02 e0 04 add %o3, 4, %o3
4001a1ac: 7f ff fd 9c call 4001981c <rtems_rfs_block_map_indirect_alloc>
4001a1b0: 98 60 3f ff subx %g0, -1, %o4
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
4001a1b4: 10 80 00 7a b 4001a39c <rtems_rfs_block_map_grow+0x2f4>
4001a1b8: b0 92 20 00 orcc %o0, 0, %i0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a1bc: ac 05 a0 08 add %l6, 8, %l6
4001a1c0: 90 10 00 1d mov %i5, %o0
4001a1c4: ad 2d a0 02 sll %l6, 2, %l6
4001a1c8: 92 10 00 11 mov %l1, %o1
4001a1cc: ac 06 40 16 add %i1, %l6, %l6
4001a1d0: 10 80 00 70 b 4001a390 <rtems_rfs_block_map_grow+0x2e8>
4001a1d4: d4 05 a0 04 ld [ %l6 + 4 ], %o2
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
4001a1d8: 7f ff a1 29 call 4000267c <.udiv> <== NOT EXECUTED
4001a1dc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001a1e0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
4001a1e4: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001a1e8: 40 00 4e e8 call 4002dd88 <.urem> <== NOT EXECUTED
4001a1ec: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
4001a1f0: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001a1f4: 12 80 00 4a bne 4001a31c <rtems_rfs_block_map_grow+0x274> <== NOT EXECUTED
4001a1f8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001a1fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a200: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001a204: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4001a208: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
4001a20c: 7f ff fd 84 call 4001981c <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001a210: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
4001a214: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001a218: 04 80 00 04 ble 4001a228 <rtems_rfs_block_map_grow+0x180> <== NOT EXECUTED
4001a21c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
4001a220: 10 80 00 62 b 4001a3a8 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
4001a224: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
4001a228: 22 80 00 08 be,a 4001a248 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
4001a22c: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001a230: 80 a7 20 05 cmp %i4, 5 <== NOT EXECUTED
4001a234: 12 80 00 13 bne 4001a280 <rtems_rfs_block_map_grow+0x1d8> <== NOT EXECUTED
4001a238: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
4001a23c: 32 80 00 12 bne,a 4001a284 <rtems_rfs_block_map_grow+0x1dc><== NOT EXECUTED
4001a240: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
4001a244: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001a248: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
&map->doubly_buffer,
&map->blocks[doubly],
4001a24c: 96 04 e0 08 add %l3, 8, %o3 <== NOT EXECUTED
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
4001a250: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001a254: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001a258: 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,
4001a25c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001a260: 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,
4001a264: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001a268: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
4001a26c: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
4001a270: 7f ff fd 6b call 4001981c <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001a274: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
4001a278: 10 80 00 0b b 4001a2a4 <rtems_rfs_block_map_grow+0x1fc> <== NOT EXECUTED
4001a27c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001a280: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
4001a284: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
4001a288: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
4001a28c: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
4001a290: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a294: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001a298: 40 00 02 16 call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001a29c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001a2a0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001a2a4: 24 80 00 08 ble,a 4001a2c4 <rtems_rfs_block_map_grow+0x21c><== NOT EXECUTED
4001a2a8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
4001a2ac: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4001a2b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a2b4: 7f ff da dd call 40010e28 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001a2b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
4001a2bc: 10 80 00 3b b 4001a3a8 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
4001a2c0: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
4001a2c4: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
4001a2c8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001a2cc: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
4001a2d0: c4 28 40 1c stb %g2, [ %g1 + %i4 ] <== NOT EXECUTED
4001a2d4: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001a2d8: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
4001a2dc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001a2e0: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
4001a2e4: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
4001a2e8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001a2ec: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
4001a2f0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001a2f4: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
4001a2f8: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
4001a2fc: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
4001a300: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001a304: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001a308: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
4001a30c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001a310: c2 2f 20 03 stb %g1, [ %i4 + 3 ] <== NOT EXECUTED
4001a314: 10 80 00 2a b 4001a3bc <rtems_rfs_block_map_grow+0x314> <== NOT EXECUTED
4001a318: e8 2e 60 44 stb %l4, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001a31c: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
4001a320: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
4001a324: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
4001a328: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
4001a32c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a330: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001a334: 40 00 01 ef call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001a338: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
4001a33c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001a340: 24 80 00 04 ble,a 4001a350 <rtems_rfs_block_map_grow+0x2a8><== NOT EXECUTED
4001a344: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
4001a348: 10 80 00 18 b 4001a3a8 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
4001a34c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001a350: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
4001a354: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a358: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001a35c: 82 00 80 1c add %g2, %i4, %g1 <== NOT EXECUTED
4001a360: d4 08 80 1c ldub [ %g2 + %i4 ], %o2 <== NOT EXECUTED
4001a364: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
4001a368: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001a36c: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001a370: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED
4001a374: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001a378: 94 10 c0 0a or %g3, %o2, %o2 <== NOT EXECUTED
4001a37c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001a380: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a384: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001a388: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
4001a38c: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a390: 40 00 01 d8 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001a394: 96 10 20 01 mov 1, %o3
singly_block, true);
if (rc > 0)
4001a398: b0 92 20 00 orcc %o0, 0, %i0
4001a39c: 24 80 00 09 ble,a 4001a3c0 <rtems_rfs_block_map_grow+0x318><== ALWAYS TAKEN
4001a3a0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
{
rtems_rfs_group_bitmap_free (fs, false, block);
4001a3a4: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
4001a3a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a3ac: 7f ff da 9f call 40010e28 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001a3b0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001a3b4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a3b8: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001a3bc: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
4001a3c0: c4 0f bf f8 ldub [ %fp + -8 ], %g2
4001a3c4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001a3c8: a5 2c a0 02 sll %l2, 2, %l2
4001a3cc: c4 28 40 12 stb %g2, [ %g1 + %l2 ]
4001a3d0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001a3d4: c4 17 bf f8 lduh [ %fp + -8 ], %g2
4001a3d8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001a3dc: 82 00 40 12 add %g1, %l2, %g1
4001a3e0: c4 28 60 01 stb %g2, [ %g1 + 1 ]
4001a3e4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001a3e8: c4 07 bf f8 ld [ %fp + -8 ], %g2
4001a3ec: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001a3f0: 85 30 a0 08 srl %g2, 8, %g2
4001a3f4: 82 00 40 12 add %g1, %l2, %g1
4001a3f8: c4 28 60 02 stb %g2, [ %g1 + 2 ]
4001a3fc: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001a400: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001a404: a4 00 40 12 add %g1, %l2, %l2
4001a408: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001a40c: c2 2c a0 03 stb %g1, [ %l2 + 3 ]
4001a410: e8 2e 60 38 stb %l4, [ %i1 + 0x38 ]
}
map->size.count++;
4001a414: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
4001a418: c0 26 60 0c clr [ %i1 + 0xc ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
4001a41c: 82 00 60 01 inc %g1
4001a420: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
if (b == 0)
4001a424: 80 a4 20 00 cmp %l0, 0
4001a428: 12 80 00 03 bne 4001a434 <rtems_rfs_block_map_grow+0x38c> <== NEVER TAKEN
4001a42c: c2 07 bf f8 ld [ %fp + -8 ], %g1
*new_block = block;
4001a430: c2 26 c0 00 st %g1, [ %i3 ]
map->last_data_block = block;
4001a434: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
map->dirty = true;
4001a438: e8 2e 40 00 stb %l4, [ %i1 ]
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
4001a43c: 10 80 00 05 b 4001a450 <rtems_rfs_block_map_grow+0x3a8>
4001a440: a0 04 20 01 inc %l0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001a444: a8 10 20 01 mov 1, %l4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001a448: aa 06 60 44 add %i1, 0x44, %l5
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a44c: a2 06 60 38 add %i1, 0x38, %l1
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
4001a450: 80 a4 00 1a cmp %l0, %i2
4001a454: 32 bf ff 2a bne,a 4001a0fc <rtems_rfs_block_map_grow+0x54>
4001a458: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
4001a45c: b0 10 20 00 clr %i0
}
4001a460: 81 c7 e0 08 ret
4001a464: 81 e8 00 00 restore
4001981c <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)
{
4001981c: 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);
40019820: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
40019824: 90 10 00 18 mov %i0, %o0
40019828: 94 10 20 00 clr %o2
4001982c: 7f ff dc fb call 40010c18 <rtems_rfs_group_bitmap_alloc>
40019830: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
40019834: ba 92 20 00 orcc %o0, 0, %i5
40019838: 34 80 00 48 bg,a 40019958 <rtems_rfs_block_map_indirect_alloc+0x13c><== NEVER TAKEN
4001983c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
40019840: d4 07 bf fc ld [ %fp + -4 ], %o2
40019844: 90 10 00 18 mov %i0, %o0
40019848: 92 10 00 1a mov %i2, %o1
4001984c: 40 00 04 a9 call 4001aaf0 <rtems_rfs_buffer_handle_request>
40019850: 96 10 20 00 clr %o3
if (rc > 0)
40019854: ba 92 20 00 orcc %o0, 0, %i5
40019858: 04 80 00 07 ble 40019874 <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
4001985c: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
40019860: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40019864: 7f ff dd 71 call 40010e28 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
40019868: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
4001986c: 81 c7 e0 08 ret <== NOT EXECUTED
40019870: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
return rc;
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
40019874: c2 06 a0 08 ld [ %i2 + 8 ], %g1
40019878: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001987c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40019880: 40 00 1f 0c call 400214b0 <memset>
40019884: 92 10 20 ff mov 0xff, %o1
if (upping)
40019888: 80 a7 20 00 cmp %i4, 0
4001988c: 02 80 00 2d be 40019940 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
40019890: 82 10 20 01 mov 1, %g1
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
40019894: 90 10 20 00 clr %o0
40019898: 7f ff e4 be call 40012b90 <rtems_rfs_trace>
4001989c: 13 00 00 08 sethi %hi(0x2000), %o1
400198a0: 80 8a 20 ff btst 0xff, %o0
400198a4: 02 80 00 07 be 400198c0 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
400198a8: 84 10 00 19 mov %i1, %g2
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
400198ac: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400198b0: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400198b4: 40 00 1f 7d call 400216a8 <printf> <== NOT EXECUTED
400198b8: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 400343b8 <CSWTCH.2+0x8> <== NOT EXECUTED
400198bc: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
400198c0: 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]);
400198c4: 86 10 20 01 mov 1, %g3
400198c8: c8 06 a0 08 ld [ %i2 + 8 ], %g4
400198cc: fa 08 a0 24 ldub [ %g2 + 0x24 ], %i5
400198d0: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
400198d4: fa 29 00 01 stb %i5, [ %g4 + %g1 ]
400198d8: c8 06 a0 08 ld [ %i2 + 8 ], %g4
400198dc: fa 10 a0 24 lduh [ %g2 + 0x24 ], %i5
400198e0: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
400198e4: 88 01 00 01 add %g4, %g1, %g4
400198e8: fa 29 20 01 stb %i5, [ %g4 + 1 ]
400198ec: c8 06 a0 08 ld [ %i2 + 8 ], %g4
400198f0: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
400198f4: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
400198f8: bb 37 60 08 srl %i5, 8, %i5
400198fc: 88 01 00 01 add %g4, %g1, %g4
40019900: fa 29 20 02 stb %i5, [ %g4 + 2 ]
40019904: c8 06 a0 08 ld [ %i2 + 8 ], %g4
40019908: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
4001990c: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
40019910: 84 00 a0 04 add %g2, 4, %g2
40019914: 88 01 00 01 add %g4, %g1, %g4
40019918: fa 29 20 03 stb %i5, [ %g4 + 3 ]
4001991c: 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++)
40019920: 80 a0 60 14 cmp %g1, 0x14
40019924: 12 bf ff e9 bne 400198c8 <rtems_rfs_block_map_indirect_alloc+0xac>
40019928: c6 2e 80 00 stb %g3, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
4001992c: 90 06 60 24 add %i1, 0x24, %o0
40019930: 92 10 20 00 clr %o1
40019934: 40 00 1e df call 400214b0 <memset>
40019938: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
4001993c: 82 10 20 01 mov 1, %g1
40019940: c2 2e 80 00 stb %g1, [ %i2 ]
*block = new_block;
40019944: c2 07 bf fc ld [ %fp + -4 ], %g1
map->last_map_block = new_block;
return 0;
40019948: ba 10 20 00 clr %i5
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
4001994c: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
40019950: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
}
40019954: b0 10 00 1d mov %i5, %i0
40019958: 81 c7 e0 08 ret
4001995c: 81 e8 00 00 restore
4001973c <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)
{
4001973c: 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) ||
40019740: 80 a7 20 00 cmp %i4, 0
40019744: 02 80 00 09 be 40019768 <rtems_rfs_block_map_indirect_shrink+0x2c><== NEVER TAKEN
40019748: 82 06 e0 08 add %i3, 8, %g1
4001974c: 80 a7 20 05 cmp %i4, 5
40019750: 32 80 00 2f bne,a 4001980c <rtems_rfs_block_map_indirect_shrink+0xd0>
40019754: b0 10 20 00 clr %i0
40019758: 80 a6 e0 00 cmp %i3, 0
4001975c: 32 80 00 2c bne,a 4001980c <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
40019760: b0 10 20 00 clr %i0 <== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
40019764: 82 06 e0 08 add %i3, 8, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
40019768: 80 a7 20 05 cmp %i4, 5
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
4001976c: 83 28 60 02 sll %g1, 2, %g1
40019770: 82 06 40 01 add %i1, %g1, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
40019774: 12 80 00 1a bne 400197dc <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
40019778: fa 00 60 04 ld [ %g1 + 4 ], %i5
4001977c: 80 a6 e0 00 cmp %i3, 0
40019780: 32 80 00 18 bne,a 400197e0 <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
40019784: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
40019788: c2 06 a0 08 ld [ %i2 + 8 ], %g1
4001978c: 84 10 20 00 clr %g2
40019790: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40019794: f8 08 40 00 ldub [ %g1 ], %i4
40019798: c8 08 60 01 ldub [ %g1 + 1 ], %g4
4001979c: b9 2f 20 18 sll %i4, 0x18, %i4
400197a0: 89 29 20 10 sll %g4, 0x10, %g4
400197a4: 88 17 00 04 or %i4, %g4, %g4
400197a8: f8 08 60 03 ldub [ %g1 + 3 ], %i4
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
400197ac: 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);
400197b0: 88 11 00 1c or %g4, %i4, %g4
400197b4: f8 08 60 02 ldub [ %g1 + 2 ], %i4
400197b8: 84 00 a0 04 add %g2, 4, %g2
400197bc: b9 2f 20 08 sll %i4, 8, %i4
400197c0: 88 11 00 1c or %g4, %i4, %g4
400197c4: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
400197c8: 80 a0 a0 14 cmp %g2, 0x14
400197cc: 12 bf ff f2 bne 40019794 <rtems_rfs_block_map_indirect_shrink+0x58>
400197d0: 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);
400197d4: 10 80 00 07 b 400197f0 <rtems_rfs_block_map_indirect_shrink+0xb4>
400197d8: 90 10 00 18 mov %i0, %o0
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
400197dc: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
400197e0: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
400197e4: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
400197e8: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
400197ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400197f0: 92 10 20 00 clr %o1
400197f4: 7f ff dd 8d call 40010e28 <rtems_rfs_group_bitmap_free>
400197f8: 94 10 00 1d mov %i5, %o2
if (rc > 0)
400197fc: b0 92 20 00 orcc %o0, 0, %i0
40019800: 14 80 00 05 bg 40019814 <rtems_rfs_block_map_indirect_shrink+0xd8><== NEVER TAKEN
40019804: 01 00 00 00 nop
return rc;
map->last_map_block = block_to_free;
40019808: fa 26 60 1c st %i5, [ %i1 + 0x1c ]
4001980c: 81 c7 e0 08 ret
40019810: 81 e8 00 00 restore
}
return rc;
}
40019814: 81 c7 e0 08 ret <== NOT EXECUTED
40019818: 81 e8 00 00 restore <== NOT EXECUTED
40019b3c <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)
{
40019b3c: 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;
40019b40: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
40019b44: 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;
40019b48: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
40019b4c: 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;
40019b50: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
40019b54: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
40019b58: 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;
40019b5c: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
40019b60: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
40019b64: 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;
40019b68: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
40019b6c: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
40019b70: 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);
40019b74: 90 10 00 18 mov %i0, %o0
40019b78: 7f ff dd 50 call 400110b8 <rtems_rfs_inode_load>
40019b7c: 92 10 00 19 mov %i1, %o1
if (rc > 0)
40019b80: ba 92 20 00 orcc %o0, 0, %i5
40019b84: 14 80 00 40 bg 40019c84 <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
40019b88: 84 10 20 00 clr %g2
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
40019b8c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
40019b90: f2 26 a0 04 st %i1, [ %i2 + 4 ]
40019b94: 88 00 a0 06 add %g2, 6, %g4
40019b98: 89 29 20 02 sll %g4, 2, %g4
40019b9c: 88 00 40 04 add %g1, %g4, %g4
40019ba0: 86 01 20 04 add %g4, 4, %g3
40019ba4: f8 09 20 04 ldub [ %g4 + 4 ], %i4
40019ba8: c8 09 20 05 ldub [ %g4 + 5 ], %g4
40019bac: b9 2f 20 18 sll %i4, 0x18, %i4
40019bb0: 89 29 20 10 sll %g4, 0x10, %g4
40019bb4: b8 17 00 04 or %i4, %g4, %i4
40019bb8: c8 08 e0 03 ldub [ %g3 + 3 ], %g4
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
}
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
40019bbc: bb 28 a0 02 sll %g2, 2, %i5
40019bc0: b8 17 00 04 or %i4, %g4, %i4
40019bc4: c8 08 e0 02 ldub [ %g3 + 2 ], %g4
40019bc8: ba 06 80 1d add %i2, %i5, %i5
40019bcc: 89 29 20 08 sll %g4, 8, %g4
40019bd0: 86 17 00 04 or %i4, %g4, %g3
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
40019bd4: 84 00 a0 01 inc %g2
40019bd8: 80 a0 a0 05 cmp %g2, 5
40019bdc: 12 bf ff ee bne 40019b94 <rtems_rfs_block_map_open+0x58>
40019be0: c6 27 60 24 st %g3, [ %i5 + 0x24 ]
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
40019be4: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
40019be8: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
40019bec: 87 28 e0 18 sll %g3, 0x18, %g3
40019bf0: 85 28 a0 10 sll %g2, 0x10, %g2
40019bf4: 84 10 c0 02 or %g3, %g2, %g2
40019bf8: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
40019bfc: 84 10 80 03 or %g2, %g3, %g2
40019c00: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
40019c04: 87 28 e0 08 sll %g3, 8, %g3
40019c08: 84 10 80 03 or %g2, %g3, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
40019c0c: c4 26 a0 08 st %g2, [ %i2 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
40019c10: 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);
40019c14: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
40019c18: 85 28 a0 08 sll %g2, 8, %g2
40019c1c: 84 10 c0 02 or %g3, %g2, %g2
40019c20: c4 26 a0 0c st %g2, [ %i2 + 0xc ]
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
40019c24: c6 08 60 30 ldub [ %g1 + 0x30 ], %g3
40019c28: c4 08 60 31 ldub [ %g1 + 0x31 ], %g2
40019c2c: 87 28 e0 18 sll %g3, 0x18, %g3
40019c30: 85 28 a0 10 sll %g2, 0x10, %g2
40019c34: 84 10 c0 02 or %g3, %g2, %g2
40019c38: c6 08 60 33 ldub [ %g1 + 0x33 ], %g3
40019c3c: 84 10 80 03 or %g2, %g3, %g2
40019c40: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
40019c44: 87 28 e0 08 sll %g3, 8, %g3
40019c48: 84 10 80 03 or %g2, %g3, %g2
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
40019c4c: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
40019c50: c4 08 60 35 ldub [ %g1 + 0x35 ], %g2
40019c54: c6 08 60 34 ldub [ %g1 + 0x34 ], %g3
40019c58: 85 28 a0 10 sll %g2, 0x10, %g2
40019c5c: 87 28 e0 18 sll %g3, 0x18, %g3
40019c60: 86 10 c0 02 or %g3, %g2, %g3
40019c64: c4 08 60 37 ldub [ %g1 + 0x37 ], %g2
40019c68: 86 10 c0 02 or %g3, %g2, %g3
40019c6c: c4 08 60 36 ldub [ %g1 + 0x36 ], %g2
40019c70: 85 28 a0 08 sll %g2, 8, %g2
40019c74: 82 10 c0 02 or %g3, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
40019c78: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
40019c7c: 7f ff dd 72 call 40011244 <rtems_rfs_inode_unload>
40019c80: 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);
40019c84: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
40019c88: 40 00 03 26 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40019c8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40019c90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
40019c94: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
40019c98: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
40019c9c: 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);
40019ca0: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
40019ca4: 40 00 03 1f call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40019ca8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
handle->dirty = false;
40019cac: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
40019cb0: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
40019cb4: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
40019cb8: 81 c7 e0 08 ret <== NOT EXECUTED
40019cbc: 81 e8 00 00 restore <== NOT EXECUTED
4001a468 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
4001a468: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
4001a46c: 90 10 20 00 clr %o0
4001a470: 7f ff e1 c8 call 40012b90 <rtems_rfs_trace>
4001a474: 13 00 00 10 sethi %hi(0x4000), %o1
4001a478: 80 8a 20 ff btst 0xff, %o0
4001a47c: 22 80 00 08 be,a 4001a49c <rtems_rfs_block_map_shrink+0x34><== ALWAYS TAKEN
4001a480: c2 06 60 08 ld [ %i1 + 8 ], %g1
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
4001a484: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
4001a488: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001a48c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001a490: 40 00 1c 86 call 400216a8 <printf> <== NOT EXECUTED
4001a494: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
4001a498: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4001a49c: 80 a0 60 00 cmp %g1, 0
4001a4a0: 12 80 00 04 bne 4001a4b0 <rtems_rfs_block_map_shrink+0x48>
4001a4a4: 80 a6 80 01 cmp %i2, %g1
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
4001a4a8: 10 80 00 b8 b 4001a788 <rtems_rfs_block_map_shrink+0x320>
4001a4ac: 90 10 20 00 clr %o0
4001a4b0: 38 80 00 90 bgu,a 4001a6f0 <rtems_rfs_block_map_shrink+0x288><== NEVER TAKEN
4001a4b4: b4 10 00 01 mov %g1, %i2 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001a4b8: 10 80 00 8f b 4001a6f4 <rtems_rfs_block_map_shrink+0x28c>
4001a4bc: a4 06 60 44 add %i1, 0x44, %l2
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
4001a4c0: ba 00 7f ff add %g1, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
4001a4c4: 80 a7 60 04 cmp %i5, 4
4001a4c8: 38 80 00 08 bgu,a 4001a4e8 <rtems_rfs_block_map_shrink+0x80>
4001a4cc: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
4001a4d0: 82 00 60 07 add %g1, 7, %g1
4001a4d4: 83 28 60 02 sll %g1, 2, %g1
4001a4d8: 82 06 40 01 add %i1, %g1, %g1
4001a4dc: fa 00 60 04 ld [ %g1 + 4 ], %i5
map->blocks[block] = 0;
4001a4e0: 10 80 00 76 b 4001a6b8 <rtems_rfs_block_map_shrink+0x250>
4001a4e4: c0 20 60 04 clr [ %g1 + 4 ]
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
4001a4e8: 90 10 00 1d mov %i5, %o0
4001a4ec: 40 00 4e 27 call 4002dd88 <.urem>
4001a4f0: 92 10 00 1b mov %i3, %o1
singly = block / fs->blocks_per_block;
4001a4f4: 92 10 00 1b mov %i3, %o1
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
4001a4f8: b8 10 00 08 mov %o0, %i4
singly = block / fs->blocks_per_block;
4001a4fc: 7f ff a0 60 call 4000267c <.udiv>
4001a500: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
4001a504: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001a508: 80 a7 40 01 cmp %i5, %g1
4001a50c: 1a 80 00 20 bcc 4001a58c <rtems_rfs_block_map_shrink+0x124><== NEVER TAKEN
4001a510: a2 10 00 08 mov %o0, %l1
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a514: 82 02 20 08 add %o0, 8, %g1
4001a518: 83 28 60 02 sll %g1, 2, %g1
4001a51c: 82 06 40 01 add %i1, %g1, %g1
4001a520: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001a524: 90 10 00 18 mov %i0, %o0
4001a528: 92 10 00 10 mov %l0, %o1
4001a52c: 40 00 01 71 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001a530: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
4001a534: 80 a2 20 00 cmp %o0, 0
4001a538: 14 80 00 94 bg 4001a788 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001a53c: 85 2f 20 02 sll %i4, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001a540: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001a544: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001a548: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001a54c: 82 00 c0 02 add %g3, %g2, %g1
4001a550: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
4001a554: c8 08 60 03 ldub [ %g1 + 3 ], %g4
4001a558: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001a55c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001a560: bb 2f 60 18 sll %i5, 0x18, %i5
4001a564: 85 28 a0 10 sll %g2, 0x10, %g2
4001a568: ba 11 00 1d or %g4, %i5, %i5
4001a56c: 83 28 60 08 sll %g1, 8, %g1
4001a570: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001a574: 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,
4001a578: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001a57c: 94 10 00 10 mov %l0, %o2
4001a580: 96 10 00 11 mov %l1, %o3
4001a584: 10 80 00 48 b 4001a6a4 <rtems_rfs_block_map_shrink+0x23c>
4001a588: 98 10 00 1c mov %i4, %o4
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
4001a58c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
4001a590: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4001a594: 3a 80 00 5d bcc,a 4001a708 <rtems_rfs_block_map_shrink+0x2a0><== NOT EXECUTED
4001a598: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
4001a59c: 7f ff a0 38 call 4000267c <.udiv> <== NOT EXECUTED
4001a5a0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001a5a4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
4001a5a8: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001a5ac: 40 00 4d f7 call 4002dd88 <.urem> <== NOT EXECUTED
4001a5b0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001a5b4: 82 05 20 08 add %l4, 8, %g1 <== NOT EXECUTED
4001a5b8: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001a5bc: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001a5c0: 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;
4001a5c4: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001a5c8: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
4001a5cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a5d0: 40 00 01 48 call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001a5d4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001a5d8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001a5dc: 14 80 00 6b bg 4001a788 <rtems_rfs_block_map_shrink+0x320><== NOT EXECUTED
4001a5e0: 85 2c 60 02 sll %l1, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001a5e4: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001a5e8: 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,
4001a5ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001a5f0: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001a5f4: f6 08 c0 02 ldub [ %g3 + %g2 ], %i3 <== NOT EXECUTED
4001a5f8: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
4001a5fc: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001a600: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001a604: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001a608: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001a60c: b7 2e e0 18 sll %i3, 0x18, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a610: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001a614: b6 11 00 1b or %g4, %i3, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a618: 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,
4001a61c: b6 16 c0 02 or %i3, %g2, %i3 <== NOT EXECUTED
4001a620: b6 16 c0 01 or %i3, %g1, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a624: 40 00 01 33 call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001a628: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
4001a62c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001a630: 14 80 00 56 bg 4001a788 <rtems_rfs_block_map_shrink+0x320><== NOT EXECUTED
4001a634: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001a638: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
4001a63c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
4001a640: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly, true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001a644: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001a648: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED
4001a64c: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
4001a650: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001a654: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001a658: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED
4001a65c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001a660: ba 11 00 1d or %g4, %i5, %i5 <== NOT EXECUTED
4001a664: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001a668: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
4001a66c: 12 80 00 13 bne 4001a6b8 <rtems_rfs_block_map_shrink+0x250><== NOT EXECUTED
4001a670: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
4001a674: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a678: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001a67c: 7f ff d9 eb call 40010e28 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001a680: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
if (rc > 0)
4001a684: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001a688: 14 80 00 40 bg 4001a788 <rtems_rfs_block_map_shrink+0x320><== NOT EXECUTED
4001a68c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
4001a690: f6 26 60 1c st %i3, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001a694: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a698: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001a69c: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001a6a0: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
4001a6a4: 7f ff fc 26 call 4001973c <rtems_rfs_block_map_indirect_shrink>
4001a6a8: 01 00 00 00 nop
doubly, doubly_singly);
if (rc)
4001a6ac: 80 a2 20 00 cmp %o0, 0
4001a6b0: 12 80 00 36 bne 4001a788 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001a6b4: 01 00 00 00 nop
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001a6b8: 90 10 00 18 mov %i0, %o0
4001a6bc: 92 10 20 00 clr %o1
4001a6c0: 7f ff d9 da call 40010e28 <rtems_rfs_group_bitmap_free>
4001a6c4: 94 10 00 1d mov %i5, %o2
if (rc > 0)
4001a6c8: 80 a2 20 00 cmp %o0, 0
4001a6cc: 14 80 00 2f bg 4001a788 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001a6d0: b4 06 bf ff add %i2, -1, %i2
return rc;
map->size.count--;
4001a6d4: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
4001a6d8: 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--;
4001a6dc: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
map->last_data_block = block_to_free;
4001a6e0: 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--;
4001a6e4: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
4001a6e8: 10 80 00 05 b 4001a6fc <rtems_rfs_block_map_shrink+0x294>
4001a6ec: e6 2e 40 00 stb %l3, [ %i1 ]
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001a6f0: a4 06 60 44 add %i1, 0x44, %l2 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001a6f4: a0 06 60 38 add %i1, 0x38, %l0
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
4001a6f8: a6 10 20 01 mov 1, %l3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001a6fc: 80 a6 a0 00 cmp %i2, 0
4001a700: 12 bf ff 70 bne 4001a4c0 <rtems_rfs_block_map_shrink+0x58>
4001a704: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
4001a708: 80 a0 60 00 cmp %g1, 0
4001a70c: 32 80 00 05 bne,a 4001a720 <rtems_rfs_block_map_shrink+0x2b8>
4001a710: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
{
map->last_map_block = 0;
4001a714: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
4001a718: c0 26 60 20 clr [ %i1 + 0x20 ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
4001a71c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4001a720: 80 a0 a0 00 cmp %g2, 0
4001a724: 02 80 00 06 be 4001a73c <rtems_rfs_block_map_shrink+0x2d4>
4001a728: 80 a0 80 01 cmp %g2, %g1
4001a72c: 80 a0 60 00 cmp %g1, 0
4001a730: 22 80 00 0e be,a 4001a768 <rtems_rfs_block_map_shrink+0x300><== ALWAYS TAKEN
4001a734: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001a738: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4001a73c: 3a 80 00 0b bcc,a 4001a768 <rtems_rfs_block_map_shrink+0x300>
4001a740: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001a744: 86 00 7f ff add %g1, -1, %g3
4001a748: 80 a0 80 03 cmp %g2, %g3
4001a74c: 12 80 00 0f bne 4001a788 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001a750: 90 10 20 00 clr %o0
4001a754: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
4001a758: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001a75c: 80 a0 c0 02 cmp %g3, %g2
4001a760: 08 80 00 0a bleu 4001a788 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001a764: 01 00 00 00 nop
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
4001a768: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
4001a76c: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
4001a770: 80 a0 a0 00 cmp %g2, 0
4001a774: 02 80 00 04 be 4001a784 <rtems_rfs_block_map_shrink+0x31c><== ALWAYS TAKEN
4001a778: c0 26 60 18 clr [ %i1 + 0x18 ]
4001a77c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4001a780: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
4001a784: 90 10 20 00 clr %o0
}
4001a788: 81 c7 e0 08 ret
4001a78c: 91 e8 00 08 restore %g0, %o0, %o0
4001fcd8 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
4001fcd8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4001fcdc: 90 10 20 00 clr %o0
4001fce0: 7f ff cb ac call 40012b90 <rtems_rfs_trace>
4001fce4: 92 10 20 40 mov 0x40, %o1
4001fce8: 80 8a 20 ff btst 0xff, %o0
4001fcec: 02 80 00 0e be 4001fd24 <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
4001fcf0: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
4001fcf4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
4001fcf8: 02 80 00 05 be 4001fd0c <rtems_rfs_buffer_bdbuf_release+0x34><== NOT EXECUTED
4001fcfc: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
4001fd00: 17 10 00 d6 sethi %hi(0x40035800), %o3 <== NOT EXECUTED
4001fd04: 10 80 00 04 b 4001fd14 <rtems_rfs_buffer_bdbuf_release+0x3c><== NOT EXECUTED
4001fd08: 96 12 e2 d8 or %o3, 0x2d8, %o3 ! 40035ad8 <rtems_rfs_rtems_file_handlers+0x2c><== NOT EXECUTED
4001fd0c: 17 10 00 c6 sethi %hi(0x40031800), %o3 <== NOT EXECUTED
4001fd10: 96 12 e1 50 or %o3, 0x150, %o3 ! 40031950 <__FUNCTION__.6193+0x148><== NOT EXECUTED
4001fd14: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001fd18: 40 00 06 64 call 400216a8 <printf> <== NOT EXECUTED
4001fd1c: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40035ae8 <rtems_rfs_rtems_file_handlers+0x3c><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
4001fd20: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4001fd24: 02 80 00 06 be 4001fd3c <rtems_rfs_buffer_bdbuf_release+0x64>
4001fd28: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
4001fd2c: 7f ff d4 96 call 40014f84 <rtems_bdbuf_release_modified>
4001fd30: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
4001fd34: 10 80 00 05 b 4001fd48 <rtems_rfs_buffer_bdbuf_release+0x70>
4001fd38: 80 a0 00 08 cmp %g0, %o0
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
4001fd3c: 7f ff d4 5d call 40014eb0 <rtems_bdbuf_release>
4001fd40: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
4001fd44: 80 a0 00 08 cmp %g0, %o0
4001fd48: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
4001fd4c: b0 0e 20 05 and %i0, 5, %i0
4001fd50: 81 c7 e0 08 ret
4001fd54: 81 e8 00 00 restore
4001fd58: 40 01 ff 64 call 4009fae8 <__end+0x579d8> <== NOT EXECUTED
4001fd5c: 40 01 ff 58 call 4009fabc <__end+0x579ac> <== NOT EXECUTED
4001fd60: 40 01 ff 4c call 4009fa90 <__end+0x57980> <== NOT EXECUTED
4001fd64: 40 01 ff 40 call 4009fa64 <__end+0x57954> <== NOT EXECUTED
4001fd68: 40 01 ff 38 call 4009fa48 <__end+0x57938> <== NOT EXECUTED
4001fd6c: 40 01 ff 2c call 4009fa1c <__end+0x5790c> <== NOT EXECUTED
4001fd70: 40 01 ff 20 call 4009f9f0 <__end+0x578e0> <== NOT EXECUTED
4001fd74: 40 01 ff 14 call 4009f9c4 <__end+0x578b4> <== NOT EXECUTED
4001fd78: 40 01 ff 0c call 4009f9a8 <__end+0x57898> <== NOT EXECUTED
4001fd7c: 40 01 ff 00 call 4009f97c <__end+0x5786c> <== NOT EXECUTED
4001fd80: 40 01 fe f4 call 4009f950 <__end+0x57840> <== NOT EXECUTED
4001fd84: 40 01 fe e8 call 4009f924 <__end+0x57814> <== NOT EXECUTED
4001b0f4 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
4001b0f4: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001b0f8: 90 10 20 00 clr %o0
4001b0fc: 7f ff de a5 call 40012b90 <rtems_rfs_trace>
4001b100: 92 10 20 10 mov 0x10, %o1
4001b104: 80 8a 20 ff btst 0xff, %o0
4001b108: 22 80 00 06 be,a 4001b120 <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
4001b10c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
printf ("rtems-rfs: buffer-close: closing\n");
4001b110: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b114: 40 00 19 fd call 40021908 <puts> <== NOT EXECUTED
4001b118: 90 12 21 50 or %o0, 0x150, %o0 ! 40034950 <CSWTCH.2+0x5a0><== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
4001b11c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
4001b120: 90 10 00 18 mov %i0, %o0
4001b124: 7f ff ff b9 call 4001b008 <rtems_rfs_buffer_setblksize>
4001b128: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001b12c: ba 92 20 00 orcc %o0, 0, %i5
4001b130: 04 80 00 0e ble 4001b168 <rtems_rfs_buffer_close+0x74> <== ALWAYS TAKEN
4001b134: 90 10 20 00 clr %o0
4001b138: 7f ff de 96 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b13c: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
4001b140: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b144: 02 80 00 09 be 4001b168 <rtems_rfs_buffer_close+0x74> <== NOT EXECUTED
4001b148: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
4001b14c: 40 00 1d c3 call 40022858 <strerror> <== NOT EXECUTED
4001b150: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b154: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001b158: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001b15c: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b160: 40 00 19 52 call 400216a8 <printf> <== NOT EXECUTED
4001b164: 90 12 21 78 or %o0, 0x178, %o0 ! 40034978 <CSWTCH.2+0x5c8><== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
4001b168: 7f ff b1 56 call 400076c0 <close>
4001b16c: d0 06 20 0c ld [ %i0 + 0xc ], %o0
4001b170: 80 a2 20 00 cmp %o0, 0
4001b174: 16 80 00 12 bge 4001b1bc <rtems_rfs_buffer_close+0xc8> <== ALWAYS TAKEN
4001b178: 01 00 00 00 nop
{
rc = errno;
4001b17c: 40 00 13 f2 call 40020144 <__errno> <== NOT EXECUTED
4001b180: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001b184: 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;
4001b188: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001b18c: 7f ff de 81 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b190: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b194: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b198: 02 80 00 09 be 4001b1bc <rtems_rfs_buffer_close+0xc8> <== NOT EXECUTED
4001b19c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
4001b1a0: 40 00 1d ae call 40022858 <strerror> <== NOT EXECUTED
4001b1a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b1a8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001b1ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001b1b0: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b1b4: 40 00 19 3d call 400216a8 <printf> <== NOT EXECUTED
4001b1b8: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400349b8 <CSWTCH.2+0x608><== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
4001b1bc: 81 c7 e0 08 ret
4001b1c0: 91 e8 00 1d restore %g0, %i5, %o0
4001a920 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
4001a920: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
4001a924: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
4001a928: ba 10 00 18 mov %i0, %i5
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
4001a92c: 80 a0 60 00 cmp %g1, 0
4001a930: 02 80 00 6e be 4001aae8 <rtems_rfs_buffer_handle_release+0x1c8>
4001a934: b0 10 20 00 clr %i0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001a938: 90 10 20 00 clr %o0
4001a93c: 7f ff e0 95 call 40012b90 <rtems_rfs_trace>
4001a940: 92 10 22 00 mov 0x200, %o1
4001a944: 80 8a 20 ff btst 0xff, %o0
4001a948: 22 80 00 18 be,a 4001a9a8 <rtems_rfs_buffer_handle_release+0x88><== ALWAYS TAKEN
4001a94c: d0 06 60 08 ld [ %i1 + 8 ], %o0
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001a950: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
4001a954: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001a958: 02 80 00 05 be 4001a96c <rtems_rfs_buffer_handle_release+0x4c><== NOT EXECUTED
4001a95c: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
4001a960: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED
4001a964: 10 80 00 04 b 4001a974 <rtems_rfs_buffer_handle_release+0x54><== NOT EXECUTED
4001a968: 94 12 a1 40 or %o2, 0x140, %o2 ! 40034540 <CSWTCH.2+0x190><== NOT EXECUTED
4001a96c: 15 10 00 c6 sethi %hi(0x40031800), %o2 <== NOT EXECUTED
4001a970: 94 12 a1 50 or %o2, 0x150, %o2 ! 40031950 <__FUNCTION__.6193+0x148><== 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" : "");
4001a974: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4001a978: 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",
4001a97c: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4001a980: 32 80 00 05 bne,a 4001a994 <rtems_rfs_buffer_handle_release+0x74><== NOT EXECUTED
4001a984: 19 10 00 c6 sethi %hi(0x40031800), %o4 <== NOT EXECUTED
4001a988: 19 10 00 d1 sethi %hi(0x40034400), %o4 <== NOT EXECUTED
4001a98c: 10 80 00 03 b 4001a998 <rtems_rfs_buffer_handle_release+0x78><== NOT EXECUTED
4001a990: 98 13 21 48 or %o4, 0x148, %o4 ! 40034548 <CSWTCH.2+0x198><== NOT EXECUTED
4001a994: 98 13 21 50 or %o4, 0x150, %o4 <== NOT EXECUTED
4001a998: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001a99c: 40 00 1b 43 call 400216a8 <printf> <== NOT EXECUTED
4001a9a0: 90 12 21 58 or %o0, 0x158, %o0 ! 40034558 <CSWTCH.2+0x1a8><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
4001a9a4: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
4001a9a8: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4001a9ac: 80 a0 60 00 cmp %g1, 0
4001a9b0: 04 80 00 03 ble 4001a9bc <rtems_rfs_buffer_handle_release+0x9c><== NEVER TAKEN
4001a9b4: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_buffer_refs_down (handle);
4001a9b8: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
4001a9bc: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4001a9c0: 80 a0 60 00 cmp %g1, 0
4001a9c4: 12 80 00 48 bne 4001aae4 <rtems_rfs_buffer_handle_release+0x1c4>
4001a9c8: b0 10 20 00 clr %i0
4001a9cc: 7f ff f3 dc call 4001793c <_Chain_Extract>
4001a9d0: 01 00 00 00 nop
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
4001a9d4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (rtems_rfs_fs_no_local_cache (fs))
4001a9d8: f0 07 40 00 ld [ %i5 ], %i0
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
4001a9dc: 82 00 7f ff add %g1, -1, %g1
if (rtems_rfs_fs_no_local_cache (fs))
4001a9e0: b0 8e 20 02 andcc %i0, 2, %i0
4001a9e4: 02 80 00 08 be 4001aa04 <rtems_rfs_buffer_handle_release+0xe4>
4001a9e8: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
{
handle->buffer->user = (void*) 0;
4001a9ec: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
4001a9f0: d2 0e 40 00 ldub [ %i1 ], %o1
4001a9f4: 40 00 14 b9 call 4001fcd8 <rtems_rfs_buffer_bdbuf_release>
4001a9f8: c0 22 20 34 clr [ %o0 + 0x34 ]
4001a9fc: 10 80 00 3a b 4001aae4 <rtems_rfs_buffer_handle_release+0x1c4>
4001aa00: b0 10 00 08 mov %o0, %i0
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
4001aa04: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001aa08: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
4001aa0c: 84 00 80 01 add %g2, %g1, %g2
4001aa10: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
4001aa14: 80 a0 80 01 cmp %g2, %g1
4001aa18: 2a 80 00 25 bcs,a 4001aaac <rtems_rfs_buffer_handle_release+0x18c>
4001aa1c: c2 0e 40 00 ldub [ %i1 ], %g1
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001aa20: 90 10 20 00 clr %o0
4001aa24: 7f ff e0 5b call 40012b90 <rtems_rfs_trace>
4001aa28: 92 10 22 00 mov 0x200, %o1
4001aa2c: 80 8a 20 ff btst 0xff, %o0
4001aa30: 22 80 00 09 be,a 4001aa54 <rtems_rfs_buffer_handle_release+0x134><== ALWAYS TAKEN
4001aa34: c4 07 60 60 ld [ %i5 + 0x60 ], %g2
printf ("rtems-rfs: buffer-release: local cache overflow:"
4001aa38: d2 07 60 70 ld [ %i5 + 0x70 ], %o1 <== NOT EXECUTED
4001aa3c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
4001aa40: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001aa44: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
4001aa48: 40 00 1b 18 call 400216a8 <printf> <== NOT EXECUTED
4001aa4c: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
4001aa50: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
4001aa54: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001aa58: 80 a0 80 01 cmp %g2, %g1
4001aa5c: 08 80 00 09 bleu 4001aa80 <rtems_rfs_buffer_handle_release+0x160>
4001aa60: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4001aa64: 7f ff c8 5b call 4000cbd0 <_Chain_Get>
4001aa68: 90 07 60 54 add %i5, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
4001aa6c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
modified = false;
4001aa70: 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--;
4001aa74: 82 00 7f ff add %g1, -1, %g1
4001aa78: 10 80 00 08 b 4001aa98 <rtems_rfs_buffer_handle_release+0x178>
4001aa7c: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
4001aa80: 7f ff c8 54 call 4000cbd0 <_Chain_Get>
4001aa84: 90 07 60 64 add %i5, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001aa88: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
modified = true;
4001aa8c: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001aa90: 82 00 7f ff add %g1, -1, %g1
4001aa94: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
modified = true;
}
buffer->user = (void*) 0;
4001aa98: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001aa9c: 40 00 14 8f call 4001fcd8 <rtems_rfs_buffer_bdbuf_release>
4001aaa0: 92 0a 60 01 and %o1, 1, %o1
4001aaa4: b0 10 00 08 mov %o0, %i0
}
if (rtems_rfs_buffer_dirty (handle))
4001aaa8: c2 0e 40 00 ldub [ %i1 ], %g1
4001aaac: 80 a0 60 00 cmp %g1, 0
4001aab0: 02 80 00 08 be 4001aad0 <rtems_rfs_buffer_handle_release+0x1b0>
4001aab4: 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 );
4001aab8: 7f ff c8 3a call 4000cba0 <_Chain_Append>
4001aabc: 90 07 60 64 add %i5, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
4001aac0: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001aac4: 82 00 60 01 inc %g1
4001aac8: 10 80 00 07 b 4001aae4 <rtems_rfs_buffer_handle_release+0x1c4>
4001aacc: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
4001aad0: 7f ff c8 34 call 4000cba0 <_Chain_Append>
4001aad4: 90 07 60 54 add %i5, 0x54, %o0
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
4001aad8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001aadc: 82 00 60 01 inc %g1
4001aae0: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
}
}
}
handle->buffer = NULL;
4001aae4: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
4001aae8: 81 c7 e0 08 ret
4001aaec: 81 e8 00 00 restore
4001aaf0 <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)
{
4001aaf0: 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))
4001aaf4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001aaf8: 80 a0 60 00 cmp %g1, 0
4001aafc: 02 80 00 1a be 4001ab64 <rtems_rfs_buffer_handle_request+0x74>
4001ab00: 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))
4001ab04: 80 a6 a0 00 cmp %i2, 0
4001ab08: 02 80 00 06 be 4001ab20 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
4001ab0c: 90 10 20 00 clr %o0
4001ab10: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001ab14: 80 a0 40 1a cmp %g1, %i2
4001ab18: 02 80 00 75 be 4001acec <rtems_rfs_buffer_handle_request+0x1fc>
4001ab1c: b0 10 20 00 clr %i0
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001ab20: 7f ff e0 1c call 40012b90 <rtems_rfs_trace>
4001ab24: 92 10 21 00 mov 0x100, %o1
4001ab28: 80 8a 20 ff btst 0xff, %o0
4001ab2c: 22 80 00 07 be,a 4001ab48 <rtems_rfs_buffer_handle_request+0x58><== ALWAYS TAKEN
4001ab30: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
4001ab34: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
4001ab38: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001ab3c: 40 00 1a db call 400216a8 <printf> <== NOT EXECUTED
4001ab40: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400345d0 <CSWTCH.2+0x220><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
4001ab44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ab48: 7f ff ff 76 call 4001a920 <rtems_rfs_buffer_handle_release>
4001ab4c: 92 10 00 19 mov %i1, %o1
if (rc > 0)
4001ab50: b0 92 20 00 orcc %o0, 0, %i0
4001ab54: 14 80 00 8b bg 4001ad80 <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
4001ab58: 01 00 00 00 nop
return rc;
handle->dirty = false;
4001ab5c: c0 2e 40 00 clrb [ %i1 ]
handle->bnum = 0;
4001ab60: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001ab64: 90 10 20 00 clr %o0
4001ab68: 7f ff e0 0a call 40012b90 <rtems_rfs_trace>
4001ab6c: 92 10 21 00 mov 0x100, %o1
4001ab70: 80 8a 20 ff btst 0xff, %o0
4001ab74: 22 80 00 07 be,a 4001ab90 <rtems_rfs_buffer_handle_request+0xa0><== ALWAYS TAKEN
4001ab78: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
4001ab7c: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001ab80: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001ab84: 40 00 1a c9 call 400216a8 <printf> <== NOT EXECUTED
4001ab88: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
* currently attached to a handle. If it is share the access. A buffer could
* be shared where different parts of the block have separate functions. An
* example is an inode block and the file system needs to handle 2 inodes in
* the same block at the same time.
*/
if (fs->buffers_count)
4001ab8c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
4001ab90: 80 a0 60 00 cmp %g1, 0
4001ab94: 22 80 00 16 be,a 4001abec <rtems_rfs_buffer_handle_request+0xfc>
4001ab98: c2 07 40 00 ld [ %i5 ], %g1
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4001ab9c: 90 07 60 44 add %i5, 0x44, %o0
4001aba0: 92 07 60 50 add %i5, 0x50, %o1
4001aba4: 7f ff ff 22 call 4001a82c <rtems_rfs_scan_chain>
4001aba8: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
4001abac: 80 a2 20 00 cmp %o0, 0
4001abb0: 02 80 00 0e be 4001abe8 <rtems_rfs_buffer_handle_request+0xf8>
4001abb4: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001abb8: 90 10 20 00 clr %o0
4001abbc: 7f ff df f5 call 40012b90 <rtems_rfs_trace>
4001abc0: 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) &&
4001abc4: 80 8a 20 ff btst 0xff, %o0
4001abc8: 22 80 00 09 be,a 4001abec <rtems_rfs_buffer_handle_request+0xfc><== ALWAYS TAKEN
4001abcc: c2 07 40 00 ld [ %i5 ], %g1
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
rtems_rfs_buffer_refs (handle) + 1);
4001abd0: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
4001abd4: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001abd8: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
4001abdc: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
4001abe0: 40 00 1a b2 call 400216a8 <printf> <== NOT EXECUTED
4001abe4: 92 02 60 01 inc %o1 <== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001abe8: c2 07 40 00 ld [ %i5 ], %g1
4001abec: 80 88 60 02 btst 2, %g1
4001abf0: 12 80 00 20 bne 4001ac70 <rtems_rfs_buffer_handle_request+0x180>
4001abf4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001abf8: 80 a0 60 00 cmp %g1, 0
4001abfc: 32 80 00 42 bne,a 4001ad04 <rtems_rfs_buffer_handle_request+0x214>
4001ac00: d2 06 60 08 ld [ %i1 + 8 ], %o1
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
4001ac04: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001ac08: 80 a0 60 00 cmp %g1, 0
4001ac0c: 22 80 00 08 be,a 4001ac2c <rtems_rfs_buffer_handle_request+0x13c>
4001ac10: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->buffer = rtems_rfs_scan_chain (&fs->release,
4001ac14: 90 07 60 54 add %i5, 0x54, %o0
4001ac18: 92 07 60 60 add %i5, 0x60, %o1
4001ac1c: 7f ff ff 04 call 4001a82c <rtems_rfs_scan_chain>
4001ac20: 94 10 00 1a mov %i2, %o2
4001ac24: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001ac28: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001ac2c: 80 a0 60 00 cmp %g1, 0
4001ac30: 32 80 00 10 bne,a 4001ac70 <rtems_rfs_buffer_handle_request+0x180>
4001ac34: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001ac38: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001ac3c: 80 a0 60 00 cmp %g1, 0
4001ac40: 22 80 00 0c be,a 4001ac70 <rtems_rfs_buffer_handle_request+0x180>
4001ac44: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
4001ac48: 90 07 60 64 add %i5, 0x64, %o0
4001ac4c: 92 07 60 70 add %i5, 0x70, %o1
4001ac50: 7f ff fe f7 call 4001a82c <rtems_rfs_scan_chain>
4001ac54: 94 10 00 1a mov %i2, %o2
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
4001ac58: 80 a2 20 00 cmp %o0, 0
4001ac5c: 02 80 00 04 be 4001ac6c <rtems_rfs_buffer_handle_request+0x17c>
4001ac60: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_buffer_mark_dirty (handle);
4001ac64: 82 10 20 01 mov 1, %g1
4001ac68: c2 2e 40 00 stb %g1, [ %i1 ]
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
4001ac6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001ac70: 80 a0 60 00 cmp %g1, 0
4001ac74: 32 80 00 24 bne,a 4001ad04 <rtems_rfs_buffer_handle_request+0x214>
4001ac78: d2 06 60 08 ld [ %i1 + 8 ], %o1
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4001ac7c: 90 10 00 1d mov %i5, %o0
4001ac80: 92 10 00 1a mov %i2, %o1
4001ac84: 94 10 00 1b mov %i3, %o2
4001ac88: 40 00 14 03 call 4001fc94 <rtems_rfs_buffer_bdbuf_request>
4001ac8c: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
4001ac90: b0 92 20 00 orcc %o0, 0, %i0
4001ac94: 04 80 00 18 ble 4001acf4 <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
4001ac98: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001ac9c: 7f ff df bd call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001aca0: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
4001aca4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001aca8: 02 80 00 11 be 4001acec <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
4001acac: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001acb0: 22 80 00 05 be,a 4001acc4 <rtems_rfs_buffer_handle_request+0x1d4><== NOT EXECUTED
4001acb4: 3b 10 00 d1 sethi %hi(0x40034400), %i5 <== NOT EXECUTED
4001acb8: 3b 10 00 ce sethi %hi(0x40033800), %i5 <== NOT EXECUTED
4001acbc: 10 80 00 03 b 4001acc8 <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
4001acc0: ba 17 62 90 or %i5, 0x290, %i5 ! 40033a90 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001acc4: ba 17 61 c8 or %i5, 0x1c8, %i5 <== NOT EXECUTED
4001acc8: 40 00 1e e4 call 40022858 <strerror> <== NOT EXECUTED
4001accc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001acd0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001acd4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001acd8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001acdc: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001ace0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001ace4: 40 00 1a 71 call 400216a8 <printf> <== NOT EXECUTED
4001ace8: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
4001acec: 81 c7 e0 08 ret
4001acf0: 81 e8 00 00 restore
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
4001acf4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001acf8: c0 20 60 04 clr [ %g1 + 4 ]
4001acfc: c0 20 40 00 clr [ %g1 ]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
4001ad00: d2 06 60 08 ld [ %i1 + 8 ], %o1
4001ad04: 90 07 60 44 add %i5, 0x44, %o0
4001ad08: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
4001ad0c: 82 00 60 01 inc %g1
4001ad10: 7f ff c7 a4 call 4000cba0 <_Chain_Append>
4001ad14: c2 22 60 30 st %g1, [ %o1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
4001ad18: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001ad1c: 90 10 20 00 clr %o0
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
4001ad20: 82 00 60 01 inc %g1
4001ad24: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
4001ad28: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001ad2c: 92 10 21 00 mov 0x100, %o1
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
4001ad30: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001ad34: 7f ff df 97 call 40012b90 <rtems_rfs_trace>
4001ad38: f4 26 60 04 st %i2, [ %i1 + 4 ]
4001ad3c: 80 8a 20 ff btst 0xff, %o0
4001ad40: 02 80 00 0f be 4001ad7c <rtems_rfs_buffer_handle_request+0x28c><== ALWAYS TAKEN
4001ad44: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001ad48: 22 80 00 05 be,a 4001ad5c <rtems_rfs_buffer_handle_request+0x26c><== NOT EXECUTED
4001ad4c: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED
4001ad50: 15 10 00 ce sethi %hi(0x40033800), %o2 <== NOT EXECUTED
4001ad54: 10 80 00 03 b 4001ad60 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
4001ad58: 94 12 a2 90 or %o2, 0x290, %o2 ! 40033a90 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001ad5c: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
4001ad60: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001ad64: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001ad68: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
4001ad6c: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
4001ad70: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
4001ad74: 40 00 1a 4d call 400216a8 <printf> <== NOT EXECUTED
4001ad78: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
4001ad7c: b0 10 20 00 clr %i0
}
4001ad80: 81 c7 e0 08 ret
4001ad84: 81 e8 00 00 restore
4001ad88 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
4001ad88: 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))
4001ad8c: 90 10 20 00 clr %o0
4001ad90: 7f ff df 80 call 40012b90 <rtems_rfs_trace>
4001ad94: 92 10 20 20 mov 0x20, %o1
4001ad98: 80 8a 20 ff btst 0xff, %o0
4001ad9c: 22 80 00 07 be,a 4001adb8 <rtems_rfs_buffer_open+0x30> <== ALWAYS TAKEN
4001ada0: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
4001ada4: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001ada8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001adac: 40 00 1a 3f call 400216a8 <printf> <== NOT EXECUTED
4001adb0: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
4001adb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001adb8: 7f ff b6 0d call 400085ec <open>
4001adbc: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
4001adc0: 80 a2 20 00 cmp %o0, 0
4001adc4: 16 80 00 0f bge 4001ae00 <rtems_rfs_buffer_open+0x78> <== ALWAYS TAKEN
4001adc8: d0 26 60 0c st %o0, [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001adcc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001add0: 7f ff df 70 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001add4: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001add8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001addc: 12 80 00 04 bne 4001adec <rtems_rfs_buffer_open+0x64> <== NOT EXECUTED
4001ade0: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
4001ade4: 81 c7 e0 08 ret <== NOT EXECUTED
4001ade8: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
4001adec: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
4001adf0: 40 00 1a c6 call 40021908 <puts> <== NOT EXECUTED
4001adf4: 01 00 00 00 nop <== NOT EXECUTED
return ENXIO;
4001adf8: 81 c7 e0 08 ret <== NOT EXECUTED
4001adfc: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
4001ae00: 7f ff b2 7b call 400077ec <fstat>
4001ae04: 92 07 bf b8 add %fp, -72, %o1
4001ae08: 80 a2 20 00 cmp %o0, 0
4001ae0c: 16 80 00 12 bge 4001ae54 <rtems_rfs_buffer_open+0xcc> <== ALWAYS TAKEN
4001ae10: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001ae14: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ae18: 7f ff df 5e call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001ae1c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001ae20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ae24: 02 bf ff f5 be 4001adf8 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
4001ae28: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
4001ae2c: 40 00 14 c6 call 40020144 <__errno> <== NOT EXECUTED
4001ae30: 01 00 00 00 nop <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
4001ae34: 40 00 1e 89 call 40022858 <strerror> <== NOT EXECUTED
4001ae38: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4001ae3c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001ae40: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ae44: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001ae48: 40 00 1a 18 call 400216a8 <printf> <== NOT EXECUTED
4001ae4c: 90 12 23 38 or %o0, 0x338, %o0 ! 40034738 <CSWTCH.2+0x388><== NOT EXECUTED
4001ae50: 30 bf ff ea b,a 4001adf8 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
4001ae54: 03 00 00 3c sethi %hi(0xf000), %g1
4001ae58: 84 08 80 01 and %g2, %g1, %g2
4001ae5c: 03 00 00 18 sethi %hi(0x6000), %g1
4001ae60: 80 a0 80 01 cmp %g2, %g1
4001ae64: 22 80 00 0c be,a 4001ae94 <rtems_rfs_buffer_open+0x10c> <== ALWAYS TAKEN
4001ae68: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001ae6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ae70: 7f ff df 48 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001ae74: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001ae78: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ae7c: 02 bf ff df be 4001adf8 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
4001ae80: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4001ae84: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001ae88: 40 00 1a 08 call 400216a8 <printf> <== NOT EXECUTED
4001ae8c: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
4001ae90: 30 bf ff da b,a 4001adf8 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4001ae94: 13 10 01 10 sethi %hi(0x40044000), %o1
4001ae98: 94 06 60 10 add %i1, 0x10, %o2
4001ae9c: 7f ff b2 a7 call 40007938 <ioctl>
4001aea0: 92 12 62 09 or %o1, 0x209, %o1
/*
* Check that device is registred as a block device and lock it.
*/
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
4001aea4: 80 a2 20 00 cmp %o0, 0
4001aea8: 02 80 00 09 be 4001aecc <rtems_rfs_buffer_open+0x144> <== ALWAYS TAKEN
4001aeac: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001aeb0: 7f ff df 38 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001aeb4: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001aeb8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001aebc: 02 bf ff cf be 4001adf8 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
4001aec0: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
4001aec4: 10 bf ff cb b 4001adf0 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
4001aec8: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 400347a0 <CSWTCH.2+0x3f0><== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001aecc: 92 10 20 20 mov 0x20, %o1
4001aed0: 7f ff df 30 call 40012b90 <rtems_rfs_trace>
4001aed4: b0 10 20 00 clr %i0
4001aed8: 80 8a 20 ff btst 0xff, %o0
4001aedc: 02 80 00 07 be 4001aef8 <rtems_rfs_buffer_open+0x170> <== ALWAYS TAKEN
4001aee0: 11 10 00 d1 sethi %hi(0x40034400), %o0
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
4001aee4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
4001aee8: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4001aeec: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
4001aef0: 40 00 19 ee call 400216a8 <printf> <== NOT EXECUTED
4001aef4: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
4001aef8: 81 c7 e0 08 ret
4001aefc: 81 e8 00 00 restore
4001b008 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001b008: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001b00c: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001b010: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001b014: 7f ff de df call 40012b90 <rtems_rfs_trace>
4001b018: 92 10 24 00 mov 0x400, %o1
4001b01c: 80 8a 20 ff btst 0xff, %o0
4001b020: 02 80 00 05 be 4001b034 <rtems_rfs_buffer_setblksize+0x2c><== ALWAYS TAKEN
4001b024: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
4001b028: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b02c: 40 00 19 9f call 400216a8 <printf> <== NOT EXECUTED
4001b030: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400348a0 <CSWTCH.2+0x4f0> <== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
4001b034: 7f ff ff d5 call 4001af88 <rtems_rfs_buffers_release>
4001b038: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001b03c: ba 92 20 00 orcc %o0, 0, %i5
4001b040: 04 80 00 0e ble 4001b078 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
4001b044: 90 10 20 00 clr %o0
4001b048: 7f ff de d2 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b04c: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001b050: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b054: 02 80 00 09 be 4001b078 <rtems_rfs_buffer_setblksize+0x70><== NOT EXECUTED
4001b058: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
4001b05c: 40 00 1d ff call 40022858 <strerror> <== NOT EXECUTED
4001b060: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b064: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001b068: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001b06c: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b070: 40 00 19 8e call 400216a8 <printf> <== NOT EXECUTED
4001b074: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400348d0 <CSWTCH.2+0x520> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
4001b078: 7f ff ff a2 call 4001af00 <rtems_rfs_buffer_sync>
4001b07c: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001b080: ba 92 20 00 orcc %o0, 0, %i5
4001b084: 04 80 00 0e ble 4001b0bc <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
4001b088: 90 10 20 00 clr %o0
4001b08c: 7f ff de c1 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b090: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001b094: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b098: 22 80 00 0a be,a 4001b0c0 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
4001b09c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
4001b0a0: 40 00 1d ee call 40022858 <strerror> <== NOT EXECUTED
4001b0a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b0a8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001b0ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001b0b0: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b0b4: 40 00 19 7d call 400216a8 <printf> <== NOT EXECUTED
4001b0b8: 90 12 21 10 or %o0, 0x110, %o0 ! 40034910 <CSWTCH.2+0x560><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001b0bc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001b0c0: 13 20 01 10 sethi %hi(0x80044000), %o1
4001b0c4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4001b0c8: 92 12 62 04 or %o1, 0x204, %o1
4001b0cc: 9f c0 40 00 call %g1
4001b0d0: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
4001b0d4: b0 92 20 00 orcc %o0, 0, %i0
4001b0d8: 16 80 00 05 bge 4001b0ec <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
4001b0dc: 01 00 00 00 nop
rc = errno;
4001b0e0: 40 00 14 19 call 40020144 <__errno> <== NOT EXECUTED
4001b0e4: 01 00 00 00 nop <== NOT EXECUTED
4001b0e8: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
4001b0ec: 81 c7 e0 08 ret
4001b0f0: 81 e8 00 00 restore
4001af00 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
4001af00: 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))
4001af04: 90 10 20 00 clr %o0
4001af08: 7f ff df 22 call 40012b90 <rtems_rfs_trace>
4001af0c: 92 10 20 20 mov 0x20, %o1
4001af10: 80 8a 20 ff btst 0xff, %o0
4001af14: 22 80 00 06 be,a 4001af2c <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
4001af18: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: syncing\n");
4001af1c: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001af20: 40 00 1a 7a call 40021908 <puts> <== NOT EXECUTED
4001af24: 90 12 20 00 mov %o0, %o0 ! 40034800 <CSWTCH.2+0x450> <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
4001af28: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
4001af2c: 7f ff e8 80 call 4001512c <rtems_bdbuf_syncdev>
4001af30: ba 10 20 00 clr %i5
if (sc != RTEMS_SUCCESSFUL)
4001af34: 80 a2 20 00 cmp %o0, 0
4001af38: 02 80 00 0f be 4001af74 <rtems_rfs_buffer_sync+0x74> <== ALWAYS TAKEN
4001af3c: b8 10 00 08 mov %o0, %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001af40: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001af44: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
4001af48: 7f ff df 12 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001af4c: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
4001af50: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001af54: 22 80 00 09 be,a 4001af78 <rtems_rfs_buffer_sync+0x78> <== NOT EXECUTED
4001af58: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
4001af5c: 7f ff ec 53 call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001af60: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001af64: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001af68: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001af6c: 40 00 19 cf call 400216a8 <printf> <== NOT EXECUTED
4001af70: 90 12 20 20 or %o0, 0x20, %o0 ! 40034820 <CSWTCH.2+0x470> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
4001af74: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001af78: 7f ff a4 a1 call 400041fc <rtems_disk_release>
4001af7c: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
4001af80: 81 c7 e0 08 ret
4001af84: 81 e8 00 00 restore
4001af88 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
4001af88: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4001af8c: 90 10 20 00 clr %o0
4001af90: 92 10 20 40 mov 0x40, %o1
4001af94: 7f ff de ff call 40012b90 <rtems_rfs_trace>
4001af98: ba 10 00 18 mov %i0, %i5
4001af9c: 80 8a 20 ff btst 0xff, %o0
4001afa0: 02 80 00 09 be 4001afc4 <rtems_rfs_buffers_release+0x3c> <== ALWAYS TAKEN
4001afa4: 92 07 60 60 add %i5, 0x60, %o1
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
4001afa8: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
4001afac: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
4001afb0: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
4001afb4: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001afb8: 40 00 19 bc call 400216a8 <printf> <== NOT EXECUTED
4001afbc: 90 12 20 50 or %o0, 0x50, %o0 ! 40034850 <CSWTCH.2+0x4a0> <== NOT EXECUTED
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
4001afc0: 92 07 60 60 add %i5, 0x60, %o1 <== NOT EXECUTED
4001afc4: 94 10 20 00 clr %o2
4001afc8: 7f ff fd f6 call 4001a7a0 <rtems_rfs_release_chain>
4001afcc: 90 07 60 54 add %i5, 0x54, %o0
4001afd0: 82 38 00 08 xnor %g0, %o0, %g1
4001afd4: 83 38 60 1f sra %g1, 0x1f, %g1
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
4001afd8: 92 07 60 70 add %i5, 0x70, %o1
4001afdc: b0 0a 00 01 and %o0, %g1, %i0
4001afe0: 94 10 20 01 mov 1, %o2
4001afe4: 7f ff fd ef call 4001a7a0 <rtems_rfs_release_chain>
4001afe8: 90 07 60 64 add %i5, 0x64, %o0
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
4001afec: 80 a6 20 00 cmp %i0, 0
4001aff0: 12 80 00 04 bne 4001b000 <rtems_rfs_buffers_release+0x78> <== NEVER TAKEN
4001aff4: 80 a2 20 00 cmp %o0, 0
4001aff8: 34 80 00 02 bg,a 4001b000 <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
4001affc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
4001b000: 81 c7 e0 08 ret
4001b004: 81 e8 00 00 restore
4001b6e4 <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)
{
4001b6e4: 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))
4001b6e8: 90 10 20 00 clr %o0
4001b6ec: 7f ff dd 29 call 40012b90 <rtems_rfs_trace>
4001b6f0: 13 08 00 00 sethi %hi(0x20000000), %o1
4001b6f4: 80 8a 20 ff btst 0xff, %o0
4001b6f8: 02 80 00 14 be 4001b748 <rtems_rfs_dir_add_entry+0x64> <== ALWAYS TAKEN
4001b6fc: a6 07 bf b0 add %fp, -80, %l3
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
4001b700: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001b704: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001b708: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED
4001b70c: 90 12 20 c0 or %o0, 0xc0, %o0 <== NOT EXECUTED
4001b710: 40 00 17 e6 call 400216a8 <printf> <== NOT EXECUTED
4001b714: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
4001b718: 10 80 00 05 b 4001b72c <rtems_rfs_dir_add_entry+0x48> <== NOT EXECUTED
4001b71c: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
4001b720: 40 00 18 4c call 40021850 <putchar> <== NOT EXECUTED
4001b724: 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++)
4001b728: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
4001b72c: 32 bf ff fd bne,a 4001b720 <rtems_rfs_dir_add_entry+0x3c><== NOT EXECUTED
4001b730: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
4001b734: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001b738: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001b73c: 40 00 17 db call 400216a8 <printf> <== NOT EXECUTED
4001b740: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001b744: a6 07 bf b0 add %fp, -80, %l3 <== NOT EXECUTED
4001b748: 90 10 00 18 mov %i0, %o0
4001b74c: 92 10 00 19 mov %i1, %o1
4001b750: 7f ff f8 fb call 40019b3c <rtems_rfs_block_map_open>
4001b754: 94 10 00 13 mov %l3, %o2
if (rc > 0)
4001b758: ba 92 20 00 orcc %o0, 0, %i5
4001b75c: 34 80 00 c5 bg,a 4001ba70 <rtems_rfs_dir_add_entry+0x38c><== NEVER TAKEN
4001b760: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b764: 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;
4001b768: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001b76c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001b770: 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;
4001b774: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
4001b778: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
4001b77c: c0 27 bf a0 clr [ %fp + -96 ]
4001b780: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001b784: aa 06 e0 0a add %i3, 0xa, %l5
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
4001b788: 90 10 00 18 mov %i0, %o0
4001b78c: 92 10 00 13 mov %l3, %o1
4001b790: 94 07 bf 98 add %fp, -104, %o2
4001b794: 7f ff f9 bf call 40019e90 <rtems_rfs_block_map_find>
4001b798: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001b79c: ba 92 20 00 orcc %o0, 0, %i5
4001b7a0: 04 80 00 29 ble 4001b844 <rtems_rfs_dir_add_entry+0x160>
4001b7a4: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
4001b7a8: 02 80 00 0f be 4001b7e4 <rtems_rfs_dir_add_entry+0x100> <== ALWAYS TAKEN
4001b7ac: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001b7b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b7b4: 7f ff dc f7 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b7b8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001b7bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b7c0: 22 80 00 a6 be,a 4001ba58 <rtems_rfs_dir_add_entry+0x374><== NOT EXECUTED
4001b7c4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001b7c8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001b7cc: 40 00 1c 23 call 40022858 <strerror> <== NOT EXECUTED
4001b7d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b7d4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001b7d8: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001b7dc: 10 80 00 15 b 4001b830 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
4001b7e0: 90 12 21 00 or %o0, 0x100, %o0 ! 40034d00 <CSWTCH.2+0x950><== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001b7e4: 92 10 00 13 mov %l3, %o1
4001b7e8: 94 10 20 01 mov 1, %o2
4001b7ec: 7f ff fa 2f call 4001a0a8 <rtems_rfs_block_map_grow>
4001b7f0: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001b7f4: ba 92 20 00 orcc %o0, 0, %i5
4001b7f8: 04 80 00 14 ble 4001b848 <rtems_rfs_dir_add_entry+0x164> <== ALWAYS TAKEN
4001b7fc: a0 10 20 00 clr %l0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001b800: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b804: 7f ff dc e3 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b808: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001b80c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b810: 22 80 00 92 be,a 4001ba58 <rtems_rfs_dir_add_entry+0x374><== NOT EXECUTED
4001b814: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001b818: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001b81c: 40 00 1c 0f call 40022858 <strerror> <== NOT EXECUTED
4001b820: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b824: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001b828: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001b82c: 90 12 21 48 or %o0, 0x148, %o0 ! 40034d48 <CSWTCH.2+0x998><== NOT EXECUTED
4001b830: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001b834: 40 00 17 9d call 400216a8 <printf> <== NOT EXECUTED
4001b838: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001b83c: 10 80 00 87 b 4001ba58 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
4001b840: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001b844: a0 10 20 01 mov 1, %l0
}
read = false;
}
bpos.bno++;
4001b848: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001b84c: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
4001b850: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001b854: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
4001b858: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001b85c: 90 10 00 18 mov %i0, %o0
4001b860: 92 07 bf a4 add %fp, -92, %o1
4001b864: 7f ff fc a3 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001b868: 96 10 00 10 mov %l0, %o3
if (rc > 0)
4001b86c: ba 92 20 00 orcc %o0, 0, %i5
4001b870: 04 80 00 0f ble 4001b8ac <rtems_rfs_dir_add_entry+0x1c8> <== ALWAYS TAKEN
4001b874: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001b878: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b87c: 7f ff dc c5 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b880: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001b884: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b888: 22 80 00 74 be,a 4001ba58 <rtems_rfs_dir_add_entry+0x374><== NOT EXECUTED
4001b88c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001b890: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001b894: 40 00 1b f1 call 40022858 <strerror> <== NOT EXECUTED
4001b898: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b89c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001b8a0: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001b8a4: 10 bf ff e3 b 4001b830 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
4001b8a8: 90 12 21 90 or %o0, 0x190, %o0 ! 40034d90 <CSWTCH.2+0x9e0><== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
4001b8ac: 80 a4 20 00 cmp %l0, 0
4001b8b0: 12 80 00 06 bne 4001b8c8 <rtems_rfs_dir_add_entry+0x1e4>
4001b8b4: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
4001b8b8: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001b8bc: 90 10 00 1d mov %i5, %o0
4001b8c0: 40 00 16 fc call 400214b0 <memset>
4001b8c4: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001b8c8: c2 06 20 08 ld [ %i0 + 8 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
4001b8cc: a2 10 20 00 clr %l1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001b8d0: 10 80 00 5d b 4001ba44 <rtems_rfs_dir_add_entry+0x360>
4001b8d4: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001b8d8: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001b8dc: e4 0f 40 00 ldub [ %i5 ], %l2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001b8e0: a1 2c 20 08 sll %l0, 8, %l0
4001b8e4: a0 14 00 03 or %l0, %g3, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001b8e8: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
4001b8ec: a5 2c a0 18 sll %l2, 0x18, %l2
4001b8f0: 87 28 e0 10 sll %g3, 0x10, %g3
4001b8f4: a4 14 80 03 or %l2, %g3, %l2
4001b8f8: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b8fc: 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);
4001b900: a4 14 80 03 or %l2, %g3, %l2
4001b904: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
4001b908: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b90c: 12 80 00 2a bne 4001b9b4 <rtems_rfs_dir_add_entry+0x2d0>
4001b910: a4 14 80 03 or %l2, %g3, %l2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
4001b914: a2 20 40 11 sub %g1, %l1, %l1
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001b918: 80 a5 40 11 cmp %l5, %l1
4001b91c: 3a bf ff 9c bcc,a 4001b78c <rtems_rfs_dir_add_entry+0xa8><== NEVER TAKEN
4001b920: 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);
4001b924: 92 10 00 1b mov %i3, %o1
4001b928: 40 00 11 18 call 4001fd88 <rtems_rfs_dir_hash>
4001b92c: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
4001b930: 83 32 20 18 srl %o0, 0x18, %g1
4001b934: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
4001b938: 83 32 20 10 srl %o0, 0x10, %g1
4001b93c: c2 2f 60 05 stb %g1, [ %i5 + 5 ]
4001b940: 83 32 20 08 srl %o0, 8, %g1
4001b944: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001b948: 83 37 20 18 srl %i4, 0x18, %g1
4001b94c: c2 2f 40 00 stb %g1, [ %i5 ]
4001b950: 83 37 20 10 srl %i4, 0x10, %g1
4001b954: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
4001b958: 83 37 20 08 srl %i4, 8, %g1
4001b95c: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
rtems_rfs_dir_set_entry_length (entry,
4001b960: 82 06 e0 0a add %i3, 0xa, %g1
4001b964: 85 30 60 08 srl %g1, 8, %g2
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
4001b968: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
4001b96c: c4 2f 60 08 stb %g2, [ %i5 + 8 ]
4001b970: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001b974: 94 10 00 1b mov %i3, %o2
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
4001b978: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001b97c: 90 07 60 0a add %i5, 0xa, %o0
4001b980: 40 00 16 3d call 40021274 <memcpy>
4001b984: 92 10 00 1a mov %i2, %o1
rtems_rfs_buffer_mark_dirty (&buffer);
4001b988: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
4001b98c: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
4001b990: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
4001b994: 7f ff fe 0c call 4001b1c4 <rtems_rfs_buffer_handle_close>
4001b998: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001b99c: 90 10 00 18 mov %i0, %o0
4001b9a0: 92 07 bf b0 add %fp, -80, %o1
4001b9a4: 7f ff f8 c7 call 40019cc0 <rtems_rfs_block_map_close>
4001b9a8: ba 10 20 00 clr %i5
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001b9ac: 81 c7 e0 08 ret
4001b9b0: 91 e8 00 1d restore %g0, %i5, %o0
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001b9b4: 80 a4 20 0a cmp %l0, 0xa
4001b9b8: 04 80 00 0d ble 4001b9ec <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
4001b9bc: 90 10 20 00 clr %o0
4001b9c0: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
4001b9c4: 80 a4 00 03 cmp %l0, %g3
4001b9c8: 1a 80 00 09 bcc 4001b9ec <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
4001b9cc: 80 a4 a0 00 cmp %l2, 0
4001b9d0: 02 80 00 07 be 4001b9ec <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
4001b9d4: 01 00 00 00 nop
4001b9d8: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
4001b9dc: 80 a4 80 03 cmp %l2, %g3
4001b9e0: 28 80 00 18 bleu,a 4001ba40 <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
4001b9e4: ba 07 40 10 add %i5, %l0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001b9e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b9ec: 7f ff dc 69 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b9f0: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001b9f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b9f8: 02 80 00 0a be 4001ba20 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
4001b9fc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001ba00: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001ba04: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001ba08: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001ba0c: 90 12 21 d8 or %o0, 0x1d8, %o0 <== NOT EXECUTED
4001ba10: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001ba14: 40 00 17 25 call 400216a8 <printf> <== NOT EXECUTED
4001ba18: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ba1c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001ba20: 7f ff fd e9 call 4001b1c4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001ba24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001ba28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ba2c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001ba30: 7f ff f8 a4 call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001ba34: 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;
}
4001ba38: 81 c7 e0 08 ret <== NOT EXECUTED
4001ba3c: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
4001ba40: 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))
4001ba44: 80 a4 40 02 cmp %l1, %g2
4001ba48: 2a bf ff a4 bcs,a 4001b8d8 <rtems_rfs_dir_add_entry+0x1f4><== ALWAYS TAKEN
4001ba4c: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
4001ba50: 10 bf ff 4f b 4001b78c <rtems_rfs_dir_add_entry+0xa8> <== NOT EXECUTED
4001ba54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ba58: 7f ff fd db call 4001b1c4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001ba5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001ba60: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ba64: 7f ff f8 97 call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001ba68: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
return rc;
}
4001ba6c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001ba70: 81 c7 e0 08 ret <== NOT EXECUTED
4001ba74: 81 e8 00 00 restore <== NOT EXECUTED
4001ba78 <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)
{
4001ba78: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001ba7c: 90 10 20 00 clr %o0
4001ba80: 13 10 00 00 sethi %hi(0x40000000), %o1
4001ba84: 7f ff dc 43 call 40012b90 <rtems_rfs_trace>
4001ba88: ba 10 00 18 mov %i0, %i5
4001ba8c: 80 8a 20 ff btst 0xff, %o0
4001ba90: 02 80 00 09 be 4001bab4 <rtems_rfs_dir_del_entry+0x3c> <== ALWAYS TAKEN
4001ba94: aa 07 bf b0 add %fp, -80, %l5
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
4001ba98: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001ba9c: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001baa0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001baa4: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
4001baa8: 40 00 17 00 call 400216a8 <printf> <== NOT EXECUTED
4001baac: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001bab0: aa 07 bf b0 add %fp, -80, %l5 <== NOT EXECUTED
4001bab4: 90 10 00 1d mov %i5, %o0
4001bab8: 92 10 00 19 mov %i1, %o1
4001babc: 7f ff f8 20 call 40019b3c <rtems_rfs_block_map_open>
4001bac0: 94 10 00 15 mov %l5, %o2
if (rc > 0)
4001bac4: b0 92 20 00 orcc %o0, 0, %i0
4001bac8: 14 80 00 c4 bg 4001bdd8 <rtems_rfs_dir_del_entry+0x360> <== NEVER TAKEN
4001bacc: ac 07 bf a0 add %fp, -96, %l6
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001bad0: 90 10 00 1d mov %i5, %o0
4001bad4: 92 10 00 15 mov %l5, %o1
4001bad8: 94 10 20 00 clr %o2
4001badc: 96 10 00 1b mov %i3, %o3
4001bae0: 7f ff f9 48 call 4001a000 <rtems_rfs_block_map_seek>
4001bae4: 98 10 00 16 mov %l6, %o4
if (rc > 0)
4001bae8: b0 92 20 00 orcc %o0, 0, %i0
4001baec: 04 80 00 06 ble 4001bb04 <rtems_rfs_dir_del_entry+0x8c> <== ALWAYS TAKEN
4001baf0: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
4001baf4: 22 80 00 b6 be,a 4001bdcc <rtems_rfs_dir_del_entry+0x354><== NOT EXECUTED
4001baf8: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001bafc: 10 80 00 b5 b 4001bdd0 <rtems_rfs_dir_del_entry+0x358> <== NOT EXECUTED
4001bb00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
4001bb04: 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)
4001bb08: 29 00 00 3f sethi %hi(0xfc00), %l4
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
4001bb0c: 2f 10 00 d3 sethi %hi(0x40034c00), %l7
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001bb10: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001bb14: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001bb18: c0 27 bf ac clr [ %fp + -84 ]
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
4001bb1c: b0 10 20 00 clr %i0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
4001bb20: 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)
4001bb24: a8 15 23 ff or %l4, 0x3ff, %l4
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
4001bb28: 10 80 00 c1 b 4001be2c <rtems_rfs_dir_del_entry+0x3b4>
4001bb2c: ae 15 e2 a8 or %l7, 0x2a8, %l7
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001bb30: 90 10 00 1d mov %i5, %o0
4001bb34: 92 07 bf a4 add %fp, -92, %o1
4001bb38: 7f ff fb ee call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001bb3c: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001bb40: a4 92 20 00 orcc %o0, 0, %l2
4001bb44: 04 80 00 13 ble 4001bb90 <rtems_rfs_dir_del_entry+0x118> <== ALWAYS TAKEN
4001bb48: 80 a4 e0 00 cmp %l3, 0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001bb4c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001bb50: 7f ff dc 10 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001bb54: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001bb58: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bb5c: 22 80 00 b9 be,a 4001be40 <rtems_rfs_dir_del_entry+0x3c8><== NOT EXECUTED
4001bb60: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001bb64: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001bb68: 40 00 1b 3c call 40022858 <strerror> <== NOT EXECUTED
4001bb6c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4001bb70: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001bb74: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001bb78: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001bb7c: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001bb80: 40 00 16 ca call 400216a8 <printf> <== NOT EXECUTED
4001bb84: 90 12 22 60 or %o0, 0x260, %o0 ! 40034e60 <CSWTCH.2+0xab0><== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001bb88: 10 80 00 ae b 4001be40 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
4001bb8c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
4001bb90: 12 80 00 06 bne 4001bba8 <rtems_rfs_dir_del_entry+0x130> <== NEVER TAKEN
4001bb94: a0 10 20 00 clr %l0
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
4001bb98: d2 07 60 08 ld [ %i5 + 8 ], %o1
4001bb9c: 40 00 48 7b call 4002dd88 <.urem>
4001bba0: 90 10 00 1b mov %i3, %o0
4001bba4: a0 10 00 08 mov %o0, %l0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001bba8: c2 07 bf ac ld [ %fp + -84 ], %g1
4001bbac: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001bbb0: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001bbb4: b8 07 00 10 add %i4, %l0, %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001bbb8: 10 80 00 8d b 4001bdec <rtems_rfs_dir_del_entry+0x374>
4001bbbc: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001bbc0: e2 0f 20 08 ldub [ %i4 + 8 ], %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001bbc4: d6 0f 00 00 ldub [ %i4 ], %o3
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001bbc8: a3 2c 60 08 sll %l1, 8, %l1
4001bbcc: a2 14 40 03 or %l1, %g3, %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001bbd0: c6 0f 20 01 ldub [ %i4 + 1 ], %g3
4001bbd4: 97 2a e0 18 sll %o3, 0x18, %o3
4001bbd8: 87 28 e0 10 sll %g3, 0x10, %g3
4001bbdc: 96 12 c0 03 or %o3, %g3, %o3
4001bbe0: c6 0f 20 03 ldub [ %i4 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001bbe4: 80 a4 40 14 cmp %l1, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001bbe8: 96 12 c0 03 or %o3, %g3, %o3
4001bbec: c6 0f 20 02 ldub [ %i4 + 2 ], %g3
4001bbf0: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001bbf4: 02 80 00 81 be 4001bdf8 <rtems_rfs_dir_del_entry+0x380> <== NEVER TAKEN
4001bbf8: 96 12 c0 03 or %o3, %g3, %o3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001bbfc: 80 a4 60 0a cmp %l1, 0xa
4001bc00: 24 80 00 0d ble,a 4001bc34 <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
4001bc04: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
4001bc08: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
4001bc0c: 80 a4 40 03 cmp %l1, %g3
4001bc10: 1a 80 00 08 bcc 4001bc30 <rtems_rfs_dir_del_entry+0x1b8> <== NEVER TAKEN
4001bc14: 80 a2 e0 00 cmp %o3, 0
4001bc18: 22 80 00 07 be,a 4001bc34 <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
4001bc1c: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
4001bc20: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
4001bc24: 80 a2 c0 03 cmp %o3, %g3
4001bc28: 08 80 00 11 bleu 4001bc6c <rtems_rfs_dir_del_entry+0x1f4> <== ALWAYS TAKEN
4001bc2c: 80 a6 80 0b cmp %i2, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001bc30: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
4001bc34: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001bc38: 7f ff db d6 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001bc3c: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001bc40: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bc44: 02 80 00 87 be 4001be60 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
4001bc48: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001bc4c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001bc50: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
4001bc54: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4001bc58: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4001bc5c: 40 00 16 93 call 400216a8 <printf> <== NOT EXECUTED
4001bc60: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
4001bc64: 10 80 00 71 b 4001be28 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
4001bc68: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
4001bc6c: 12 80 00 5d bne 4001bde0 <rtems_rfs_dir_del_entry+0x368> <== NEVER TAKEN
4001bc70: 80 a4 e0 00 cmp %l3, 0
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
4001bc74: 92 07 00 11 add %i4, %l1, %o1
4001bc78: 90 10 00 1c mov %i4, %o0
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001bc7c: b6 04 00 11 add %l0, %l1, %i3
4001bc80: b6 20 40 1b sub %g1, %i3, %i3
memmove (entry, entry + elength, remaining);
4001bc84: 40 00 15 b9 call 40021368 <memmove>
4001bc88: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
4001bc8c: 90 07 00 1b add %i4, %i3, %o0
4001bc90: 92 10 20 ff mov 0xff, %o1
4001bc94: 40 00 16 07 call 400214b0 <memset>
4001bc98: 94 10 00 11 mov %l1, %o2
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
4001bc9c: c4 0f 20 08 ldub [ %i4 + 8 ], %g2
4001bca0: c2 0f 20 09 ldub [ %i4 + 9 ], %g1
4001bca4: 85 28 a0 08 sll %g2, 8, %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001bca8: 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);
4001bcac: b8 10 80 01 or %g2, %g1, %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001bcb0: 7f ff db b8 call 40012b90 <rtems_rfs_trace>
4001bcb4: 13 10 00 00 sethi %hi(0x40000000), %o1
4001bcb8: 80 8a 20 ff btst 0xff, %o0
4001bcbc: 02 80 00 1a be 4001bd24 <rtems_rfs_dir_del_entry+0x2ac> <== ALWAYS TAKEN
4001bcc0: 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");
4001bcc4: 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: "
4001bcc8: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
4001bccc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001bcd0: 12 80 00 08 bne 4001bcf0 <rtems_rfs_dir_del_entry+0x278> <== NOT EXECUTED
4001bcd4: 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");
4001bcd8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001bcdc: 12 80 00 06 bne 4001bcf4 <rtems_rfs_dir_del_entry+0x27c> <== NOT EXECUTED
4001bce0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
4001bce4: 1b 10 00 cd sethi %hi(0x40033400), %o5 <== NOT EXECUTED
4001bce8: 10 80 00 08 b 4001bd08 <rtems_rfs_dir_del_entry+0x290> <== NOT EXECUTED
4001bcec: 9a 13 61 10 or %o5, 0x110, %o5 ! 40033510 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
4001bcf0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001bcf4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001bcf8: 02 bf ff fc be 4001bce8 <rtems_rfs_dir_del_entry+0x270> <== NOT EXECUTED
4001bcfc: 1b 10 00 cd sethi %hi(0x40033400), %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: "
4001bd00: 1b 10 00 c6 sethi %hi(0x40031800), %o5 <== NOT EXECUTED
4001bd04: 9a 13 62 f8 or %o5, 0x2f8, %o5 ! 40031af8 <__FUNCTION__.6193+0x2f0><== NOT EXECUTED
4001bd08: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001bd0c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001bd10: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
4001bd14: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001bd18: 40 00 16 64 call 400216a8 <printf> <== NOT EXECUTED
4001bd1c: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
4001bd20: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
4001bd24: b8 38 40 1c xnor %g1, %i4, %i4
4001bd28: 80 a7 20 00 cmp %i4, 0
4001bd2c: 12 80 00 23 bne 4001bdb8 <rtems_rfs_dir_del_entry+0x340>
4001bd30: 80 a4 20 00 cmp %l0, 0
4001bd34: 12 80 00 21 bne 4001bdb8 <rtems_rfs_dir_del_entry+0x340> <== ALWAYS TAKEN
4001bd38: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001bd3c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001bd40: 12 80 00 05 bne 4001bd54 <rtems_rfs_dir_del_entry+0x2dc> <== NOT EXECUTED
4001bd44: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
4001bd48: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001bd4c: 02 80 00 07 be 4001bd68 <rtems_rfs_dir_del_entry+0x2f0> <== NOT EXECUTED
4001bd50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001bd54: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001bd58: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001bd5c: 12 80 00 18 bne 4001bdbc <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
4001bd60: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001bd64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001bd68: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001bd6c: 7f ff f9 bf call 4001a468 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
4001bd70: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
4001bd74: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001bd78: 04 80 00 10 ble 4001bdb8 <rtems_rfs_dir_del_entry+0x340> <== NOT EXECUTED
4001bd7c: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001bd80: 7f ff db 84 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001bd84: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001bd88: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bd8c: 02 80 00 0c be 4001bdbc <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
4001bd90: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001bd94: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
4001bd98: 40 00 1a b0 call 40022858 <strerror> <== NOT EXECUTED
4001bd9c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001bda0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001bda4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001bda8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001bdac: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001bdb0: 40 00 16 3e call 400216a8 <printf> <== NOT EXECUTED
4001bdb4: 90 12 23 58 or %o0, 0x358, %o0 ! 40034f58 <CSWTCH.2+0xba8><== NOT EXECUTED
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
4001bdb8: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
4001bdbc: 90 10 00 1d mov %i5, %o0
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
4001bdc0: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
4001bdc4: 7f ff fd 00 call 4001b1c4 <rtems_rfs_buffer_handle_close>
4001bdc8: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_block_map_close (fs, &map);
4001bdcc: 90 10 00 1d mov %i5, %o0
4001bdd0: 7f ff f7 bc call 40019cc0 <rtems_rfs_block_map_close>
4001bdd4: 92 07 bf b0 add %fp, -80, %o1
4001bdd8: 81 c7 e0 08 ret
4001bddc: 81 e8 00 00 restore
return 0;
}
if (!search)
4001bde0: 02 80 00 20 be 4001be60 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
4001bde4: b8 07 00 11 add %i4, %l1, %i4 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
4001bde8: a0 04 00 11 add %l0, %l1, %l0 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001bdec: 80 a4 00 02 cmp %l0, %g2
4001bdf0: 2a bf ff 74 bcs,a 4001bbc0 <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
4001bdf4: c6 0f 20 09 ldub [ %i4 + 9 ], %g3
entry += elength;
eoffset += elength;
}
if (rc == 0)
4001bdf8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001bdfc: 32 80 00 0c bne,a 4001be2c <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
4001be00: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001be04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001be08: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001be0c: 7f ff f8 9a call 4001a074 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001be10: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
if (rc == ENXIO)
4001be14: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
4001be18: 12 80 00 05 bne 4001be2c <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
4001be1c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = ENOENT;
4001be20: 10 80 00 06 b 4001be38 <rtems_rfs_dir_del_entry+0x3c0> <== NOT EXECUTED
4001be24: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
4001be28: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
4001be2c: 80 a6 20 00 cmp %i0, 0
4001be30: 02 bf ff 40 be 4001bb30 <rtems_rfs_dir_del_entry+0xb8> <== ALWAYS TAKEN
4001be34: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001be38: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001be3c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001be40: 7f ff fc e1 call 4001b1c4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001be44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001be48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001be4c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001be50: 7f ff f7 9c call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001be54: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
4001be58: 81 c7 e0 08 ret <== NOT EXECUTED
4001be5c: 81 e8 00 00 restore <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
4001be60: 10 bf ff f2 b 4001be28 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
4001be64: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
4001c200 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
4001c200: 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))
4001c204: 90 10 20 00 clr %o0
4001c208: 7f ff da 62 call 40012b90 <rtems_rfs_trace>
4001c20c: 13 20 00 00 sethi %hi(0x80000000), %o1
4001c210: 80 8a 20 ff btst 0xff, %o0
4001c214: 02 80 00 07 be 4001c230 <rtems_rfs_dir_empty+0x30> <== ALWAYS TAKEN
4001c218: b8 07 bf b0 add %fp, -80, %i4
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
4001c21c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c220: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c224: 40 00 15 21 call 400216a8 <printf> <== NOT EXECUTED
4001c228: 90 12 20 88 or %o0, 0x88, %o0 ! 40035088 <CSWTCH.2+0xcd8> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001c22c: b8 07 bf b0 add %fp, -80, %i4 <== NOT EXECUTED
4001c230: 90 10 00 18 mov %i0, %o0
4001c234: 92 10 00 19 mov %i1, %o1
4001c238: 7f ff f6 41 call 40019b3c <rtems_rfs_block_map_open>
4001c23c: 94 10 00 1c mov %i4, %o2
if (rc > 0)
4001c240: ba 92 20 00 orcc %o0, 0, %i5
4001c244: 34 80 00 82 bg,a 4001c44c <rtems_rfs_dir_empty+0x24c> <== NEVER TAKEN
4001c248: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001c24c: b6 07 bf a0 add %fp, -96, %i3
4001c250: 90 10 00 18 mov %i0, %o0
4001c254: 92 10 00 1c mov %i4, %o1
4001c258: 94 10 20 00 clr %o2
4001c25c: 96 10 20 00 clr %o3
4001c260: 7f ff f7 68 call 4001a000 <rtems_rfs_block_map_seek>
4001c264: 98 10 00 1b mov %i3, %o4
if (rc > 0)
4001c268: ba 92 20 00 orcc %o0, 0, %i5
4001c26c: 04 80 00 05 ble 4001c280 <rtems_rfs_dir_empty+0x80> <== ALWAYS TAKEN
4001c270: 25 00 00 3f sethi %hi(0xfc00), %l2
{
rtems_rfs_block_map_close (fs, &map);
4001c274: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c278: 10 80 00 69 b 4001c41c <rtems_rfs_dir_empty+0x21c> <== NOT EXECUTED
4001c27c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
4001c280: 27 10 00 d4 sethi %hi(0x40035000), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001c284: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001c288: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001c28c: 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)
4001c290: a4 14 a3 ff or %l2, 0x3ff, %l2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
4001c294: a6 14 e0 a8 or %l3, 0xa8, %l3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c298: a2 10 00 1c mov %i4, %l1
4001c29c: a0 10 00 1b mov %i3, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001c2a0: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001c2a4: 90 10 00 18 mov %i0, %o0
4001c2a8: 92 07 bf a4 add %fp, -92, %o1
4001c2ac: 7f ff fa 11 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001c2b0: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001c2b4: ba 92 20 00 orcc %o0, 0, %i5
4001c2b8: 14 80 00 4c bg 4001c3e8 <rtems_rfs_dir_empty+0x1e8> <== NEVER TAKEN
4001c2bc: 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))
4001c2c0: c4 06 20 08 ld [ %i0 + 8 ], %g2
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
4001c2c4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c2c8: 84 00 bf f6 add %g2, -10, %g2
4001c2cc: 10 80 00 3b b 4001c3b8 <rtems_rfs_dir_empty+0x1b8>
4001c2d0: b6 10 20 00 clr %i3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001c2d4: f8 08 60 08 ldub [ %g1 + 8 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001c2d8: f4 08 40 00 ldub [ %g1 ], %i2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001c2dc: b9 2f 20 08 sll %i4, 8, %i4
4001c2e0: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001c2e4: c6 08 60 01 ldub [ %g1 + 1 ], %g3
4001c2e8: b5 2e a0 18 sll %i2, 0x18, %i2
4001c2ec: 87 28 e0 10 sll %g3, 0x10, %g3
4001c2f0: b4 16 80 03 or %i2, %g3, %i2
4001c2f4: c6 08 60 03 ldub [ %g1 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c2f8: 80 a7 00 12 cmp %i4, %l2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001c2fc: b4 16 80 03 or %i2, %g3, %i2
4001c300: c6 08 60 02 ldub [ %g1 + 2 ], %g3
4001c304: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c308: 02 80 00 48 be 4001c428 <rtems_rfs_dir_empty+0x228>
4001c30c: b4 16 80 03 or %i2, %g3, %i2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001c310: 80 a7 20 0a cmp %i4, 0xa
4001c314: 04 80 00 0d ble 4001c348 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
4001c318: 90 10 20 01 mov 1, %o0
4001c31c: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
4001c320: 80 a7 00 03 cmp %i4, %g3
4001c324: 1a 80 00 09 bcc 4001c348 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
4001c328: 80 a6 a0 00 cmp %i2, 0
4001c32c: 02 80 00 07 be 4001c348 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
4001c330: 01 00 00 00 nop
4001c334: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
4001c338: 80 a6 80 03 cmp %i2, %g3
4001c33c: 08 80 00 10 bleu 4001c37c <rtems_rfs_dir_empty+0x17c> <== ALWAYS TAKEN
4001c340: 80 a7 20 0b cmp %i4, 0xb
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001c344: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
4001c348: 7f ff da 12 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001c34c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001c350: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c354: 22 80 00 36 be,a 4001c42c <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
4001c358: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
4001c35c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c360: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4001c364: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001c368: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4001c36c: 40 00 14 cf call 400216a8 <printf> <== NOT EXECUTED
4001c370: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c374: 10 80 00 2e b 4001c42c <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
4001c378: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
4001c37c: 12 80 00 04 bne 4001c38c <rtems_rfs_dir_empty+0x18c>
4001c380: 80 a7 20 0c cmp %i4, 0xc
4001c384: 10 80 00 09 b 4001c3a8 <rtems_rfs_dir_empty+0x1a8>
4001c388: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
4001c38c: 32 80 00 18 bne,a 4001c3ec <rtems_rfs_dir_empty+0x1ec>
4001c390: 82 10 20 00 clr %g1
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
4001c394: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
4001c398: 80 a0 e0 2e cmp %g3, 0x2e
4001c39c: 32 80 00 14 bne,a 4001c3ec <rtems_rfs_dir_empty+0x1ec> <== NEVER TAKEN
4001c3a0: 82 10 20 00 clr %g1 <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001c3a4: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
4001c3a8: 80 a0 e0 2e cmp %g3, 0x2e
4001c3ac: 12 80 00 0c bne 4001c3dc <rtems_rfs_dir_empty+0x1dc> <== NEVER TAKEN
4001c3b0: b6 06 c0 1c add %i3, %i4, %i3
{
empty = false;
break;
}
entry += elength;
4001c3b4: 82 00 40 1c add %g1, %i4, %g1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c3b8: 80 a6 c0 02 cmp %i3, %g2
4001c3bc: 2a bf ff c6 bcs,a 4001c2d4 <rtems_rfs_dir_empty+0xd4> <== ALWAYS TAKEN
4001c3c0: c6 08 60 09 ldub [ %g1 + 9 ], %g3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c3c4: 10 80 00 1a b 4001c42c <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
4001c3c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
{
if (rc == ENXIO)
4001c3cc: 02 80 00 06 be 4001c3e4 <rtems_rfs_dir_empty+0x1e4> <== ALWAYS TAKEN
4001c3d0: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
4001c3d4: 10 80 00 07 b 4001c3f0 <rtems_rfs_dir_empty+0x1f0> <== NOT EXECUTED
4001c3d8: 82 18 60 01 xor %g1, 1, %g1 <== NOT EXECUTED
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001c3dc: 10 80 00 04 b 4001c3ec <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
4001c3e0: 82 10 20 00 clr %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = 0;
4001c3e4: ba 10 20 00 clr %i5
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
4001c3e8: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
4001c3ec: 82 18 60 01 xor %g1, 1, %g1
4001c3f0: 80 88 60 ff btst 0xff, %g1
4001c3f4: 02 80 00 06 be 4001c40c <rtems_rfs_dir_empty+0x20c>
4001c3f8: 92 07 bf a4 add %fp, -92, %o1
4001c3fc: 80 a7 60 00 cmp %i5, 0
4001c400: 22 80 00 03 be,a 4001c40c <rtems_rfs_dir_empty+0x20c> <== ALWAYS TAKEN
4001c404: ba 10 20 5a mov 0x5a, %i5
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
4001c408: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001c40c: 7f ff fb 6e call 4001b1c4 <rtems_rfs_buffer_handle_close>
4001c410: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001c414: 90 10 00 18 mov %i0, %o0
4001c418: 92 07 bf b0 add %fp, -80, %o1
4001c41c: 7f ff f6 29 call 40019cc0 <rtems_rfs_block_map_close>
4001c420: b0 10 00 1d mov %i5, %i0
4001c424: 30 80 00 0a b,a 4001c44c <rtems_rfs_dir_empty+0x24c>
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c428: 90 10 00 18 mov %i0, %o0
4001c42c: 92 10 00 11 mov %l1, %o1
4001c430: 7f ff f7 11 call 4001a074 <rtems_rfs_block_map_next_block>
4001c434: 94 10 00 10 mov %l0, %o2
if (rc > 0)
4001c438: ba 92 20 00 orcc %o0, 0, %i5
4001c43c: 24 bf ff 9a ble,a 4001c2a4 <rtems_rfs_dir_empty+0xa4> <== NEVER TAKEN
4001c440: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
{
if (rc == ENXIO)
4001c444: 10 bf ff e2 b 4001c3cc <rtems_rfs_dir_empty+0x1cc>
4001c448: 80 a7 60 06 cmp %i5, 6
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001c44c: 81 c7 e0 08 ret
4001c450: 81 e8 00 00 restore
4001fd88 <rtems_rfs_dir_hash>:
{
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
4001fd88: 05 37 f7 c5 sethi %hi(0xdfdf1400), %g2
4001fd8c: 84 10 a2 9f or %g2, 0x29f, %g2 ! dfdf169f <LEON_REG+0x5fdf169f>
4001fd90: 84 02 40 02 add %o1, %g2, %g2
4001fd94: 86 10 00 02 mov %g2, %g3
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
4001fd98: 10 80 00 48 b 4001feb8 <rtems_rfs_dir_hash+0x130>
4001fd9c: 88 10 00 02 mov %g2, %g4
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
4001fda0: d8 0a 20 02 ldub [ %o0 + 2 ], %o4
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
4001fda4: 88 03 40 04 add %o5, %g4, %g4
a += ((uint32_t)k[1])<<8;
4001fda8: da 0a 20 01 ldub [ %o0 + 1 ], %o5
a += ((uint32_t)k[2])<<16;
4001fdac: 99 2b 20 10 sll %o4, 0x10, %o4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
4001fdb0: 9b 2b 60 08 sll %o5, 8, %o5
4001fdb4: 9a 01 00 0d add %g4, %o5, %o5
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
4001fdb8: c8 0a 20 04 ldub [ %o0 + 4 ], %g4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
4001fdbc: 9a 03 40 0c add %o5, %o4, %o5
a += ((uint32_t)k[3])<<24;
b += k[4];
4001fdc0: 86 01 00 03 add %g4, %g3, %g3
b += ((uint32_t)k[5])<<8;
4001fdc4: c8 0a 20 05 ldub [ %o0 + 5 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
4001fdc8: d8 0a 20 03 ldub [ %o0 + 3 ], %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
4001fdcc: 89 29 20 08 sll %g4, 8, %g4
4001fdd0: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[6])<<16;
4001fdd4: c8 0a 20 06 ldub [ %o0 + 6 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
4001fdd8: 99 2b 20 18 sll %o4, 0x18, %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
4001fddc: 89 29 20 10 sll %g4, 0x10, %g4
4001fde0: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[7])<<24;
4001fde4: c8 0a 20 07 ldub [ %o0 + 7 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
4001fde8: 9a 03 40 0c add %o5, %o4, %o5
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
4001fdec: 89 29 20 18 sll %g4, 0x18, %g4
4001fdf0: 86 00 c0 04 add %g3, %g4, %g3
c += k[8];
4001fdf4: c8 0a 20 08 ldub [ %o0 + 8 ], %g4
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
4001fdf8: 92 02 7f f4 add %o1, -12, %o1
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
4001fdfc: 84 01 00 02 add %g4, %g2, %g2
c += ((uint32_t)k[9])<<8;
4001fe00: c8 0a 20 09 ldub [ %o0 + 9 ], %g4
4001fe04: 89 29 20 08 sll %g4, 8, %g4
4001fe08: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[10])<<16;
4001fe0c: c8 0a 20 0a ldub [ %o0 + 0xa ], %g4
4001fe10: 89 29 20 10 sll %g4, 0x10, %g4
4001fe14: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[11])<<24;
4001fe18: c8 0a 20 0b ldub [ %o0 + 0xb ], %g4
mix(a,b,c);
length -= 12;
k += 12;
4001fe1c: 90 02 20 0c add %o0, 0xc, %o0
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
4001fe20: 89 29 20 18 sll %g4, 0x18, %g4
4001fe24: 84 00 80 04 add %g2, %g4, %g2
mix(a,b,c);
4001fe28: 9a 23 40 02 sub %o5, %g2, %o5
4001fe2c: 99 28 a0 04 sll %g2, 4, %o4
4001fe30: 89 30 a0 1c srl %g2, 0x1c, %g4
4001fe34: 88 13 00 04 or %o4, %g4, %g4
4001fe38: 88 1b 40 04 xor %o5, %g4, %g4
4001fe3c: 99 29 20 06 sll %g4, 6, %o4
4001fe40: 9b 31 20 1a srl %g4, 0x1a, %o5
4001fe44: 9a 13 00 0d or %o4, %o5, %o5
4001fe48: 84 00 80 03 add %g2, %g3, %g2
4001fe4c: 86 20 c0 04 sub %g3, %g4, %g3
4001fe50: 86 1b 40 03 xor %o5, %g3, %g3
4001fe54: 99 28 e0 08 sll %g3, 8, %o4
4001fe58: 9b 30 e0 18 srl %g3, 0x18, %o5
4001fe5c: 9a 13 00 0d or %o4, %o5, %o5
4001fe60: 88 01 00 02 add %g4, %g2, %g4
4001fe64: 84 20 80 03 sub %g2, %g3, %g2
4001fe68: 84 1b 40 02 xor %o5, %g2, %g2
4001fe6c: 99 28 a0 10 sll %g2, 0x10, %o4
4001fe70: 9b 30 a0 10 srl %g2, 0x10, %o5
4001fe74: 9a 13 00 0d or %o4, %o5, %o5
4001fe78: 86 00 c0 04 add %g3, %g4, %g3
4001fe7c: 88 21 00 02 sub %g4, %g2, %g4
4001fe80: 88 1b 40 04 xor %o5, %g4, %g4
4001fe84: 99 29 20 13 sll %g4, 0x13, %o4
4001fe88: 9b 31 20 0d srl %g4, 0xd, %o5
4001fe8c: 9a 13 00 0d or %o4, %o5, %o5
4001fe90: 84 00 80 03 add %g2, %g3, %g2
4001fe94: 86 20 c0 04 sub %g3, %g4, %g3
4001fe98: 88 01 00 02 add %g4, %g2, %g4
4001fe9c: 86 1b 40 03 xor %o5, %g3, %g3
4001fea0: 84 20 80 03 sub %g2, %g3, %g2
4001fea4: 99 28 e0 04 sll %g3, 4, %o4
4001fea8: 9b 30 e0 1c srl %g3, 0x1c, %o5
4001feac: 86 00 c0 04 add %g3, %g4, %g3
4001feb0: 9a 13 00 0d or %o4, %o5, %o5
4001feb4: 84 1b 40 02 xor %o5, %g2, %g2
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
4001feb8: 80 a2 60 0c cmp %o1, 0xc
4001febc: 38 bf ff b9 bgu,a 4001fda0 <rtems_rfs_dir_hash+0x18>
4001fec0: da 0a 00 00 ldub [ %o0 ], %o5
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
4001fec4: 92 02 7f ff add %o1, -1, %o1
4001fec8: 80 a2 60 0b cmp %o1, 0xb
4001fecc: 18 80 00 4b bgu 4001fff8 <rtems_rfs_dir_hash+0x270> <== NEVER TAKEN
4001fed0: 93 2a 60 02 sll %o1, 2, %o1
4001fed4: 1b 10 00 7f sethi %hi(0x4001fc00), %o5
4001fed8: 9a 13 61 58 or %o5, 0x158, %o5 ! 4001fd58 <rtems_rfs_buffer_bdbuf_release+0x80>
4001fedc: da 03 40 09 ld [ %o5 + %o1 ], %o5
4001fee0: 81 c3 40 00 jmp %o5
4001fee4: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
4001fee8: da 0a 20 0b ldub [ %o0 + 0xb ], %o5
4001feec: 9b 2b 60 18 sll %o5, 0x18, %o5
4001fef0: 84 03 40 02 add %o5, %g2, %g2
case 11: c+=((uint32_t)k[10])<<16;
4001fef4: da 0a 20 0a ldub [ %o0 + 0xa ], %o5
4001fef8: 9b 2b 60 10 sll %o5, 0x10, %o5
4001fefc: 84 00 80 0d add %g2, %o5, %g2
case 10: c+=((uint32_t)k[9])<<8;
4001ff00: da 0a 20 09 ldub [ %o0 + 9 ], %o5
4001ff04: 9b 2b 60 08 sll %o5, 8, %o5
4001ff08: 84 00 80 0d add %g2, %o5, %g2
case 9 : c+=k[8];
4001ff0c: da 0a 20 08 ldub [ %o0 + 8 ], %o5
4001ff10: 84 00 80 0d add %g2, %o5, %g2
case 8 : b+=((uint32_t)k[7])<<24;
4001ff14: da 0a 20 07 ldub [ %o0 + 7 ], %o5
4001ff18: 9b 2b 60 18 sll %o5, 0x18, %o5
4001ff1c: 86 03 40 03 add %o5, %g3, %g3
case 7 : b+=((uint32_t)k[6])<<16;
4001ff20: da 0a 20 06 ldub [ %o0 + 6 ], %o5
4001ff24: 9b 2b 60 10 sll %o5, 0x10, %o5
4001ff28: 86 00 c0 0d add %g3, %o5, %g3
case 6 : b+=((uint32_t)k[5])<<8;
4001ff2c: da 0a 20 05 ldub [ %o0 + 5 ], %o5
4001ff30: 9b 2b 60 08 sll %o5, 8, %o5
4001ff34: 86 00 c0 0d add %g3, %o5, %g3
case 5 : b+=k[4];
4001ff38: da 0a 20 04 ldub [ %o0 + 4 ], %o5
4001ff3c: 86 00 c0 0d add %g3, %o5, %g3
case 4 : a+=((uint32_t)k[3])<<24;
4001ff40: da 0a 20 03 ldub [ %o0 + 3 ], %o5
4001ff44: 9b 2b 60 18 sll %o5, 0x18, %o5
4001ff48: 88 03 40 04 add %o5, %g4, %g4
case 3 : a+=((uint32_t)k[2])<<16;
4001ff4c: da 0a 20 02 ldub [ %o0 + 2 ], %o5
4001ff50: 9b 2b 60 10 sll %o5, 0x10, %o5
4001ff54: 88 01 00 0d add %g4, %o5, %g4
case 2 : a+=((uint32_t)k[1])<<8;
4001ff58: da 0a 20 01 ldub [ %o0 + 1 ], %o5
4001ff5c: 9b 2b 60 08 sll %o5, 8, %o5
4001ff60: 88 01 00 0d add %g4, %o5, %g4
case 1 : a+=k[0];
4001ff64: c2 0a 00 00 ldub [ %o0 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
4001ff68: 9b 30 e0 12 srl %g3, 0x12, %o5
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
4001ff6c: 88 01 00 01 add %g4, %g1, %g4
break;
case 0 : return c;
}
}
final(a,b,c);
4001ff70: 83 28 e0 0e sll %g3, 0xe, %g1
4001ff74: 82 13 40 01 or %o5, %g1, %g1
4001ff78: 84 18 80 03 xor %g2, %g3, %g2
4001ff7c: 84 20 80 01 sub %g2, %g1, %g2
4001ff80: 9b 28 a0 0b sll %g2, 0xb, %o5
4001ff84: 83 30 a0 15 srl %g2, 0x15, %g1
4001ff88: 82 13 40 01 or %o5, %g1, %g1
4001ff8c: 88 18 80 04 xor %g2, %g4, %g4
4001ff90: 88 21 00 01 sub %g4, %g1, %g4
4001ff94: 9b 29 20 19 sll %g4, 0x19, %o5
4001ff98: 83 31 20 07 srl %g4, 7, %g1
4001ff9c: 82 13 40 01 or %o5, %g1, %g1
4001ffa0: 86 19 00 03 xor %g4, %g3, %g3
4001ffa4: 86 20 c0 01 sub %g3, %g1, %g3
4001ffa8: 9b 28 e0 10 sll %g3, 0x10, %o5
4001ffac: 83 30 e0 10 srl %g3, 0x10, %g1
4001ffb0: 82 13 40 01 or %o5, %g1, %g1
4001ffb4: 84 18 c0 02 xor %g3, %g2, %g2
4001ffb8: 84 20 80 01 sub %g2, %g1, %g2
4001ffbc: 9b 28 a0 04 sll %g2, 4, %o5
4001ffc0: 83 30 a0 1c srl %g2, 0x1c, %g1
4001ffc4: 82 13 40 01 or %o5, %g1, %g1
4001ffc8: 88 18 80 04 xor %g2, %g4, %g4
4001ffcc: 88 21 00 01 sub %g4, %g1, %g4
4001ffd0: 83 29 20 0e sll %g4, 0xe, %g1
4001ffd4: 86 19 00 03 xor %g4, %g3, %g3
4001ffd8: 89 31 20 12 srl %g4, 0x12, %g4
4001ffdc: 88 10 40 04 or %g1, %g4, %g4
4001ffe0: 86 20 c0 04 sub %g3, %g4, %g3
4001ffe4: 84 18 c0 02 xor %g3, %g2, %g2
4001ffe8: 83 28 e0 18 sll %g3, 0x18, %g1
4001ffec: 87 30 e0 08 srl %g3, 8, %g3
4001fff0: 86 10 40 03 or %g1, %g3, %g3
4001fff4: 84 20 80 03 sub %g2, %g3, %g2
return c;
}
4001fff8: 81 c3 e0 08 retl
4001fffc: 90 10 00 02 mov %g2, %o0
4001b1ec <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
4001b1ec: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b1f0: 90 10 20 00 clr %o0
4001b1f4: 13 01 00 00 sethi %hi(0x4000000), %o1
4001b1f8: 7f ff de 66 call 40012b90 <rtems_rfs_trace>
4001b1fc: a0 10 00 18 mov %i0, %l0
4001b200: 80 8a 20 ff btst 0xff, %o0
4001b204: 22 80 00 13 be,a 4001b250 <rtems_rfs_dir_lookup_ino+0x64><== ALWAYS TAKEN
4001b208: c0 27 00 00 clr [ %i4 ]
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001b20c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001b210: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
4001b214: b0 10 20 00 clr %i0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001b218: 40 00 19 24 call 400216a8 <printf> <== NOT EXECUTED
4001b21c: 90 12 21 f0 or %o0, 0x1f0, %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
4001b220: 10 80 00 05 b 4001b234 <rtems_rfs_dir_lookup_ino+0x48> <== NOT EXECUTED
4001b224: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
4001b228: 40 00 19 8a call 40021850 <putchar> <== NOT EXECUTED
4001b22c: 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++)
4001b230: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
4001b234: 26 bf ff fd bl,a 4001b228 <rtems_rfs_dir_lookup_ino+0x3c><== NOT EXECUTED
4001b238: d0 4e 80 18 ldsb [ %i2 + %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
4001b23c: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b240: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001b244: 40 00 19 19 call 400216a8 <printf> <== NOT EXECUTED
4001b248: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
4001b24c: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
4001b250: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001b254: 90 10 00 10 mov %l0, %o0
4001b258: 92 10 00 19 mov %i1, %o1
4001b25c: 7f ff fa 38 call 40019b3c <rtems_rfs_block_map_open>
4001b260: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001b264: b0 92 20 00 orcc %o0, 0, %i0
4001b268: 04 80 00 12 ble 4001b2b0 <rtems_rfs_dir_lookup_ino+0xc4> <== ALWAYS TAKEN
4001b26c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b270: 7f ff de 48 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b274: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001b278: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b27c: 02 80 01 18 be 4001b6dc <rtems_rfs_dir_lookup_ino+0x4f0> <== NOT EXECUTED
4001b280: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
4001b284: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
4001b288: 40 00 1d 74 call 40022858 <strerror> <== NOT EXECUTED
4001b28c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b290: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001b294: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001b298: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001b29c: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b2a0: 40 00 19 02 call 400216a8 <printf> <== NOT EXECUTED
4001b2a4: 90 12 22 38 or %o0, 0x238, %o0 ! 40034a38 <CSWTCH.2+0x688><== NOT EXECUTED
4001b2a8: 81 c7 e0 08 ret <== NOT EXECUTED
4001b2ac: 81 e8 00 00 restore <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
4001b2b0: 92 10 00 1b mov %i3, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001b2b4: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001b2b8: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001b2bc: c0 27 bf ac clr [ %fp + -84 ]
4001b2c0: 40 00 12 b2 call 4001fd88 <rtems_rfs_dir_hash>
4001b2c4: 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);
4001b2c8: 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);
4001b2cc: d0 27 bf 9c st %o0, [ %fp + -100 ]
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001b2d0: 94 10 20 00 clr %o2
4001b2d4: 90 10 00 10 mov %l0, %o0
4001b2d8: 96 10 20 00 clr %o3
4001b2dc: 7f ff fb 49 call 4001a000 <rtems_rfs_block_map_seek>
4001b2e0: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001b2e4: b0 92 20 00 orcc %o0, 0, %i0
4001b2e8: 04 80 00 d3 ble 4001b634 <rtems_rfs_dir_lookup_ino+0x448> <== ALWAYS TAKEN
4001b2ec: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b2f0: 7f ff de 28 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b2f4: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001b2f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b2fc: 02 80 00 0a be 4001b324 <rtems_rfs_dir_lookup_ino+0x138> <== NOT EXECUTED
4001b300: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
4001b304: 40 00 1d 55 call 40022858 <strerror> <== NOT EXECUTED
4001b308: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b30c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001b310: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001b314: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b318: 40 00 18 e4 call 400216a8 <printf> <== NOT EXECUTED
4001b31c: 90 12 22 78 or %o0, 0x278, %o0 ! 40034a78 <CSWTCH.2+0x6c8><== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
4001b320: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
4001b324: 22 80 00 dc be,a 4001b694 <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
4001b328: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
4001b32c: 10 80 00 db b 4001b698 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
4001b330: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b334: 7f ff de 17 call 40012b90 <rtems_rfs_trace>
4001b338: 13 01 00 00 sethi %hi(0x4000000), %o1
4001b33c: 80 8a 20 ff btst 0xff, %o0
4001b340: 02 80 00 08 be 4001b360 <rtems_rfs_dir_lookup_ino+0x174> <== ALWAYS TAKEN
4001b344: d4 07 bf a0 ld [ %fp + -96 ], %o2
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001b348: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001b34c: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
4001b350: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b354: 40 00 18 d5 call 400216a8 <printf> <== NOT EXECUTED
4001b358: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40034ab8 <CSWTCH.2+0x708><== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001b35c: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
4001b360: 90 10 00 10 mov %l0, %o0
4001b364: 92 07 bf a4 add %fp, -92, %o1
4001b368: 7f ff fd e2 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001b36c: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001b370: a2 92 20 00 orcc %o0, 0, %l1
4001b374: 04 80 00 15 ble 4001b3c8 <rtems_rfs_dir_lookup_ino+0x1dc> <== ALWAYS TAKEN
4001b378: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b37c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b380: 7f ff de 04 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b384: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001b388: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b38c: 22 80 00 c2 be,a 4001b694 <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
4001b390: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
4001b394: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001b398: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
4001b39c: 40 00 1d 2f call 40022858 <strerror> <== NOT EXECUTED
4001b3a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001b3a4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001b3a8: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001b3ac: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001b3b0: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b3b4: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001b3b8: 40 00 18 bc call 400216a8 <printf> <== NOT EXECUTED
4001b3bc: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
4001b3c0: 10 80 00 b5 b 4001b694 <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
4001b3c4: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
4001b3c8: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001b3cc: 10 80 00 71 b 4001b590 <rtems_rfs_dir_lookup_ino+0x3a4>
4001b3d0: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001b3d4: c8 0c a0 04 ldub [ %l2 + 4 ], %g4
4001b3d8: 85 28 a0 10 sll %g2, 0x10, %g2
4001b3dc: 89 29 20 18 sll %g4, 0x18, %g4
4001b3e0: 88 11 00 02 or %g4, %g2, %g4
4001b3e4: c4 0c a0 07 ldub [ %l2 + 7 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
4001b3e8: c6 0c a0 09 ldub [ %l2 + 9 ], %g3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001b3ec: 88 11 00 02 or %g4, %g2, %g4
4001b3f0: c4 0c a0 06 ldub [ %l2 + 6 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
4001b3f4: de 0c 80 00 ldub [ %l2 ], %o7
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001b3f8: 85 28 a0 08 sll %g2, 8, %g2
4001b3fc: 88 11 00 02 or %g4, %g2, %g4
elength = rtems_rfs_dir_entry_length (entry);
4001b400: c4 0c a0 08 ldub [ %l2 + 8 ], %g2
*ino = rtems_rfs_dir_entry_ino (entry);
4001b404: 9f 2b e0 18 sll %o7, 0x18, %o7
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
4001b408: 85 28 a0 08 sll %g2, 8, %g2
4001b40c: a6 10 80 03 or %g2, %g3, %l3
*ino = rtems_rfs_dir_entry_ino (entry);
4001b410: c6 0c a0 01 ldub [ %l2 + 1 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b414: 80 a4 c0 14 cmp %l3, %l4
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
4001b418: 87 28 e0 10 sll %g3, 0x10, %g3
4001b41c: 86 13 c0 03 or %o7, %g3, %g3
4001b420: de 0c a0 03 ldub [ %l2 + 3 ], %o7
4001b424: 86 10 c0 0f or %g3, %o7, %g3
4001b428: de 0c a0 02 ldub [ %l2 + 2 ], %o7
4001b42c: 9f 2b e0 08 sll %o7, 8, %o7
4001b430: 86 10 c0 0f or %g3, %o7, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b434: 12 80 00 07 bne 4001b450 <rtems_rfs_dir_lookup_ino+0x264>
4001b438: c6 27 00 00 st %g3, [ %i4 ]
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001b43c: 80 a4 60 00 cmp %l1, 0
4001b440: 32 80 00 85 bne,a 4001b654 <rtems_rfs_dir_lookup_ino+0x468><== NEVER TAKEN
4001b444: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001b448: 10 80 00 5a b 4001b5b0 <rtems_rfs_dir_lookup_ino+0x3c4>
4001b44c: 90 10 00 10 mov %l0, %o0
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
4001b450: 80 a4 e0 0a cmp %l3, 0xa
4001b454: 34 80 00 0a bg,a 4001b47c <rtems_rfs_dir_lookup_ino+0x290><== ALWAYS TAKEN
4001b458: de 04 20 1c ld [ %l0 + 0x1c ], %o7
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b45c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b460: 7f ff dd cc call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b464: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001b468: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b46c: 22 80 00 70 be,a 4001b62c <rtems_rfs_dir_lookup_ino+0x440><== NOT EXECUTED
4001b470: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001b474: 10 80 00 0c b 4001b4a4 <rtems_rfs_dir_lookup_ino+0x2b8> <== NOT EXECUTED
4001b478: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
4001b47c: 80 a4 c0 0f cmp %l3, %o7
4001b480: 1a bf ff f7 bcc 4001b45c <rtems_rfs_dir_lookup_ino+0x270> <== NEVER TAKEN
4001b484: 80 a0 e0 00 cmp %g3, 0
4001b488: 02 bf ff f6 be 4001b460 <rtems_rfs_dir_lookup_ino+0x274> <== NEVER TAKEN
4001b48c: 90 10 20 00 clr %o0
4001b490: de 04 20 14 ld [ %l0 + 0x14 ], %o7
4001b494: 80 a0 c0 0f cmp %g3, %o7
4001b498: 08 80 00 0a bleu 4001b4c0 <rtems_rfs_dir_lookup_ino+0x2d4><== ALWAYS TAKEN
4001b49c: c2 07 bf 9c ld [ %fp + -100 ], %g1
4001b4a0: 30 bf ff f0 b,a 4001b460 <rtems_rfs_dir_lookup_ino+0x274><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001b4a4: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001b4a8: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001b4ac: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4001b4b0: 40 00 18 7e call 400216a8 <printf> <== NOT EXECUTED
4001b4b4: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
4001b4b8: 10 80 00 5d b 4001b62c <rtems_rfs_dir_lookup_ino+0x440> <== NOT EXECUTED
4001b4bc: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
4001b4c0: 80 a1 00 01 cmp %g4, %g1
4001b4c4: 12 80 00 30 bne 4001b584 <rtems_rfs_dir_lookup_ino+0x398>
4001b4c8: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001b4cc: 90 10 20 00 clr %o0
4001b4d0: 7f ff dd b0 call 40012b90 <rtems_rfs_trace>
4001b4d4: 13 02 00 00 sethi %hi(0x8000000), %o1
4001b4d8: 80 8a 20 ff btst 0xff, %o0
4001b4dc: 02 80 00 12 be 4001b524 <rtems_rfs_dir_lookup_ino+0x338> <== ALWAYS TAKEN
4001b4e0: 90 04 a0 0a add %l2, 0xa, %o0
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
4001b4e4: c6 0c a0 01 ldub [ %l2 + 1 ], %g3 <== NOT EXECUTED
4001b4e8: da 0c 80 00 ldub [ %l2 ], %o5 <== NOT EXECUTED
4001b4ec: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4001b4f0: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
4001b4f4: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
4001b4f8: c6 0c a0 03 ldub [ %l2 + 3 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001b4fc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
4001b500: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
4001b504: c6 0c a0 02 ldub [ %l2 + 2 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001b508: 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));
4001b50c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001b510: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
4001b514: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
4001b518: 40 00 18 64 call 400216a8 <printf> <== NOT EXECUTED
4001b51c: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001b520: 90 04 a0 0a add %l2, 0xa, %o0 <== NOT EXECUTED
4001b524: 92 10 00 1a mov %i2, %o1
4001b528: 40 00 17 29 call 400211cc <memcmp>
4001b52c: 94 10 00 1b mov %i3, %o2
4001b530: 80 a2 20 00 cmp %o0, 0
4001b534: 12 80 00 14 bne 4001b584 <rtems_rfs_dir_lookup_ino+0x398> <== NEVER TAKEN
4001b538: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
*offset = rtems_rfs_block_map_pos (fs, &map);
4001b53c: 90 10 00 10 mov %l0, %o0
4001b540: 7f ff f9 48 call 40019a60 <rtems_rfs_block_get_pos>
4001b544: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001b548: 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);
4001b54c: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001b550: 7f ff dd 90 call 40012b90 <rtems_rfs_trace>
4001b554: 13 04 00 00 sethi %hi(0x10000000), %o1
4001b558: 80 8a 20 ff btst 0xff, %o0
4001b55c: 22 80 00 4f be,a 4001b698 <rtems_rfs_dir_lookup_ino+0x4ac><== ALWAYS TAKEN
4001b560: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
4001b564: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001b568: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4001b56c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001b570: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
4001b574: 40 00 18 4d call 400216a8 <printf> <== NOT EXECUTED
4001b578: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 40034be8 <CSWTCH.2+0x838><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
4001b57c: 10 80 00 47 b 4001b698 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
4001b580: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
4001b584: a4 04 80 13 add %l2, %l3, %l2
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
4001b588: 86 00 c0 13 add %g3, %l3, %g3
4001b58c: c6 27 bf c4 st %g3, [ %fp + -60 ]
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001b590: c4 04 20 08 ld [ %l0 + 8 ], %g2
4001b594: c6 07 bf c4 ld [ %fp + -60 ], %g3
4001b598: 84 00 bf f6 add %g2, -10, %g2
4001b59c: 80 a0 c0 02 cmp %g3, %g2
4001b5a0: 2a bf ff 8d bcs,a 4001b3d4 <rtems_rfs_dir_lookup_ino+0x1e8><== ALWAYS TAKEN
4001b5a4: c4 0c a0 05 ldub [ %l2 + 5 ], %g2
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001b5a8: 10 bf ff a6 b 4001b440 <rtems_rfs_dir_lookup_ino+0x254> <== NOT EXECUTED
4001b5ac: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001b5b0: 92 07 bf b0 add %fp, -80, %o1
4001b5b4: 7f ff fa b0 call 4001a074 <rtems_rfs_block_map_next_block>
4001b5b8: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
4001b5bc: 80 a2 20 06 cmp %o0, 6
4001b5c0: 02 80 00 05 be 4001b5d4 <rtems_rfs_dir_lookup_ino+0x3e8> <== ALWAYS TAKEN
4001b5c4: b0 10 00 08 mov %o0, %i0
4001b5c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b5cc: 14 80 00 07 bg 4001b5e8 <rtems_rfs_dir_lookup_ino+0x3fc> <== NOT EXECUTED
4001b5d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
4001b5d4: 80 a6 20 06 cmp %i0, 6
4001b5d8: 12 80 00 20 bne 4001b658 <rtems_rfs_dir_lookup_ino+0x46c> <== NEVER TAKEN
4001b5dc: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
4001b5e0: 10 80 00 11 b 4001b624 <rtems_rfs_dir_lookup_ino+0x438>
4001b5e4: b0 10 20 02 mov 2, %i0
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b5e8: 7f ff dd 6a call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b5ec: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001b5f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b5f4: 22 bf ff f9 be,a 4001b5d8 <rtems_rfs_dir_lookup_ino+0x3ec><== NOT EXECUTED
4001b5f8: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001b5fc: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
4001b600: 40 00 1c 96 call 40022858 <strerror> <== NOT EXECUTED
4001b604: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b608: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001b60c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001b610: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001b614: 40 00 18 25 call 400216a8 <printf> <== NOT EXECUTED
4001b618: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001b61c: 10 80 00 0f b 4001b658 <rtems_rfs_dir_lookup_ino+0x46c> <== NOT EXECUTED
4001b620: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001b624: 10 80 00 25 b 4001b6b8 <rtems_rfs_dir_lookup_ino+0x4cc>
4001b628: a2 10 00 18 mov %i0, %l1
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
4001b62c: 10 80 00 0a b 4001b654 <rtems_rfs_dir_lookup_ino+0x468> <== NOT EXECUTED
4001b630: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b634: 29 00 00 3f sethi %hi(0xfc00), %l4
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001b638: 2b 10 00 d2 sethi %hi(0x40034800), %l5
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001b63c: 2d 10 00 d3 sethi %hi(0x40034c00), %l6
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001b640: 2f 10 00 d2 sethi %hi(0x40034800), %l7
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b644: a8 15 23 ff or %l4, 0x3ff, %l4
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001b648: aa 15 63 88 or %l5, 0x388, %l5
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001b64c: ac 15 a0 30 or %l6, 0x30, %l6
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001b650: ae 15 e3 38 or %l7, 0x338, %l7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001b654: 80 a6 20 00 cmp %i0, 0
4001b658: 12 80 00 17 bne 4001b6b4 <rtems_rfs_dir_lookup_ino+0x4c8> <== NEVER TAKEN
4001b65c: c2 07 bf a0 ld [ %fp + -96 ], %g1
4001b660: 80 a0 60 00 cmp %g1, 0
4001b664: 12 bf ff 34 bne 4001b334 <rtems_rfs_dir_lookup_ino+0x148> <== ALWAYS TAKEN
4001b668: 90 10 20 00 clr %o0
4001b66c: 30 80 00 15 b,a 4001b6c0 <rtems_rfs_dir_lookup_ino+0x4d4><== NOT EXECUTED
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001b670: 40 00 1c 7a call 40022858 <strerror> <== NOT EXECUTED
4001b674: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
4001b678: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001b67c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001b680: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
4001b684: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001b688: 40 00 18 08 call 400216a8 <printf> <== NOT EXECUTED
4001b68c: 90 12 20 80 or %o0, 0x80, %o0 ! 40034c80 <CSWTCH.2+0x8d0> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
4001b690: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
4001b694: 92 07 bf a4 add %fp, -92, %o1
4001b698: 7f ff fe cb call 4001b1c4 <rtems_rfs_buffer_handle_close>
4001b69c: 90 10 00 10 mov %l0, %o0
rtems_rfs_block_map_close (fs, &map);
4001b6a0: 90 10 00 10 mov %l0, %o0
4001b6a4: 7f ff f9 87 call 40019cc0 <rtems_rfs_block_map_close>
4001b6a8: 92 07 bf b0 add %fp, -80, %o1
4001b6ac: 81 c7 e0 08 ret
4001b6b0: 81 e8 00 00 restore
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001b6b4: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
4001b6b8: 10 bf ff f7 b 4001b694 <rtems_rfs_dir_lookup_ino+0x4a8>
4001b6bc: b0 10 00 11 mov %l1, %i0
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001b6c0: 7f ff dd 34 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001b6c4: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001b6c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b6cc: 32 bf ff e9 bne,a 4001b670 <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED
4001b6d0: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
4001b6d4: 10 bf ff f0 b 4001b694 <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
4001b6d8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001b6dc: 81 c7 e0 08 ret <== NOT EXECUTED
4001b6e0: 81 e8 00 00 restore <== NOT EXECUTED
4001be68 <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)
{
4001be68: 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))
4001be6c: 90 10 20 00 clr %o0
4001be70: 7f ff db 48 call 40012b90 <rtems_rfs_trace>
4001be74: 13 20 00 00 sethi %hi(0x80000000), %o1
4001be78: 80 8a 20 ff btst 0xff, %o0
4001be7c: 22 80 00 09 be,a 4001bea0 <rtems_rfs_dir_read+0x38> <== ALWAYS TAKEN
4001be80: c0 27 40 00 clr [ %i5 ]
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
4001be84: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001be88: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001be8c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001be90: 90 12 23 a0 or %o0, 0x3a0, %o0 <== NOT EXECUTED
4001be94: 40 00 16 05 call 400216a8 <printf> <== NOT EXECUTED
4001be98: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
4001be9c: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001bea0: 90 10 00 18 mov %i0, %o0
4001bea4: 92 10 00 19 mov %i1, %o1
4001bea8: 7f ff f7 25 call 40019b3c <rtems_rfs_block_map_open>
4001beac: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001beb0: a0 92 20 00 orcc %o0, 0, %l0
4001beb4: 14 80 00 d1 bg 4001c1f8 <rtems_rfs_dir_read+0x390> <== NEVER TAKEN
4001beb8: 90 10 00 1a mov %i2, %o0
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
4001bebc: e0 06 20 08 ld [ %i0 + 8 ], %l0
4001bec0: a2 10 00 10 mov %l0, %l1
4001bec4: 92 10 00 1b mov %i3, %o1
4001bec8: a0 10 20 00 clr %l0
4001becc: 96 10 00 11 mov %l1, %o3
4001bed0: 40 00 49 89 call 4002e4f4 <__moddi3>
4001bed4: 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) -
4001bed8: 92 a4 40 09 subcc %l1, %o1, %o1
4001bedc: 90 64 00 08 subx %l0, %o0, %o0
4001bee0: 80 a2 20 00 cmp %o0, 0
4001bee4: 34 80 00 17 bg,a 4001bf40 <rtems_rfs_dir_read+0xd8> <== NEVER TAKEN
4001bee8: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
4001beec: 80 a2 20 00 cmp %o0, 0
4001bef0: 12 80 00 06 bne 4001bf08 <rtems_rfs_dir_read+0xa0> <== NEVER TAKEN
4001bef4: 90 10 00 1a mov %i2, %o0
4001bef8: 80 a2 60 0a cmp %o1, 0xa
4001befc: 38 80 00 11 bgu,a 4001bf40 <rtems_rfs_dir_read+0xd8> <== ALWAYS TAKEN
4001bf00: a2 07 bf b0 add %fp, -80, %l1
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
4001bf04: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001bf08: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001bf0c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001bf10: 40 00 48 8e call 4002e148 <__divdi3> <== NOT EXECUTED
4001bf14: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001bf18: 86 82 60 01 addcc %o1, 1, %g3 <== NOT EXECUTED
4001bf1c: 84 42 20 00 addx %o0, 0, %g2 <== NOT EXECUTED
4001bf20: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
4001bf24: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
4001bf28: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001bf2c: 40 00 48 43 call 4002e038 <__muldi3> <== NOT EXECUTED
4001bf30: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001bf34: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
4001bf38: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001bf3c: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
4001bf40: a4 07 bf a0 add %fp, -96, %l2
4001bf44: 90 10 00 18 mov %i0, %o0
4001bf48: 92 10 00 11 mov %l1, %o1
4001bf4c: 94 10 00 1a mov %i2, %o2
4001bf50: 96 10 00 1b mov %i3, %o3
4001bf54: 7f ff f8 2b call 4001a000 <rtems_rfs_block_map_seek>
4001bf58: 98 10 00 12 mov %l2, %o4
if (rc > 0)
4001bf5c: a0 92 20 00 orcc %o0, 0, %l0
4001bf60: 04 80 00 07 ble 4001bf7c <rtems_rfs_dir_read+0x114> <== ALWAYS TAKEN
4001bf64: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
4001bf68: 22 80 00 02 be,a 4001bf70 <rtems_rfs_dir_read+0x108> <== NOT EXECUTED
4001bf6c: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
4001bf70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bf74: 10 80 00 9f b 4001c1f0 <rtems_rfs_dir_read+0x388> <== NOT EXECUTED
4001bf78: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001bf7c: 2b 00 00 3f sethi %hi(0xfc00), %l5
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001bf80: 2d 10 00 d4 sethi %hi(0x40035000), %l6
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001bf84: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001bf88: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001bf8c: 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)
4001bf90: aa 15 63 ff or %l5, 0x3ff, %l5
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001bf94: ac 15 a0 50 or %l6, 0x50, %l6
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001bf98: ae 10 00 11 mov %l1, %l7
4001bf9c: a8 10 00 12 mov %l2, %l4
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001bfa0: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001bfa4: 90 10 00 18 mov %i0, %o0
4001bfa8: 92 07 bf a4 add %fp, -92, %o1
4001bfac: 7f ff fa d1 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001bfb0: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001bfb4: a0 92 20 00 orcc %o0, 0, %l0
4001bfb8: 04 80 00 04 ble 4001bfc8 <rtems_rfs_dir_read+0x160> <== ALWAYS TAKEN
4001bfbc: c2 07 bf ac ld [ %fp + -84 ], %g1
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001bfc0: 10 80 00 88 b 4001c1e0 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001bfc4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
4001bfc8: e6 07 bf c4 ld [ %fp + -60 ], %l3
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
4001bfcc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
entry += map.bpos.boff;
4001bfd0: a2 00 40 13 add %g1, %l3, %l1
elength = rtems_rfs_dir_entry_length (entry);
4001bfd4: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
4001bfd8: e4 0c 60 08 ldub [ %l1 + 8 ], %l2
eino = rtems_rfs_dir_entry_ino (entry);
4001bfdc: c8 08 40 13 ldub [ %g1 + %l3 ], %g4
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
4001bfe0: a5 2c a0 08 sll %l2, 8, %l2
eino = rtems_rfs_dir_entry_ino (entry);
4001bfe4: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
4001bfe8: a4 14 80 02 or %l2, %g2, %l2
eino = rtems_rfs_dir_entry_ino (entry);
4001bfec: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001bff0: 80 a4 80 15 cmp %l2, %l5
4001bff4: 02 80 00 5d be 4001c168 <rtems_rfs_dir_read+0x300>
4001bff8: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001bffc: a9 29 20 18 sll %g4, 0x18, %l4
4001c000: 86 08 e0 ff and %g3, 0xff, %g3
4001c004: 84 08 a0 ff and %g2, 0xff, %g2
4001c008: 87 28 e0 10 sll %g3, 0x10, %g3
4001c00c: 82 08 60 ff and %g1, 0xff, %g1
4001c010: a8 15 00 03 or %l4, %g3, %l4
4001c014: 83 28 60 08 sll %g1, 8, %g1
4001c018: a8 15 00 02 or %l4, %g2, %l4
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001c01c: 80 a4 a0 0a cmp %l2, 0xa
4001c020: 04 80 00 0d ble 4001c054 <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
4001c024: a8 15 00 01 or %l4, %g1, %l4
4001c028: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001c02c: 80 a4 80 01 cmp %l2, %g1
4001c030: 1a 80 00 0a bcc 4001c058 <rtems_rfs_dir_read+0x1f0> <== NEVER TAKEN
4001c034: 90 10 20 00 clr %o0
4001c038: 80 a5 20 00 cmp %l4, 0
4001c03c: 02 80 00 08 be 4001c05c <rtems_rfs_dir_read+0x1f4> <== NEVER TAKEN
4001c040: 13 20 00 00 sethi %hi(0x80000000), %o1
4001c044: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001c048: 80 a5 00 01 cmp %l4, %g1
4001c04c: 08 80 00 12 bleu 4001c094 <rtems_rfs_dir_read+0x22c> <== ALWAYS TAKEN
4001c050: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c054: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c058: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
4001c05c: 7f ff da cd call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001c060: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
4001c064: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c068: 22 80 00 5e be,a 4001c1e0 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001c06c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
4001c070: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c074: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001c078: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
4001c07c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001c080: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001c084: 40 00 15 89 call 400216a8 <printf> <== NOT EXECUTED
4001c088: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001c08c: 10 80 00 55 b 4001c1e0 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001c090: 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));
4001c094: 92 10 20 00 clr %o1
4001c098: 40 00 15 06 call 400214b0 <memset>
4001c09c: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
4001c0a0: 82 10 21 18 mov 0x118, %g1
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
4001c0a4: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
4001c0a8: c2 37 20 10 sth %g1, [ %i4 + 0x10 ]
*length += elength;
4001c0ac: c2 07 40 00 ld [ %i5 ], %g1
4001c0b0: 82 04 80 01 add %l2, %g1, %g1
4001c0b4: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001c0b8: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001c0bc: a6 20 80 13 sub %g2, %l3, %l3
4001c0c0: a6 24 c0 12 sub %l3, %l2, %l3
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
4001c0c4: 80 a4 e0 0a cmp %l3, 0xa
4001c0c8: 14 80 00 04 bg 4001c0d8 <rtems_rfs_dir_read+0x270> <== ALWAYS TAKEN
4001c0cc: a4 04 bf f6 add %l2, -10, %l2
*length += remaining;
4001c0d0: 82 04 c0 01 add %l3, %g1, %g1 <== NOT EXECUTED
4001c0d4: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
4001c0d8: 80 a4 a0 ff cmp %l2, 0xff
4001c0dc: 34 80 00 02 bg,a 4001c0e4 <rtems_rfs_dir_read+0x27c> <== NEVER TAKEN
4001c0e0: a4 10 20 ff mov 0xff, %l2 <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
4001c0e4: 92 04 60 0a add %l1, 0xa, %o1
4001c0e8: 94 10 00 12 mov %l2, %o2
4001c0ec: ba 07 20 14 add %i4, 0x14, %i5
4001c0f0: 40 00 14 61 call 40021274 <memcpy>
4001c0f4: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001c0f8: c4 0c 40 00 ldub [ %l1 ], %g2
4001c0fc: c2 0c 60 01 ldub [ %l1 + 1 ], %g1
4001c100: 85 28 a0 18 sll %g2, 0x18, %g2
4001c104: 83 28 60 10 sll %g1, 0x10, %g1
4001c108: 82 10 80 01 or %g2, %g1, %g1
4001c10c: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c110: 90 10 20 00 clr %o0
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001c114: 82 10 40 02 or %g1, %g2, %g1
4001c118: c4 0c 60 02 ldub [ %l1 + 2 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c11c: 13 20 00 00 sethi %hi(0x80000000), %o1
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001c120: 85 28 a0 08 sll %g2, 8, %g2
4001c124: 82 10 40 02 or %g1, %g2, %g1
dirent->d_namlen = elength;
4001c128: e4 37 20 12 sth %l2, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c12c: 7f ff da 99 call 40012b90 <rtems_rfs_trace>
4001c130: c2 27 00 00 st %g1, [ %i4 ]
4001c134: 80 8a 20 ff btst 0xff, %o0
4001c138: 22 80 00 2a be,a 4001c1e0 <rtems_rfs_dir_read+0x378> <== ALWAYS TAKEN
4001c13c: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001c140: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
4001c144: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001c148: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c14c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
4001c150: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
4001c154: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
4001c158: 40 00 15 54 call 400216a8 <printf> <== NOT EXECUTED
4001c15c: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001c160: 10 80 00 20 b 4001c1e0 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001c164: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
4001c168: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c16c: 90 10 20 00 clr %o0
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
4001c170: a6 20 40 13 sub %g1, %l3, %l3
4001c174: c2 07 40 00 ld [ %i5 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c178: 13 20 00 00 sethi %hi(0x80000000), %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
4001c17c: a6 00 40 13 add %g1, %l3, %l3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001c180: 7f ff da 84 call 40012b90 <rtems_rfs_trace>
4001c184: e6 27 40 00 st %l3, [ %i5 ]
4001c188: 80 8a 20 ff btst 0xff, %o0
4001c18c: 02 80 00 08 be 4001c1ac <rtems_rfs_dir_read+0x344> <== ALWAYS TAKEN
4001c190: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001c194: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001c198: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
4001c19c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c1a0: 40 00 15 42 call 400216a8 <printf> <== NOT EXECUTED
4001c1a4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c1a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c1ac: 92 10 00 17 mov %l7, %o1
4001c1b0: 7f ff f7 b1 call 4001a074 <rtems_rfs_block_map_next_block>
4001c1b4: 94 10 00 14 mov %l4, %o2
if (rc == ENXIO)
4001c1b8: 80 a2 20 06 cmp %o0, 6
4001c1bc: 02 80 00 07 be 4001c1d8 <rtems_rfs_dir_read+0x370> <== ALWAYS TAKEN
4001c1c0: 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)
4001c1c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c1c8: 02 bf ff 77 be 4001bfa4 <rtems_rfs_dir_read+0x13c> <== NOT EXECUTED
4001c1cc: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001c1d0: 10 80 00 04 b 4001c1e0 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001c1d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
4001c1d8: a0 10 20 02 mov 2, %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001c1dc: 92 07 bf a4 add %fp, -92, %o1
4001c1e0: 7f ff fb f9 call 4001b1c4 <rtems_rfs_buffer_handle_close>
4001c1e4: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001c1e8: 90 10 00 18 mov %i0, %o0
4001c1ec: 92 07 bf b0 add %fp, -80, %o1
4001c1f0: 7f ff f6 b4 call 40019cc0 <rtems_rfs_block_map_close>
4001c1f4: 01 00 00 00 nop
return rc;
}
4001c1f8: 81 c7 e0 08 ret
4001c1fc: 91 e8 00 10 restore %g0, %l0, %o0
4001c454 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
4001c454: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001c458: 90 10 20 10 mov 0x10, %o0
4001c45c: 7f ff d9 cd call 40012b90 <rtems_rfs_trace>
4001c460: 92 10 20 00 clr %o1
4001c464: 80 8a 20 ff btst 0xff, %o0
4001c468: 22 80 00 08 be,a 4001c488 <rtems_rfs_file_close+0x34> <== ALWAYS TAKEN
4001c46c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
4001c470: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
4001c474: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c478: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
4001c47c: 40 00 14 8b call 400216a8 <printf> <== NOT EXECUTED
4001c480: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
4001c484: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
4001c488: c2 02 60 08 ld [ %o1 + 8 ], %g1
4001c48c: 80 a0 60 00 cmp %g1, 0
4001c490: 04 80 00 03 ble 4001c49c <rtems_rfs_file_close+0x48> <== NEVER TAKEN
4001c494: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
4001c498: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
4001c49c: c2 02 60 08 ld [ %o1 + 8 ], %g1
4001c4a0: 80 a0 60 00 cmp %g1, 0
4001c4a4: 12 80 00 7e bne 4001c69c <rtems_rfs_file_close+0x248> <== NEVER TAKEN
4001c4a8: ba 10 20 00 clr %i5
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
4001c4ac: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001c4b0: 80 a0 60 00 cmp %g1, 0
4001c4b4: 32 80 00 09 bne,a 4001c4d8 <rtems_rfs_file_close+0x84> <== NEVER TAKEN
4001c4b8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
4001c4bc: 90 10 00 18 mov %i0, %o0
4001c4c0: 7f ff d2 fe call 400110b8 <rtems_rfs_inode_load>
4001c4c4: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
4001c4c8: ba 92 20 00 orcc %o0, 0, %i5
4001c4cc: 32 80 00 3f bne,a 4001c5c8 <rtems_rfs_file_close+0x174> <== NEVER TAKEN
4001c4d0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
4001c4d4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001c4d8: c4 00 60 8c ld [ %g1 + 0x8c ], %g2
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4001c4dc: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001c4e0: 89 30 a0 18 srl %g2, 0x18, %g4
4001c4e4: c8 28 e0 10 stb %g4, [ %g3 + 0x10 ]
4001c4e8: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001c4ec: 89 30 a0 10 srl %g2, 0x10, %g4
4001c4f0: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
4001c4f4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001c4f8: 89 30 a0 08 srl %g2, 8, %g4
4001c4fc: c8 28 e0 12 stb %g4, [ %g3 + 0x12 ]
4001c500: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001c504: c4 28 e0 13 stb %g2, [ %g3 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001c508: 86 10 20 01 mov 1, %g3
4001c50c: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
4001c510: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001c514: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001c518: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c51c: bb 30 a0 18 srl %g2, 0x18, %i5
4001c520: fa 29 20 14 stb %i5, [ %g4 + 0x14 ]
4001c524: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c528: bb 30 a0 10 srl %g2, 0x10, %i5
4001c52c: fa 29 20 15 stb %i5, [ %g4 + 0x15 ]
4001c530: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c534: bb 30 a0 08 srl %g2, 8, %i5
4001c538: fa 29 20 16 stb %i5, [ %g4 + 0x16 ]
4001c53c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c540: c4 29 20 17 stb %g2, [ %g4 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001c544: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
4001c548: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001c54c: c4 00 60 94 ld [ %g1 + 0x94 ], %g2
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4001c550: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c554: bb 30 a0 18 srl %g2, 0x18, %i5
4001c558: fa 29 20 18 stb %i5, [ %g4 + 0x18 ]
4001c55c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c560: bb 30 a0 10 srl %g2, 0x10, %i5
4001c564: fa 29 20 19 stb %i5, [ %g4 + 0x19 ]
4001c568: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c56c: bb 30 a0 08 srl %g2, 8, %i5
4001c570: fa 29 20 1a stb %i5, [ %g4 + 0x1a ]
4001c574: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001c578: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001c57c: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001c580: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001c584: c4 00 60 84 ld [ %g1 + 0x84 ], %g2
4001c588: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
4001c58c: 80 a0 80 03 cmp %g2, %g3
4001c590: 32 80 00 08 bne,a 4001c5b0 <rtems_rfs_file_close+0x15c> <== NEVER TAKEN
4001c594: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
4001c598: c8 00 60 88 ld [ %g1 + 0x88 ], %g4
4001c59c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
4001c5a0: 80 a1 00 03 cmp %g4, %g3
4001c5a4: 02 80 00 08 be 4001c5c4 <rtems_rfs_file_close+0x170> <== ALWAYS TAKEN
4001c5a8: ba 10 20 00 clr %i5
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
4001c5ac: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
4001c5b0: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 <== NOT EXECUTED
map->dirty = true;
4001c5b4: ba 10 20 00 clr %i5 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
4001c5b8: c4 20 60 40 st %g2, [ %g1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001c5bc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4001c5c0: c4 28 60 34 stb %g2, [ %g1 + 0x34 ] <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
4001c5c4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001c5c8: 90 10 00 18 mov %i0, %o0
4001c5cc: 7f ff f5 bd call 40019cc0 <rtems_rfs_block_map_close>
4001c5d0: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001c5d4: b8 92 20 00 orcc %o0, 0, %i4
4001c5d8: 04 80 00 14 ble 4001c628 <rtems_rfs_file_close+0x1d4> <== ALWAYS TAKEN
4001c5dc: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001c5e0: 7f ff d9 6c call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001c5e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001c5e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c5ec: 02 80 00 0d be 4001c620 <rtems_rfs_file_close+0x1cc> <== NOT EXECUTED
4001c5f0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
4001c5f4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
4001c5f8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001c5fc: 40 00 18 97 call 40022858 <strerror> <== NOT EXECUTED
4001c600: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001c604: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001c608: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c60c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001c610: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c614: 40 00 14 25 call 400216a8 <printf> <== NOT EXECUTED
4001c618: 90 12 21 18 or %o0, 0x118, %o0 ! 40035118 <CSWTCH.2+0xd68><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001c61c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4001c620: 22 80 00 02 be,a 4001c628 <rtems_rfs_file_close+0x1d4> <== NOT EXECUTED
4001c624: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001c628: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001c62c: 90 10 00 18 mov %i0, %o0
4001c630: 7f ff d3 41 call 40011334 <rtems_rfs_inode_close>
4001c634: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
4001c638: b8 92 20 00 orcc %o0, 0, %i4
4001c63c: 04 80 00 14 ble 4001c68c <rtems_rfs_file_close+0x238> <== ALWAYS TAKEN
4001c640: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001c644: 7f ff d9 53 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001c648: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001c64c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c650: 02 80 00 0d be 4001c684 <rtems_rfs_file_close+0x230> <== NOT EXECUTED
4001c654: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
4001c658: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
4001c65c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001c660: 40 00 18 7e call 40022858 <strerror> <== NOT EXECUTED
4001c664: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001c668: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001c66c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c670: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001c674: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c678: 40 00 14 0c call 400216a8 <printf> <== NOT EXECUTED
4001c67c: 90 12 21 58 or %o0, 0x158, %o0 ! 40035158 <CSWTCH.2+0xda8><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001c680: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4001c684: 22 80 00 02 be,a 4001c68c <rtems_rfs_file_close+0x238> <== NOT EXECUTED
4001c688: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4001c68c: 7f ff ec ac call 4001793c <_Chain_Extract>
4001c690: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
4001c694: 7f ff ac 2c call 40007744 <free>
4001c698: 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);
4001c69c: 90 10 00 18 mov %i0, %o0
4001c6a0: 7f ff f8 a0 call 4001a920 <rtems_rfs_buffer_handle_release>
4001c6a4: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
4001c6a8: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
4001c6ac: 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)
4001c6b0: 80 a7 60 00 cmp %i5, 0
4001c6b4: 04 80 00 0f ble 4001c6f0 <rtems_rfs_file_close+0x29c> <== ALWAYS TAKEN
4001c6b8: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001c6bc: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
4001c6c0: 7f ff d9 34 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001c6c4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001c6c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c6cc: 22 80 00 0a be,a 4001c6f4 <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
4001c6d0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001c6d4: 40 00 18 61 call 40022858 <strerror> <== NOT EXECUTED
4001c6d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c6dc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c6e0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001c6e4: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c6e8: 40 00 13 f0 call 400216a8 <printf> <== NOT EXECUTED
4001c6ec: 90 12 21 98 or %o0, 0x198, %o0 ! 40035198 <CSWTCH.2+0xde8><== NOT EXECUTED
}
free (handle);
4001c6f0: 90 10 00 19 mov %i1, %o0
4001c6f4: 7f ff ac 14 call 40007744 <free>
4001c6f8: b0 10 00 1d mov %i5, %i0
return rrc;
}
4001c6fc: 81 c7 e0 08 ret
4001c700: 81 e8 00 00 restore
4001c928 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
4001c928: 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))
4001c92c: 90 10 20 20 mov 0x20, %o0
4001c930: 92 10 20 00 clr %o1
4001c934: 7f ff d8 97 call 40012b90 <rtems_rfs_trace>
4001c938: ba 10 00 18 mov %i0, %i5
4001c93c: 80 8a 20 ff btst 0xff, %o0
4001c940: 22 80 00 0e be,a 4001c978 <rtems_rfs_file_io_end+0x50> <== ALWAYS TAKEN
4001c944: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001c948: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001c94c: 22 80 00 05 be,a 4001c960 <rtems_rfs_file_io_end+0x38> <== NOT EXECUTED
4001c950: 13 10 00 d4 sethi %hi(0x40035000), %o1 <== NOT EXECUTED
4001c954: 13 10 00 ce sethi %hi(0x40033800), %o1 <== NOT EXECUTED
4001c958: 10 80 00 03 b 4001c964 <rtems_rfs_file_io_end+0x3c> <== NOT EXECUTED
4001c95c: 92 12 62 90 or %o1, 0x290, %o1 ! 40033a90 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001c960: 92 12 61 c0 or %o1, 0x1c0, %o1 <== NOT EXECUTED
4001c964: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c968: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001c96c: 40 00 13 4f call 400216a8 <printf> <== NOT EXECUTED
4001c970: 90 12 22 80 or %o0, 0x280, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001c974: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001c978: 80 a0 60 00 cmp %g1, 0
4001c97c: 02 80 00 1e be 4001c9f4 <rtems_rfs_file_io_end+0xcc> <== NEVER TAKEN
4001c980: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
4001c984: 32 80 00 05 bne,a 4001c998 <rtems_rfs_file_io_end+0x70>
4001c988: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001c98c: 82 10 20 01 mov 1, %g1
4001c990: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001c994: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001c998: 92 07 60 04 add %i5, 4, %o1
4001c99c: 7f ff f7 e1 call 4001a920 <rtems_rfs_buffer_handle_release>
4001c9a0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001c9a4: b0 92 20 00 orcc %o0, 0, %i0
4001c9a8: 04 80 00 14 ble 4001c9f8 <rtems_rfs_file_io_end+0xd0> <== ALWAYS TAKEN
4001c9ac: 80 a6 a0 00 cmp %i2, 0
{
printf (
4001c9b0: 22 80 00 05 be,a 4001c9c4 <rtems_rfs_file_io_end+0x9c> <== NOT EXECUTED
4001c9b4: 3b 10 00 d4 sethi %hi(0x40035000), %i5 <== NOT EXECUTED
4001c9b8: 3b 10 00 ce sethi %hi(0x40033800), %i5 <== NOT EXECUTED
4001c9bc: 10 80 00 03 b 4001c9c8 <rtems_rfs_file_io_end+0xa0> <== NOT EXECUTED
4001c9c0: ba 17 62 90 or %i5, 0x290, %i5 ! 40033a90 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001c9c4: ba 17 61 c0 or %i5, 0x1c0, %i5 <== NOT EXECUTED
4001c9c8: 40 00 17 a4 call 40022858 <strerror> <== NOT EXECUTED
4001c9cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c9d0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c9d4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001c9d8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001c9dc: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c9e0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001c9e4: 40 00 13 31 call 400216a8 <printf> <== NOT EXECUTED
4001c9e8: 90 12 22 a8 or %o0, 0x2a8, %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;
4001c9ec: 81 c7 e0 08 ret <== NOT EXECUTED
4001c9f0: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
4001c9f4: b0 10 20 00 clr %i0 <== NOT EXECUTED
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
4001c9f8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001c9fc: b2 06 40 01 add %i1, %g1, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001ca00: 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;
4001ca04: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001ca08: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
4001ca0c: 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 >=
4001ca10: 80 a6 40 02 cmp %i1, %g2
4001ca14: 0a 80 00 07 bcs 4001ca30 <rtems_rfs_file_io_end+0x108>
4001ca18: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
4001ca1c: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001ca20: 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++;
4001ca24: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001ca28: 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++;
4001ca2c: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
4001ca30: 12 80 00 19 bne 4001ca94 <rtems_rfs_file_io_end+0x16c>
4001ca34: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001ca38: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
}
length = false;
mtime = false;
if (!read &&
4001ca3c: 80 a0 e0 00 cmp %g3, 0
4001ca40: 02 80 00 05 be 4001ca54 <rtems_rfs_file_io_end+0x12c>
4001ca44: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001ca48: 80 a0 a0 00 cmp %g2, 0
4001ca4c: 22 80 00 0f be,a 4001ca88 <rtems_rfs_file_io_end+0x160> <== NEVER TAKEN
4001ca50: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
4001ca54: 80 a0 c0 02 cmp %g3, %g2
4001ca58: 3a 80 00 0c bcc,a 4001ca88 <rtems_rfs_file_io_end+0x160>
4001ca5c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001ca60: 88 00 bf ff add %g2, -1, %g4
4001ca64: 80 a0 c0 04 cmp %g3, %g4
4001ca68: 12 80 00 0b bne 4001ca94 <rtems_rfs_file_io_end+0x16c>
4001ca6c: 84 10 20 00 clr %g2
4001ca70: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
4001ca74: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
4001ca78: 80 a1 00 03 cmp %g4, %g3
4001ca7c: 28 80 00 07 bleu,a 4001ca98 <rtems_rfs_file_io_end+0x170>
4001ca80: c2 07 40 00 ld [ %i5 ], %g1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
4001ca84: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001ca88: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
map->dirty = true;
4001ca8c: 84 10 20 01 mov 1, %g2
4001ca90: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001ca94: c2 07 40 00 ld [ %i5 ], %g1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001ca98: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001ca9c: a2 08 60 01 and %g1, 1, %l1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001caa0: 80 88 60 02 btst 2, %g1
4001caa4: a2 1c 60 01 xor %l1, 1, %l1
4001caa8: 12 80 00 03 bne 4001cab4 <rtems_rfs_file_io_end+0x18c> <== NEVER TAKEN
4001caac: a0 10 00 11 mov %l1, %l0
4001cab0: b8 08 a0 ff and %g2, 0xff, %i4
4001cab4: b2 0f 20 01 and %i4, 1, %i1
length = rtems_rfs_file_update_length (handle) && length;
4001cab8: 80 88 60 04 btst 4, %g1
4001cabc: 12 80 00 03 bne 4001cac8 <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
4001cac0: b6 10 20 00 clr %i3
4001cac4: b6 08 a0 ff and %g2, 0xff, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001cac8: 90 10 20 20 mov 0x20, %o0
4001cacc: 92 10 20 00 clr %o1
4001cad0: 7f ff d8 30 call 40012b90 <rtems_rfs_trace>
4001cad4: b6 0e e0 01 and %i3, 1, %i3
4001cad8: 80 8a 20 ff btst 0xff, %o0
4001cadc: 22 80 00 17 be,a 4001cb38 <rtems_rfs_file_io_end+0x210> <== ALWAYS TAKEN
4001cae0: b8 17 00 11 or %i4, %l1, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
4001cae4: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
4001cae8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4001caec: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
4001caf0: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
4001caf4: 82 0e 60 ff and %i1, 0xff, %g1 <== NOT EXECUTED
4001caf8: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
4001cafc: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4001cb00: 82 0e e0 ff and %i3, 0xff, %g1 <== NOT EXECUTED
4001cb04: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
4001cb08: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4001cb0c: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
4001cb10: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
4001cb14: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
4001cb18: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001cb1c: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
4001cb20: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
4001cb24: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
4001cb28: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
4001cb2c: 40 00 12 df call 400216a8 <printf> <== NOT EXECUTED
4001cb30: 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)
4001cb34: b8 17 00 11 or %i4, %l1, %i4 <== NOT EXECUTED
4001cb38: 80 8f 20 01 btst 1, %i4
4001cb3c: 02 80 00 13 be 4001cb88 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
4001cb40: 80 8e e0 ff btst 0xff, %i3
{
time_t now = time (NULL);
4001cb44: 40 00 23 3f call 40025840 <time>
4001cb48: 90 10 20 00 clr %o0
if (read && atime)
4001cb4c: 80 a6 a0 00 cmp %i2, 0
4001cb50: 02 80 00 07 be 4001cb6c <rtems_rfs_file_io_end+0x244>
4001cb54: 80 8e 60 ff btst 0xff, %i1
4001cb58: 80 8c 20 ff btst 0xff, %l0
4001cb5c: 02 80 00 04 be 4001cb6c <rtems_rfs_file_io_end+0x244> <== NEVER TAKEN
4001cb60: 80 8e 60 ff btst 0xff, %i1
handle->shared->atime = now;
4001cb64: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001cb68: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (!read && mtime)
4001cb6c: 02 80 00 07 be 4001cb88 <rtems_rfs_file_io_end+0x260>
4001cb70: 80 8e e0 ff btst 0xff, %i3
4001cb74: 80 a6 a0 01 cmp %i2, 1
4001cb78: 02 80 00 04 be 4001cb88 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
4001cb7c: 80 8e e0 ff btst 0xff, %i3
handle->shared->mtime = now;
4001cb80: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001cb84: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
}
if (length)
4001cb88: 02 80 00 07 be 4001cba4 <rtems_rfs_file_io_end+0x27c>
4001cb8c: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
4001cb90: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
4001cb94: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
4001cb98: c4 20 60 84 st %g2, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
4001cb9c: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
4001cba0: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
4001cba4: 81 c7 e0 08 ret
4001cba8: 81 e8 00 00 restore
4001cbac <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))
4001cbac: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4001cbb0: 80 a0 60 00 cmp %g1, 0
4001cbb4: 02 80 00 08 be 4001cbd4 <rtems_rfs_file_io_release+0x28> <== ALWAYS TAKEN
4001cbb8: 92 10 00 08 mov %o0, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001cbbc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
4001cbc0: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
4001cbc4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001cbc8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001cbcc: 7f ff f7 55 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001cbd0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
4001cbd4: 81 c3 e0 08 retl
4001cbd8: 90 10 20 00 clr %o0
4001c704 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
4001c704: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001c708: 90 10 20 20 mov 0x20, %o0
4001c70c: 92 10 20 00 clr %o1
4001c710: 7f ff d9 20 call 40012b90 <rtems_rfs_trace>
4001c714: ba 10 00 18 mov %i0, %i5
4001c718: 80 8a 20 ff btst 0xff, %o0
4001c71c: 22 80 00 0f be,a 4001c758 <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
4001c720: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001c724: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001c728: 22 80 00 05 be,a 4001c73c <rtems_rfs_file_io_start+0x38> <== NOT EXECUTED
4001c72c: 13 10 00 d4 sethi %hi(0x40035000), %o1 <== NOT EXECUTED
4001c730: 13 10 00 ce sethi %hi(0x40033800), %o1 <== NOT EXECUTED
4001c734: 10 80 00 03 b 4001c740 <rtems_rfs_file_io_start+0x3c> <== NOT EXECUTED
4001c738: 92 12 62 90 or %o1, 0x290, %o1 ! 40033a90 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001c73c: 92 12 61 c0 or %o1, 0x1c0, %o1 <== NOT EXECUTED
4001c740: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
4001c744: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
4001c748: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c74c: 40 00 13 d7 call 400216a8 <printf> <== NOT EXECUTED
4001c750: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 400351c8 <CSWTCH.2+0xe18><== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001c754: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001c758: 80 a0 60 00 cmp %g1, 0
4001c75c: 12 80 00 4f bne 4001c898 <rtems_rfs_file_io_start+0x194>
4001c760: 80 a6 a0 00 cmp %i2, 0
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001c764: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001c768: 94 07 60 10 add %i5, 0x10, %o2
4001c76c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001c770: 96 07 bf fc add %fp, -4, %o3
4001c774: 7f ff f5 c7 call 40019e90 <rtems_rfs_block_map_find>
4001c778: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001c77c: b0 92 20 00 orcc %o0, 0, %i0
4001c780: 04 80 00 1e ble 4001c7f8 <rtems_rfs_file_io_start+0xf4>
4001c784: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
4001c788: 32 80 00 66 bne,a 4001c920 <rtems_rfs_file_io_start+0x21c><== NEVER TAKEN
4001c78c: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
4001c790: 80 a6 a0 00 cmp %i2, 0
4001c794: 22 80 00 05 be,a 4001c7a8 <rtems_rfs_file_io_start+0xa4> <== ALWAYS TAKEN
4001c798: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
4001c79c: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
4001c7a0: 81 c7 e0 08 ret <== NOT EXECUTED
4001c7a4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if (rc != ENXIO)
4001c7a8: 12 80 00 5e bne 4001c920 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
4001c7ac: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001c7b0: 7f ff d8 f8 call 40012b90 <rtems_rfs_trace>
4001c7b4: 92 10 20 00 clr %o1
4001c7b8: 80 8a 20 ff btst 0xff, %o0
4001c7bc: 22 80 00 06 be,a 4001c7d4 <rtems_rfs_file_io_start+0xd0> <== ALWAYS TAKEN
4001c7c0: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-io: start: grow\n");
4001c7c4: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c7c8: 40 00 14 50 call 40021908 <puts> <== NOT EXECUTED
4001c7cc: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400351f8 <CSWTCH.2+0xe48><== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001c7d0: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
4001c7d4: 94 10 20 01 mov 1, %o2
4001c7d8: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001c7dc: 96 07 bf fc add %fp, -4, %o3
4001c7e0: 7f ff f6 32 call 4001a0a8 <rtems_rfs_block_map_grow>
4001c7e4: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
4001c7e8: b0 92 20 00 orcc %o0, 0, %i0
4001c7ec: 14 80 00 4d bg 4001c920 <rtems_rfs_file_io_start+0x21c>
4001c7f0: b8 10 20 00 clr %i4
4001c7f4: 30 80 00 0f b,a 4001c830 <rtems_rfs_file_io_start+0x12c>
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
4001c7f8: 80 a6 a0 00 cmp %i2, 0
4001c7fc: 12 80 00 0d bne 4001c830 <rtems_rfs_file_io_start+0x12c>
4001c800: b8 10 00 1a mov %i2, %i4
4001c804: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001c808: 80 a0 60 00 cmp %g1, 0
4001c80c: 12 80 00 09 bne 4001c830 <rtems_rfs_file_io_start+0x12c>
4001c810: b8 10 20 01 mov 1, %i4
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001c814: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
4001c818: c4 06 40 00 ld [ %i1 ], %g2
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001c81c: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
4001c820: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001c824: 80 a0 80 01 cmp %g2, %g1
4001c828: 3a 80 00 02 bcc,a 4001c830 <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
4001c82c: b8 10 20 00 clr %i4 <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001c830: 90 10 20 20 mov 0x20, %o0
4001c834: 7f ff d8 d7 call 40012b90 <rtems_rfs_trace>
4001c838: 92 10 20 00 clr %o1
4001c83c: 80 8a 20 ff btst 0xff, %o0
4001c840: 22 80 00 0e be,a 4001c878 <rtems_rfs_file_io_start+0x174><== ALWAYS TAKEN
4001c844: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001c848: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4001c84c: 02 80 00 05 be 4001c860 <rtems_rfs_file_io_start+0x15c> <== NOT EXECUTED
4001c850: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
4001c854: 15 10 00 cd sethi %hi(0x40033400), %o2 <== NOT EXECUTED
4001c858: 10 80 00 04 b 4001c868 <rtems_rfs_file_io_start+0x164> <== NOT EXECUTED
4001c85c: 94 12 a1 10 or %o2, 0x110, %o2 ! 40033510 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
4001c860: 15 10 00 c6 sethi %hi(0x40031800), %o2 <== NOT EXECUTED
4001c864: 94 12 a2 f8 or %o2, 0x2f8, %o2 ! 40031af8 <__FUNCTION__.6193+0x2f0><== NOT EXECUTED
4001c868: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001c86c: 40 00 13 8f call 400216a8 <printf> <== NOT EXECUTED
4001c870: 90 12 22 18 or %o0, 0x218, %o0 ! 40035218 <CSWTCH.2+0xe68><== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001c874: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001c878: d4 07 bf fc ld [ %fp + -4 ], %o2
4001c87c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001c880: 92 07 60 04 add %i5, 4, %o1
4001c884: 7f ff f8 9b call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001c888: 96 0f 20 ff and %i4, 0xff, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
4001c88c: b0 92 20 00 orcc %o0, 0, %i0
4001c890: 14 80 00 24 bg 4001c920 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
4001c894: 80 a6 a0 00 cmp %i2, 0
return rc;
}
if (read
4001c898: 02 80 00 12 be 4001c8e0 <rtems_rfs_file_io_start+0x1dc>
4001c89c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001c8a0: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
4001c8a4: 80 a0 a0 00 cmp %g2, 0
4001c8a8: 12 80 00 05 bne 4001c8bc <rtems_rfs_file_io_start+0x1b8>
4001c8ac: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
4001c8b0: 80 a0 e0 00 cmp %g3, 0
4001c8b4: 22 80 00 07 be,a 4001c8d0 <rtems_rfs_file_io_start+0x1cc><== NEVER TAKEN
4001c8b8: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
4001c8bc: 86 00 ff ff add %g3, -1, %g3
4001c8c0: 80 a0 80 03 cmp %g2, %g3
4001c8c4: 32 80 00 07 bne,a 4001c8e0 <rtems_rfs_file_io_start+0x1dc>
4001c8c8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001c8cc: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
4001c8d0: 80 a7 20 00 cmp %i4, 0
4001c8d4: 32 80 00 06 bne,a 4001c8ec <rtems_rfs_file_io_start+0x1e8>
4001c8d8: 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));
4001c8dc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001c8e0: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
4001c8e4: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
4001c8e8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001c8ec: 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);
4001c8f0: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001c8f4: 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);
4001c8f8: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001c8fc: 7f ff d8 a5 call 40012b90 <rtems_rfs_trace>
4001c900: b0 10 20 00 clr %i0
4001c904: 80 8a 20 ff btst 0xff, %o0
4001c908: 02 80 00 06 be 4001c920 <rtems_rfs_file_io_start+0x21c> <== ALWAYS TAKEN
4001c90c: 11 10 00 d4 sethi %hi(0x40035000), %o0
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
4001c910: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001c914: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001c918: 40 00 13 64 call 400216a8 <printf> <== NOT EXECUTED
4001c91c: 90 12 22 50 or %o0, 0x250, %o0 <== NOT EXECUTED
*available, size);
return 0;
}
4001c920: 81 c7 e0 08 ret
4001c924: 81 e8 00 00 restore
4001d034 <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)
{
4001d034: 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))
4001d038: 90 10 20 08 mov 8, %o0
4001d03c: 7f ff d6 d5 call 40012b90 <rtems_rfs_trace>
4001d040: 92 10 20 00 clr %o1
4001d044: 80 8a 20 ff btst 0xff, %o0
4001d048: 22 80 00 07 be,a 4001d064 <rtems_rfs_file_open+0x30> <== ALWAYS TAKEN
4001d04c: c0 26 c0 00 clr [ %i3 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
4001d050: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001d054: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001d058: 40 00 11 94 call 400216a8 <printf> <== NOT EXECUTED
4001d05c: 90 12 23 70 or %o0, 0x370, %o0 <== NOT EXECUTED
*file = NULL;
4001d060: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
4001d064: 90 10 20 20 mov 0x20, %o0
4001d068: 7f ff ab 48 call 40007d88 <malloc>
4001d06c: a0 10 20 0c mov 0xc, %l0
if (!handle)
4001d070: 80 a2 20 00 cmp %o0, 0
4001d074: 02 80 00 a4 be 4001d304 <rtems_rfs_file_open+0x2d0> <== NEVER TAKEN
4001d078: ba 10 00 08 mov %o0, %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
4001d07c: 92 10 20 00 clr %o1
4001d080: 40 00 11 0c call 400214b0 <memset>
4001d084: 94 10 20 20 mov 0x20, %o2
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
4001d088: 90 10 00 18 mov %i0, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001d08c: c0 2f 60 04 clrb [ %i5 + 4 ]
handle->bnum = 0;
4001d090: c0 27 60 08 clr [ %i5 + 8 ]
handle->buffer = NULL;
4001d094: c0 27 60 0c clr [ %i5 + 0xc ]
4001d098: 7f ff ff d9 call 4001cffc <rtems_rfs_file_get_shared>
4001d09c: 92 10 00 19 mov %i1, %o1
if (shared)
4001d0a0: b8 92 20 00 orcc %o0, 0, %i4
4001d0a4: 02 80 00 0d be 4001d0d8 <rtems_rfs_file_open+0xa4> <== ALWAYS TAKEN
4001d0a8: 90 10 20 08 mov 8, %o0
{
shared->references++;
4001d0ac: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
4001d0b0: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001d0b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d0b8: 7f ff d6 b6 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d0bc: c2 27 20 08 st %g1, [ %i4 + 8 ] <== NOT EXECUTED
4001d0c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d0c4: 22 80 00 8d be,a 4001d2f8 <rtems_rfs_file_open+0x2c4> <== NOT EXECUTED
4001d0c8: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001d0cc: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001d0d0: 10 80 00 87 b 4001d2ec <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
4001d0d4: 90 12 23 90 or %o0, 0x390, %o0 ! 40035390 <CSWTCH.2+0xfe0><== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
4001d0d8: 7f ff ab 2c call 40007d88 <malloc>
4001d0dc: 90 10 20 9c mov 0x9c, %o0
if (!shared)
4001d0e0: b8 92 20 00 orcc %o0, 0, %i4
4001d0e4: 12 80 00 04 bne 4001d0f4 <rtems_rfs_file_open+0xc0> <== ALWAYS TAKEN
4001d0e8: 92 10 20 00 clr %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001d0ec: 10 80 00 34 b 4001d1bc <rtems_rfs_file_open+0x188> <== NOT EXECUTED
4001d0f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
4001d0f4: 40 00 10 ef call 400214b0 <memset>
4001d0f8: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4001d0fc: a2 07 20 0c add %i4, 0xc, %l1
4001d100: 90 10 00 18 mov %i0, %o0
4001d104: 92 10 00 19 mov %i1, %o1
4001d108: 94 10 00 11 mov %l1, %o2
4001d10c: 7f ff d0 18 call 4001116c <rtems_rfs_inode_open>
4001d110: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001d114: a0 92 20 00 orcc %o0, 0, %l0
4001d118: 04 80 00 0f ble 4001d154 <rtems_rfs_file_open+0x120> <== ALWAYS TAKEN
4001d11c: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001d120: 7f ff d6 9c call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d124: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d128: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d12c: 02 80 00 21 be 4001d1b0 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
4001d130: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
4001d134: 40 00 15 c9 call 40022858 <strerror> <== NOT EXECUTED
4001d138: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001d13c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001d140: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d144: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001d148: 40 00 11 58 call 400216a8 <printf> <== NOT EXECUTED
4001d14c: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 400353b8 <CSWTCH.2+0x1008><== NOT EXECUTED
4001d150: 30 80 00 18 b,a 4001d1b0 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
4001d154: 90 10 00 18 mov %i0, %o0
4001d158: 92 10 00 11 mov %l1, %o1
4001d15c: 7f ff f2 78 call 40019b3c <rtems_rfs_block_map_open>
4001d160: 94 07 20 34 add %i4, 0x34, %o2
if (rc > 0)
4001d164: a0 92 20 00 orcc %o0, 0, %l0
4001d168: 04 80 00 1e ble 4001d1e0 <rtems_rfs_file_open+0x1ac> <== ALWAYS TAKEN
4001d16c: 82 10 20 01 mov 1, %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001d170: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
4001d174: 7f ff d6 87 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d178: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d17c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d180: 22 80 00 0a be,a 4001d1a8 <rtems_rfs_file_open+0x174> <== NOT EXECUTED
4001d184: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001d188: 40 00 15 b4 call 40022858 <strerror> <== NOT EXECUTED
4001d18c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001d190: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001d194: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d198: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001d19c: 40 00 11 43 call 400216a8 <printf> <== NOT EXECUTED
4001d1a0: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 400353f0 <CSWTCH.2+0x1040><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
4001d1a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d1a8: 7f ff d0 63 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001d1ac: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
free (shared);
4001d1b0: 7f ff a9 65 call 40007744 <free> <== NOT EXECUTED
4001d1b4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001d1b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d1bc: 7f ff f5 d9 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d1c0: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
4001d1c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001d1c8: c0 2f 60 04 clrb [ %i5 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001d1cc: c0 27 60 08 clr [ %i5 + 8 ] <== NOT EXECUTED
4001d1d0: 7f ff a9 5d call 40007744 <free> <== NOT EXECUTED
4001d1d4: c0 27 60 0c clr [ %i5 + 0xc ] <== NOT EXECUTED
return rc;
4001d1d8: 81 c7 e0 08 ret <== NOT EXECUTED
4001d1dc: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
shared->references = 1;
4001d1e0: c2 27 20 08 st %g1, [ %i4 + 8 ]
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4001d1e4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4001d1e8: 90 06 20 74 add %i0, 0x74, %o0
4001d1ec: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
4001d1f0: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
4001d1f4: 87 28 e0 18 sll %g3, 0x18, %g3
4001d1f8: 85 28 a0 10 sll %g2, 0x10, %g2
4001d1fc: 84 10 c0 02 or %g3, %g2, %g2
4001d200: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
4001d204: 92 10 00 1c mov %i4, %o1
4001d208: 84 10 80 03 or %g2, %g3, %g2
4001d20c: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
4001d210: 87 28 e0 08 sll %g3, 8, %g3
4001d214: 84 10 80 03 or %g2, %g3, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001d218: c4 27 20 84 st %g2, [ %i4 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001d21c: 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);
4001d220: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001d224: 85 28 a0 08 sll %g2, 8, %g2
4001d228: 84 10 c0 02 or %g3, %g2, %g2
4001d22c: c4 27 20 88 st %g2, [ %i4 + 0x88 ]
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4001d230: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
4001d234: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
4001d238: 87 28 e0 18 sll %g3, 0x18, %g3
4001d23c: 85 28 a0 10 sll %g2, 0x10, %g2
4001d240: 84 10 c0 02 or %g3, %g2, %g2
4001d244: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
4001d248: 84 10 80 03 or %g2, %g3, %g2
4001d24c: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
4001d250: 87 28 e0 08 sll %g3, 8, %g3
4001d254: 84 10 80 03 or %g2, %g3, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001d258: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4001d25c: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
4001d260: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
4001d264: 87 28 e0 18 sll %g3, 0x18, %g3
4001d268: 85 28 a0 10 sll %g2, 0x10, %g2
4001d26c: 84 10 c0 02 or %g3, %g2, %g2
4001d270: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
4001d274: 84 10 80 03 or %g2, %g3, %g2
4001d278: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
4001d27c: 87 28 e0 08 sll %g3, 8, %g3
4001d280: 84 10 80 03 or %g2, %g3, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
4001d284: c4 27 20 90 st %g2, [ %i4 + 0x90 ]
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4001d288: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
4001d28c: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
4001d290: 85 28 a0 10 sll %g2, 0x10, %g2
4001d294: 87 28 e0 18 sll %g3, 0x18, %g3
4001d298: 86 10 c0 02 or %g3, %g2, %g3
4001d29c: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
4001d2a0: 86 10 c0 02 or %g3, %g2, %g3
4001d2a4: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
4001d2a8: f0 27 20 98 st %i0, [ %i4 + 0x98 ]
4001d2ac: 85 28 a0 08 sll %g2, 8, %g2
4001d2b0: 82 10 c0 02 or %g3, %g2, %g1
4001d2b4: 7f ff be 3b call 4000cba0 <_Chain_Append>
4001d2b8: c2 27 20 94 st %g1, [ %i4 + 0x94 ]
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001d2bc: 92 10 00 11 mov %l1, %o1
4001d2c0: 94 10 20 00 clr %o2
4001d2c4: 7f ff cf e0 call 40011244 <rtems_rfs_inode_unload>
4001d2c8: 90 10 00 18 mov %i0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001d2cc: 90 10 20 08 mov 8, %o0
4001d2d0: 7f ff d6 30 call 40012b90 <rtems_rfs_trace>
4001d2d4: 92 10 20 00 clr %o1
4001d2d8: 80 8a 20 ff btst 0xff, %o0
4001d2dc: 22 80 00 07 be,a 4001d2f8 <rtems_rfs_file_open+0x2c4> <== ALWAYS TAKEN
4001d2e0: f4 27 40 00 st %i2, [ %i5 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001d2e4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d2e8: 90 12 20 28 or %o0, 0x28, %o0 ! 40035428 <CSWTCH.2+0x1078><== NOT EXECUTED
4001d2ec: 40 00 10 ef call 400216a8 <printf> <== NOT EXECUTED
4001d2f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
handle->flags = oflag;
4001d2f4: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
handle->shared = shared;
4001d2f8: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
*file = handle;
4001d2fc: fa 26 c0 00 st %i5, [ %i3 ]
return 0;
4001d300: a0 10 20 00 clr %l0
}
4001d304: b0 10 00 10 mov %l0, %i0
4001d308: 81 c7 e0 08 ret
4001d30c: 81 e8 00 00 restore
4001cbdc <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
4001cbdc: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001cbe0: 90 10 20 20 mov 0x20, %o0
4001cbe4: 7f ff d7 eb call 40012b90 <rtems_rfs_trace>
4001cbe8: 92 10 20 00 clr %o1
4001cbec: 80 8a 20 ff btst 0xff, %o0
4001cbf0: 22 80 00 08 be,a 4001cc10 <rtems_rfs_file_seek+0x34> <== ALWAYS TAKEN
4001cbf4: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
4001cbf8: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001cbfc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001cc00: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
4001cc04: 40 00 12 a9 call 400216a8 <printf> <== NOT EXECUTED
4001cc08: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001cc0c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
4001cc10: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001cc14: 7f ff f3 b2 call 40019adc <rtems_rfs_block_get_size>
4001cc18: 92 02 60 84 add %o1, 0x84, %o1
4001cc1c: 80 a6 40 08 cmp %i1, %o0
4001cc20: 18 80 00 23 bgu 4001ccac <rtems_rfs_file_seek+0xd0> <== NEVER TAKEN
4001cc24: 01 00 00 00 nop
4001cc28: 32 80 00 06 bne,a 4001cc40 <rtems_rfs_file_seek+0x64> <== NEVER TAKEN
4001cc2c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
4001cc30: 80 a6 80 09 cmp %i2, %o1
4001cc34: 18 80 00 1e bgu 4001ccac <rtems_rfs_file_seek+0xd0>
4001cc38: 01 00 00 00 nop
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
4001cc3c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001cc40: b8 06 20 10 add %i0, 0x10, %i4
4001cc44: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001cc48: 92 10 00 19 mov %i1, %o1
4001cc4c: 94 10 00 1a mov %i2, %o2
4001cc50: 7f ff f3 73 call 40019a1c <rtems_rfs_block_get_bpos>
4001cc54: 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))
4001cc58: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001cc5c: 80 a0 60 00 cmp %g1, 0
4001cc60: 02 80 00 18 be 4001ccc0 <rtems_rfs_file_seek+0xe4>
4001cc64: 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),
4001cc68: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
4001cc6c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001cc70: 96 07 bf fc add %fp, -4, %o3
4001cc74: 7f ff f4 87 call 40019e90 <rtems_rfs_block_map_find>
4001cc78: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001cc7c: 80 a2 20 00 cmp %o0, 0
4001cc80: 14 80 00 13 bg 4001cccc <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
4001cc84: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
4001cc88: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001cc8c: 80 a0 80 01 cmp %g2, %g1
4001cc90: 02 80 00 0c be 4001ccc0 <rtems_rfs_file_seek+0xe4> <== ALWAYS TAKEN
4001cc94: 92 06 20 04 add %i0, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001cc98: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
4001cc9c: 7f ff f7 21 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001cca0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
if (rc > 0)
4001cca4: 10 80 00 05 b 4001ccb8 <rtems_rfs_file_seek+0xdc> <== NOT EXECUTED
4001cca8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
{
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
4001ccac: 7f ff ff c0 call 4001cbac <rtems_rfs_file_io_release>
4001ccb0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001ccb4: 80 a2 20 00 cmp %o0, 0
4001ccb8: 14 80 00 05 bg 4001cccc <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
4001ccbc: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
4001ccc0: f2 26 c0 00 st %i1, [ %i3 ]
4001ccc4: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
4001ccc8: 90 10 20 00 clr %o0
}
4001cccc: 81 c7 e0 08 ret
4001ccd0: 91 e8 00 08 restore %g0, %o0, %o0
4001ccd4 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4001ccd4: 9d e3 bf 90 save %sp, -112, %sp
4001ccd8: ba 10 00 1a mov %i2, %i5
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001ccdc: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4001cce0: b6 10 00 18 mov %i0, %i3
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001cce4: 90 10 20 20 mov 0x20, %o0
4001cce8: 92 10 20 00 clr %o1
4001ccec: 7f ff d7 a9 call 40012b90 <rtems_rfs_trace>
4001ccf0: b8 10 00 19 mov %i1, %i4
4001ccf4: 80 8a 20 ff btst 0xff, %o0
4001ccf8: 02 80 00 07 be 4001cd14 <rtems_rfs_file_set_size+0x40> <== ALWAYS TAKEN
4001ccfc: b0 06 a0 34 add %i2, 0x34, %i0
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
4001cd00: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
4001cd04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001cd08: 90 12 23 48 or %o0, 0x348, %o0 <== NOT EXECUTED
4001cd0c: 40 00 12 67 call 400216a8 <printf> <== NOT EXECUTED
4001cd10: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
4001cd14: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
4001cd18: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001cd1c: 7f ff f3 70 call 40019adc <rtems_rfs_block_get_size>
4001cd20: 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)
4001cd24: 80 a2 00 1c cmp %o0, %i4
4001cd28: 12 80 00 07 bne 4001cd44 <rtems_rfs_file_set_size+0x70> <== NEVER TAKEN
4001cd2c: 80 97 00 1d orcc %i4, %i5, %g0
4001cd30: 80 a2 40 1d cmp %o1, %i5
4001cd34: 12 80 00 04 bne 4001cd44 <rtems_rfs_file_set_size+0x70>
4001cd38: 80 97 00 1d orcc %i4, %i5, %g0
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
4001cd3c: 10 80 00 ad b 4001cff0 <rtems_rfs_file_set_size+0x31c>
4001cd40: 90 10 20 00 clr %o0
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
4001cd44: 12 80 00 0a bne 4001cd6c <rtems_rfs_file_set_size+0x98>
4001cd48: f2 06 e0 1c ld [ %i3 + 0x1c ], %i1
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001cd4c: d0 06 60 98 ld [ %i1 + 0x98 ], %o0
4001cd50: 7f ff f6 90 call 4001a790 <rtems_rfs_block_map_free_all>
4001cd54: 92 10 00 18 mov %i0, %o1
if (rc > 0)
4001cd58: 80 a2 20 00 cmp %o0, 0
4001cd5c: 14 80 00 a6 bg 4001cff4 <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
4001cd60: b0 10 00 08 mov %o0, %i0
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001cd64: 10 80 00 97 b 4001cfc0 <rtems_rfs_file_set_size+0x2ec>
4001cd68: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
4001cd6c: 80 a7 00 08 cmp %i4, %o0
4001cd70: 38 80 00 09 bgu,a 4001cd94 <rtems_rfs_file_set_size+0xc0><== NEVER TAKEN
4001cd74: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 <== NOT EXECUTED
4001cd78: 80 a7 00 08 cmp %i4, %o0
4001cd7c: 32 80 00 58 bne,a 4001cedc <rtems_rfs_file_set_size+0x208><== NEVER TAKEN
4001cd80: e0 06 60 98 ld [ %i1 + 0x98 ], %l0 <== NOT EXECUTED
4001cd84: 80 a7 40 09 cmp %i5, %o1
4001cd88: 28 80 00 55 bleu,a 4001cedc <rtems_rfs_file_set_size+0x208>
4001cd8c: e0 06 60 98 ld [ %i1 + 0x98 ], %l0
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001cd90: c2 06 60 98 ld [ %i1 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
4001cd94: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001cd98: f2 00 60 08 ld [ %g1 + 8 ], %i1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
4001cd9c: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
4001cda0: a2 10 20 00 clr %l1
4001cda4: a0 10 20 01 mov 1, %l0
while (count)
4001cda8: 10 80 00 48 b 4001cec8 <rtems_rfs_file_set_size+0x1f4>
4001cdac: a4 06 e0 04 add %i3, 4, %l2
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
4001cdb0: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001cdb4: c4 27 bf f8 st %g2, [ %fp + -8 ]
4001cdb8: c2 27 bf f4 st %g1, [ %fp + -12 ]
4001cdbc: 80 a0 a0 00 cmp %g2, 0
4001cdc0: 02 80 00 04 be 4001cdd0 <rtems_rfs_file_set_size+0xfc>
4001cdc4: c0 27 bf fc clr [ %fp + -4 ]
4001cdc8: 82 00 7f ff add %g1, -1, %g1
4001cdcc: c2 27 bf f4 st %g1, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001cdd0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001cdd4: 92 10 00 18 mov %i0, %o1
4001cdd8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001cddc: 94 07 bf f4 add %fp, -12, %o2
4001cde0: 7f ff f4 2c call 40019e90 <rtems_rfs_block_map_find>
4001cde4: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
4001cde8: 80 a2 20 00 cmp %o0, 0
4001cdec: 14 80 00 0b bg 4001ce18 <rtems_rfs_file_set_size+0x144>
4001cdf0: 80 a2 20 06 cmp %o0, 6
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
4001cdf4: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001cdf8: 80 a7 20 00 cmp %i4, 0
4001cdfc: 12 80 00 17 bne 4001ce58 <rtems_rfs_file_set_size+0x184> <== NEVER TAKEN
4001ce00: 84 26 40 01 sub %i1, %g1, %g2
4001ce04: 80 a0 80 1d cmp %g2, %i5
4001ce08: 38 80 00 10 bgu,a 4001ce48 <rtems_rfs_file_set_size+0x174>
4001ce0c: b2 00 40 1d add %g1, %i5, %i1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
4001ce10: 10 80 00 13 b 4001ce5c <rtems_rfs_file_set_size+0x188>
4001ce14: c0 26 a0 40 clr [ %i2 + 0x40 ]
if (rc > 0)
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
4001ce18: 12 80 00 76 bne 4001cff0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001ce1c: 92 10 00 18 mov %i0, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001ce20: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001ce24: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ce28: 94 10 20 01 mov 1, %o2
4001ce2c: 7f ff f4 9f call 4001a0a8 <rtems_rfs_block_map_grow>
4001ce30: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
4001ce34: 80 a2 20 00 cmp %o0, 0
4001ce38: 04 bf ff f0 ble 4001cdf8 <rtems_rfs_file_set_size+0x124> <== ALWAYS TAKEN
4001ce3c: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
}
4001ce40: 81 c7 e0 08 ret <== NOT EXECUTED
4001ce44: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
map->dirty = true;
4001ce48: e0 2e a0 34 stb %l0, [ %i2 + 0x34 ]
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
4001ce4c: f2 26 a0 40 st %i1, [ %i2 + 0x40 ]
}
if (count < (length - bpos.boff))
{
length = count + bpos.boff;
read_block = true;
4001ce50: 10 80 00 04 b 4001ce60 <rtems_rfs_file_set_size+0x18c>
4001ce54: a2 10 20 01 mov 1, %l1
4001ce58: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001ce5c: e0 2e a0 34 stb %l0, [ %i2 + 0x34 ]
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001ce60: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001ce64: d4 07 bf f0 ld [ %fp + -16 ], %o2
4001ce68: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ce6c: 92 10 00 12 mov %l2, %o1
4001ce70: 7f ff f7 20 call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001ce74: 96 0c 60 01 and %l1, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
4001ce78: 80 a2 20 00 cmp %o0, 0
4001ce7c: 14 80 00 5d bg 4001cff0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001ce80: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
4001ce84: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
memset (dst + bpos.boff, 0, length - bpos.boff);
4001ce88: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001ce8c: 92 10 20 00 clr %o1
4001ce90: 90 02 00 0a add %o0, %o2, %o0
4001ce94: 40 00 11 87 call 400214b0 <memset>
4001ce98: 94 26 40 0a sub %i1, %o2, %o2
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ce9c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001cea0: e0 2e e0 04 stb %l0, [ %i3 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001cea4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001cea8: 7f ff f6 9e call 4001a920 <rtems_rfs_buffer_handle_release>
4001ceac: 92 10 00 12 mov %l2, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001ceb0: 80 a2 20 00 cmp %o0, 0
4001ceb4: 14 80 00 4f bg 4001cff0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001ceb8: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
count -= length - bpos.boff;
4001cebc: 82 26 40 01 sub %i1, %g1, %g1
4001cec0: ba a7 40 01 subcc %i5, %g1, %i5
4001cec4: 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)
4001cec8: 80 97 00 1d orcc %i4, %i5, %g0
4001cecc: 32 bf ff b9 bne,a 4001cdb0 <rtems_rfs_file_set_size+0xdc>
4001ced0: c4 06 a0 40 ld [ %i2 + 0x40 ], %g2
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001ced4: 10 80 00 3b b 4001cfc0 <rtems_rfs_file_set_size+0x2ec>
4001ced8: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
4001cedc: 92 87 7f ff addcc %i5, -1, %o1
4001cee0: e2 04 20 08 ld [ %l0 + 8 ], %l1
4001cee4: 90 47 3f ff addx %i4, -1, %o0
4001cee8: 94 10 20 00 clr %o2
4001ceec: 40 00 46 76 call 4002e8c4 <__udivdi3>
4001cef0: 96 10 00 11 mov %l1, %o3
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4001cef4: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001cef8: 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));
4001cefc: 90 10 00 1c mov %i4, %o0
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4001cf00: b0 02 40 01 add %o1, %g1, %i0
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001cf04: 94 10 20 00 clr %o2
4001cf08: 92 10 00 1d mov %i5, %o1
4001cf0c: 40 00 47 42 call 4002ec14 <__umoddi3>
4001cf10: 96 10 00 11 mov %l1, %o3
if (blocks)
4001cf14: 80 a6 20 00 cmp %i0, 0
4001cf18: 12 80 00 0b bne 4001cf44 <rtems_rfs_file_set_size+0x270>
4001cf1c: 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),
4001cf20: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
4001cf24: 82 10 20 01 mov 1, %g1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
4001cf28: fa 26 a0 40 st %i5, [ %i2 + 0x40 ]
map->dirty = true;
4001cf2c: c2 2e a0 34 stb %g1, [ %i2 + 0x34 ]
4001cf30: 80 a0 a0 00 cmp %g2, 0
4001cf34: 12 80 00 0d bne 4001cf68 <rtems_rfs_file_set_size+0x294>
4001cf38: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001cf3c: 10 80 00 0f b 4001cf78 <rtems_rfs_file_set_size+0x2a4>
4001cf40: 80 a0 80 01 cmp %g2, %g1
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
4001cf44: 90 10 00 10 mov %l0, %o0
4001cf48: 92 06 60 34 add %i1, 0x34, %o1
4001cf4c: 7f ff f5 47 call 4001a468 <rtems_rfs_block_map_shrink>
4001cf50: 94 10 00 18 mov %i0, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
4001cf54: 80 a2 20 00 cmp %o0, 0
4001cf58: 34 80 00 27 bg,a 4001cff4 <rtems_rfs_file_set_size+0x320><== NEVER TAKEN
4001cf5c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001cf60: 10 bf ff f1 b 4001cf24 <rtems_rfs_file_set_size+0x250>
4001cf64: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
4001cf68: 80 a0 60 00 cmp %g1, 0
4001cf6c: 22 80 00 0e be,a 4001cfa4 <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
4001cf70: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
4001cf74: 80 a0 80 01 cmp %g2, %g1
4001cf78: 3a 80 00 0b bcc,a 4001cfa4 <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
4001cf7c: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
4001cf80: 86 00 7f ff add %g1, -1, %g3
4001cf84: 80 a0 80 03 cmp %g2, %g3
4001cf88: 32 80 00 0e bne,a 4001cfc0 <rtems_rfs_file_set_size+0x2ec><== NEVER TAKEN
4001cf8c: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5 <== NOT EXECUTED
4001cf90: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
4001cf94: 80 a0 80 1d cmp %g2, %i5
4001cf98: 28 80 00 0a bleu,a 4001cfc0 <rtems_rfs_file_set_size+0x2ec>
4001cf9c: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
4001cfa0: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
4001cfa4: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
4001cfa8: 80 a7 60 00 cmp %i5, 0
4001cfac: 02 80 00 04 be 4001cfbc <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
4001cfb0: c0 26 e0 18 clr [ %i3 + 0x18 ]
4001cfb4: 82 00 7f ff add %g1, -1, %g1
4001cfb8: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001cfbc: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
4001cfc0: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001cfc4: c2 27 60 84 st %g1, [ %i5 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
4001cfc8: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
4001cfcc: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
if (rtems_rfs_file_update_mtime (handle))
4001cfd0: c2 06 c0 00 ld [ %i3 ], %g1
4001cfd4: 80 88 60 02 btst 2, %g1
4001cfd8: 12 80 00 06 bne 4001cff0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001cfdc: 90 10 20 00 clr %o0
handle->shared->mtime = time (NULL);
4001cfe0: 40 00 22 18 call 40025840 <time>
4001cfe4: 90 10 20 00 clr %o0
4001cfe8: d0 27 60 90 st %o0, [ %i5 + 0x90 ]
}
return 0;
4001cfec: 90 10 20 00 clr %o0
}
4001cff0: b0 10 00 08 mov %o0, %i0
4001cff4: 81 c7 e0 08 ret
4001cff8: 81 e8 00 00 restore
4000fc78 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
4000fc78: 9d e3 be c0 save %sp, -320, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
4000fc7c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
4000fc80: 80 a0 60 00 cmp %g1, 0
4000fc84: 22 80 00 07 be,a 4000fca0 <rtems_rfs_format+0x28> <== ALWAYS TAKEN
4000fc88: 92 10 20 00 clr %o1
printf ("rtems-rfs: format: %s\n", name);
4000fc8c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000fc90: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000fc94: 40 00 46 85 call 400216a8 <printf> <== NOT EXECUTED
4000fc98: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
4000fc9c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000fca0: 94 10 20 84 mov 0x84, %o2
4000fca4: 40 00 46 03 call 400214b0 <memset>
4000fca8: 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;
4000fcac: 82 07 bf c4 add %fp, -60, %g1
4000fcb0: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
4000fcb4: 82 07 bf c0 add %fp, -64, %g1
4000fcb8: 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;
4000fcbc: 82 07 bf d4 add %fp, -44, %g1
4000fcc0: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
4000fcc4: 82 07 bf d0 add %fp, -48, %g1
4000fcc8: 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;
4000fccc: 82 07 bf e4 add %fp, -28, %g1
4000fcd0: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
4000fcd4: 82 07 bf e0 add %fp, -32, %g1
4000fcd8: 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;
4000fcdc: 82 07 bf f4 add %fp, -12, %g1
4000fce0: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
4000fce4: 82 07 bf f0 add %fp, -16, %g1
4000fce8: 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;
4000fcec: 82 10 20 05 mov 5, %g1
4000fcf0: 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;
4000fcf4: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4000fcf8: 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;
4000fcfc: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4000fd00: 40 00 2c 22 call 4001ad88 <rtems_rfs_buffer_open>
4000fd04: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
4000fd08: ba 92 20 00 orcc %o0, 0, %i5
4000fd0c: 04 80 00 08 ble 4000fd2c <rtems_rfs_format+0xb4> <== ALWAYS TAKEN
4000fd10: c2 07 bf 8c ld [ %fp + -116 ], %g1
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
4000fd14: 40 00 4a d1 call 40022858 <strerror> <== NOT EXECUTED
4000fd18: 01 00 00 00 nop <== NOT EXECUTED
4000fd1c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000fd20: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000fd24: 10 80 03 0e b 4001095c <rtems_rfs_format+0xce4> <== NOT EXECUTED
4000fd28: 90 12 22 48 or %o0, 0x248, %o0 ! 40032a48 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
4000fd2c: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
4000fd30: 80 a0 60 00 cmp %g1, 0
4000fd34: 32 80 00 08 bne,a 4000fd54 <rtems_rfs_format+0xdc> <== ALWAYS TAKEN
4000fd38: c2 06 40 00 ld [ %i1 ], %g1
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
4000fd3c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000fd40: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000fd44: 40 00 46 59 call 400216a8 <printf> <== NOT EXECUTED
4000fd48: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
4000fd4c: 81 c7 e0 08 ret <== NOT EXECUTED
4000fd50: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
4000fd54: 80 a0 60 00 cmp %g1, 0
4000fd58: 12 80 00 2a bne 4000fe00 <rtems_rfs_format+0x188>
4000fd5c: c2 27 bf 84 st %g1, [ %fp + -124 ]
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4000fd60: 40 00 35 7f call 4001d35c <rtems_rfs_fs_media_size>
4000fd64: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
4000fd68: 80 a2 20 00 cmp %o0, 0
4000fd6c: 12 80 00 08 bne 4000fd8c <rtems_rfs_format+0x114> <== NEVER TAKEN
4000fd70: 37 00 04 00 sethi %hi(0x100000), %i3
4000fd74: 03 00 03 ff sethi %hi(0xffc00), %g1
4000fd78: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <PROM_START+0xfffff>
4000fd7c: 80 a2 40 01 cmp %o1, %g1
4000fd80: 08 80 00 16 bleu 4000fdd8 <rtems_rfs_format+0x160> <== ALWAYS TAKEN
4000fd84: c2 07 bf 84 ld [ %fp + -124 ], %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4000fd88: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
4000fd8c: ba 82 40 1b addcc %o1, %i3, %i5 <== NOT EXECUTED
4000fd90: 83 37 60 14 srl %i5, 0x14, %g1 <== NOT EXECUTED
4000fd94: b4 10 20 00 clr %i2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4000fd98: 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);
4000fd9c: b8 42 00 1a addx %o0, %i2, %i4 <== NOT EXECUTED
4000fda0: 85 2f 20 0c sll %i4, 0xc, %g2 <== NOT EXECUTED
4000fda4: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4000fda8: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4000fdac: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
4000fdb0: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
4000fdb4: 32 80 00 06 bne,a 4000fdcc <rtems_rfs_format+0x154> <== NOT EXECUTED
4000fdb8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
4000fdbc: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
4000fdc0: 12 bf ff fc bne 4000fdb0 <rtems_rfs_format+0x138> <== NOT EXECUTED
4000fdc4: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
4000fdc8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4000fdcc: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
4000fdd0: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
}
if (fs->block_size < 512)
4000fdd4: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
4000fdd8: 80 a0 61 ff cmp %g1, 0x1ff
4000fddc: 18 80 00 05 bgu 4000fdf0 <rtems_rfs_format+0x178> <== NEVER TAKEN
4000fde0: c4 07 bf 84 ld [ %fp + -124 ], %g2
fs->block_size = 512;
4000fde4: 82 10 22 00 mov 0x200, %g1
4000fde8: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
4000fdec: c4 07 bf 84 ld [ %fp + -124 ], %g2
4000fdf0: 03 00 00 04 sethi %hi(0x1000), %g1
4000fdf4: 80 a0 80 01 cmp %g2, %g1
4000fdf8: 38 80 00 02 bgu,a 4000fe00 <rtems_rfs_format+0x188> <== NEVER TAKEN
4000fdfc: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4000fe00: c2 07 bf 8c ld [ %fp + -116 ], %g1
4000fe04: fa 07 bf 84 ld [ %fp + -124 ], %i5
4000fe08: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
4000fe0c: 90 10 00 1d mov %i5, %o0
4000fe10: 40 00 77 de call 4002dd88 <.urem>
4000fe14: 92 10 00 1c mov %i4, %o1
4000fe18: 80 a2 20 00 cmp %o0, 0
4000fe1c: 22 80 00 07 be,a 4000fe38 <rtems_rfs_format+0x1c0> <== ALWAYS TAKEN
4000fe20: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
4000fe24: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000fe28: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000fe2c: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
4000fe30: 10 80 02 cc b 40010960 <rtems_rfs_format+0xce8> <== NOT EXECUTED
4000fe34: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
4000fe38: 80 a0 60 00 cmp %g1, 0
4000fe3c: 02 80 00 04 be 4000fe4c <rtems_rfs_format+0x1d4> <== ALWAYS TAKEN
4000fe40: bb 2f 60 03 sll %i5, 3, %i5
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
4000fe44: 10 80 00 03 b 4000fe50 <rtems_rfs_format+0x1d8> <== NOT EXECUTED
4000fe48: c2 27 bf a4 st %g1, [ %fp + -92 ] <== NOT EXECUTED
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
4000fe4c: fa 27 bf a4 st %i5, [ %fp + -92 ]
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
4000fe50: c2 07 bf a4 ld [ %fp + -92 ], %g1
4000fe54: 80 a0 40 1d cmp %g1, %i5
4000fe58: 08 80 00 04 bleu 4000fe68 <rtems_rfs_format+0x1f0> <== ALWAYS TAKEN
4000fe5c: 11 10 00 ca sethi %hi(0x40032800), %o0
{
printf ("group block count is higher than bits in block\n");
4000fe60: 10 80 01 2f b 4001031c <rtems_rfs_format+0x6a4> <== NOT EXECUTED
4000fe64: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40032ae0 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4000fe68: 40 00 35 3d call 4001d35c <rtems_rfs_fs_media_size>
4000fe6c: 90 07 bf 7c add %fp, -132, %o0
4000fe70: fa 07 bf 84 ld [ %fp + -124 ], %i5
4000fe74: 94 10 20 00 clr %o2
4000fe78: 40 00 7a 93 call 4002e8c4 <__udivdi3>
4000fe7c: 96 10 00 1d mov %i5, %o3
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4000fe80: b9 2f 60 03 sll %i5, 3, %i4
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4000fe84: d2 27 bf 80 st %o1, [ %fp + -128 ]
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4000fe88: 90 10 00 09 mov %o1, %o0
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4000fe8c: b6 10 00 09 mov %o1, %i3
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4000fe90: 7f ff ff 6f call 4000fc4c <rtems_rfs_rup_quotient>
4000fe94: 92 10 00 1c mov %i4, %o1
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
4000fe98: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4000fe9c: d0 27 bf a0 st %o0, [ %fp + -96 ]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
4000fea0: c2 27 bf a8 st %g1, [ %fp + -88 ]
if (!fs->group_inodes)
4000fea4: 80 a0 60 00 cmp %g1, 0
4000fea8: 12 80 00 14 bne 4000fef8 <rtems_rfs_format+0x280> <== NEVER TAKEN
4000feac: b4 10 00 08 mov %o0, %i2
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
4000feb0: d0 06 60 0c ld [ %i1 + 0xc ], %o0
4000feb4: 80 a2 20 00 cmp %o0, 0
4000feb8: 22 80 00 02 be,a 4000fec0 <rtems_rfs_format+0x248> <== ALWAYS TAKEN
4000febc: 90 10 20 01 mov 1, %o0
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
4000fec0: 7f ff c9 b5 call 40002594 <.umul>
4000fec4: 92 06 ff ff add %i3, -1, %o1
4000fec8: 7f ff c9 ed call 4000267c <.udiv>
4000fecc: 92 10 20 64 mov 0x64, %o1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
4000fed0: 7f ff ff 5f call 4000fc4c <rtems_rfs_rup_quotient>
4000fed4: 92 10 00 1a mov %i2, %o1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
4000fed8: 92 10 20 38 mov 0x38, %o1
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
4000fedc: b6 10 00 08 mov %o0, %i3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
4000fee0: 7f ff c9 e7 call 4000267c <.udiv>
4000fee4: 90 10 00 1d mov %i5, %o0
4000fee8: 92 10 00 08 mov %o0, %o1
4000feec: 7f ff c9 aa call 40002594 <.umul>
4000fef0: 90 10 00 1b mov %i3, %o0
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
inode_overhead = config->inode_overhead;
fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
4000fef4: d0 27 bf a8 st %o0, [ %fp + -88 ]
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
4000fef8: 90 10 00 1d mov %i5, %o0
4000fefc: 7f ff c9 e0 call 4000267c <.udiv>
4000ff00: 92 10 20 38 mov 0x38, %o1
4000ff04: ba 10 00 08 mov %o0, %i5
4000ff08: d0 27 bf ac st %o0, [ %fp + -84 ]
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
4000ff0c: d0 07 bf a8 ld [ %fp + -88 ], %o0
4000ff10: 7f ff ff 4f call 4000fc4c <rtems_rfs_rup_quotient>
4000ff14: 92 10 00 1d mov %i5, %o1
fs->inodes_per_block) * fs->inodes_per_block;
4000ff18: 7f ff c9 9f call 40002594 <.umul>
4000ff1c: 92 10 00 1d mov %i5, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
4000ff20: 80 a2 00 1c cmp %o0, %i4
4000ff24: 38 80 00 03 bgu,a 4000ff30 <rtems_rfs_format+0x2b8> <== NEVER TAKEN
4000ff28: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
4000ff2c: d0 27 bf a8 st %o0, [ %fp + -88 ]
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
4000ff30: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
4000ff34: 80 a0 60 00 cmp %g1, 0
4000ff38: 22 80 02 90 be,a 40010978 <rtems_rfs_format+0xd00> <== ALWAYS TAKEN
4000ff3c: 82 10 22 00 mov 0x200, %g1
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
4000ff40: 10 80 02 8f b 4001097c <rtems_rfs_format+0xd04> <== NOT EXECUTED
4000ff44: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4000ff48: 40 00 35 05 call 4001d35c <rtems_rfs_fs_media_size> <== NOT EXECUTED
4000ff4c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
4000ff50: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
4000ff54: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
4000ff58: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000ff5c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
4000ff60: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
4000ff64: 40 00 45 d1 call 400216a8 <printf> <== NOT EXECUTED
4000ff68: 90 12 23 10 or %o0, 0x310, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
4000ff6c: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
4000ff70: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000ff74: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4000ff78: 40 00 45 cc call 400216a8 <printf> <== NOT EXECUTED
4000ff7c: 90 12 23 38 or %o0, 0x338, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
4000ff80: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
4000ff84: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000ff88: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
4000ff8c: 40 00 45 c7 call 400216a8 <printf> <== NOT EXECUTED
4000ff90: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
4000ff94: 40 00 34 e9 call 4001d338 <rtems_rfs_fs_size> <== NOT EXECUTED
4000ff98: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
4000ff9c: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
4000ffa0: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
4000ffa4: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000ffa8: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
4000ffac: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
4000ffb0: 40 00 45 be call 400216a8 <printf> <== NOT EXECUTED
4000ffb4: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
4000ffb8: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
4000ffbc: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000ffc0: 40 00 45 ba call 400216a8 <printf> <== NOT EXECUTED
4000ffc4: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 40032bb0 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
4000ffc8: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
4000ffcc: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
4000ffd0: 40 00 45 b6 call 400216a8 <printf> <== NOT EXECUTED
4000ffd4: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 40032bd8 <_CPU_Trap_slot_template+0x1b8><== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
4000ffd8: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
4000ffdc: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
4000ffe0: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
4000ffe4: 40 00 45 b1 call 400216a8 <printf> <== NOT EXECUTED
4000ffe8: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
4000ffec: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
4000fff0: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
4000fff4: 40 00 45 ad call 400216a8 <printf> <== NOT EXECUTED
4000fff8: 90 12 20 28 or %o0, 0x28, %o0 ! 40032c28 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4000fffc: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
40010000: 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",
40010004: 7f ff c9 64 call 40002594 <.umul> <== NOT EXECUTED
40010008: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
rtems_rfs_fs_block_size (fs));
4001000c: f8 07 bf 84 ld [ %fp + -124 ], %i4 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40010010: 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,
40010014: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40010018: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
4001001c: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
40010020: 7f ff ff 0b call 4000fc4c <rtems_rfs_rup_quotient> <== NOT EXECUTED
40010024: 90 27 40 08 sub %i5, %o0, %o0 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
40010028: 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));
4001002c: 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))
40010030: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
40010034: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
40010038: 28 80 00 02 bleu,a 40010040 <rtems_rfs_format+0x3c8> <== NOT EXECUTED
4001003c: 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;
40010040: 84 02 20 01 add %o0, 1, %g2 <== NOT EXECUTED
40010044: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
40010048: 89 28 a0 07 sll %g2, 7, %g4 <== NOT EXECUTED
4001004c: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
40010050: 90 00 c0 02 add %g3, %g2, %o0 <== NOT EXECUTED
40010054: 7f ff c9 8c call 40002684 <.div> <== NOT EXECUTED
40010058: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4001005c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
40010060: 7f ff c9 89 call 40002684 <.div> <== NOT EXECUTED
40010064: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
40010068: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
4001006c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40010070: 40 00 77 48 call 4002dd90 <.rem> <== NOT EXECUTED
40010074: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40010078: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001007c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40010080: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40010084: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010088: 40 00 45 88 call 400216a8 <printf> <== NOT EXECUTED
4001008c: 90 12 20 50 or %o0, 0x50, %o0 ! 40032c50 <_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);
40010090: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
40010094: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010098: 40 00 45 84 call 400216a8 <printf> <== NOT EXECUTED
4001009c: 90 12 20 80 or %o0, 0x80, %o0 ! 40032c80 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
400100a0: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
400100a4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400100a8: 40 00 45 80 call 400216a8 <printf> <== NOT EXECUTED
400100ac: 90 12 20 a0 or %o0, 0xa0, %o0 ! 40032ca0 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
400100b0: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
400100b4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400100b8: 40 00 45 7c call 400216a8 <printf> <== NOT EXECUTED
400100bc: 90 12 20 c8 or %o0, 0xc8, %o0 ! 40032cc8 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
400100c0: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
400100c4: 40 00 2b d1 call 4001b008 <rtems_rfs_buffer_setblksize>
400100c8: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
400100cc: ba 92 20 00 orcc %o0, 0, %i5
400100d0: 24 80 00 08 ble,a 400100f0 <rtems_rfs_format+0x478> <== ALWAYS TAKEN
400100d4: c0 2f bf 30 clrb [ %fp + -208 ]
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
400100d8: 40 00 49 e0 call 40022858 <strerror> <== NOT EXECUTED
400100dc: 01 00 00 00 nop <== NOT EXECUTED
400100e0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400100e4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400100e8: 10 80 02 1d b 4001095c <rtems_rfs_format+0xce4> <== NOT EXECUTED
400100ec: 90 12 20 f0 or %o0, 0xf0, %o0 ! 40032cf0 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
400100f0: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
400100f4: 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);
400100f8: 90 07 bf 7c add %fp, -132, %o0
400100fc: 92 07 bf 30 add %fp, -208, %o1
40010100: 94 10 20 00 clr %o2
40010104: 40 00 2a 7b call 4001aaf0 <rtems_rfs_buffer_handle_request>
40010108: 96 10 20 00 clr %o3
if (rc > 0)
4001010c: ba 92 20 00 orcc %o0, 0, %i5
40010110: 04 80 00 0a ble 40010138 <rtems_rfs_format+0x4c0> <== ALWAYS TAKEN
40010114: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
40010118: 7f ff fe c3 call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001011c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
40010120: 40 00 49 ce call 40022858 <strerror> <== NOT EXECUTED
40010124: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40010128: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001012c: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010130: 10 80 00 73 b 400102fc <rtems_rfs_format+0x684> <== NOT EXECUTED
40010134: 90 12 21 28 or %o0, 0x128, %o0 ! 40032d28 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
40010138: 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));
4001013c: 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);
40010140: 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));
40010144: 92 10 20 ff mov 0xff, %o1
40010148: 40 00 44 da call 400214b0 <memset>
4001014c: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
40010150: 82 10 20 28 mov 0x28, %g1
40010154: c2 2f 40 00 stb %g1, [ %i5 ]
40010158: 82 10 20 09 mov 9, %g1
4001015c: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
40010160: 82 10 20 20 mov 0x20, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40010164: 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);
40010168: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
4001016c: c0 2f 60 05 clrb [ %i5 + 5 ]
40010170: c0 2f 60 06 clrb [ %i5 + 6 ]
40010174: 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);
40010178: 84 10 20 01 mov 1, %g2
4001017c: c4 2f 60 03 stb %g2, [ %i5 + 3 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40010180: c2 07 bf 80 ld [ %fp + -128 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40010184: 92 07 bf 30 add %fp, -208, %o1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40010188: 87 30 60 18 srl %g1, 0x18, %g3
4001018c: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
40010190: 87 30 60 10 srl %g1, 0x10, %g3
40010194: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
40010198: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
4001019c: 87 30 60 08 srl %g1, 8, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
400101a0: c2 0f bf 84 ldub [ %fp + -124 ], %g1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
400101a4: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
400101a8: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
400101ac: c2 17 bf 84 lduh [ %fp + -124 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400101b0: 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));
400101b4: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
400101b8: c2 07 bf 84 ld [ %fp + -124 ], %g1
400101bc: 83 30 60 08 srl %g1, 8, %g1
400101c0: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
400101c4: c2 07 bf 84 ld [ %fp + -124 ], %g1
400101c8: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
400101cc: c2 0f bf 94 ldub [ %fp + -108 ], %g1
400101d0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
400101d4: c2 17 bf 94 lduh [ %fp + -108 ], %g1
400101d8: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
400101dc: c2 07 bf 94 ld [ %fp + -108 ], %g1
400101e0: 83 30 60 08 srl %g1, 8, %g1
400101e4: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
400101e8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400101ec: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
400101f0: c2 0f bf 98 ldub [ %fp + -104 ], %g1
400101f4: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
400101f8: c2 17 bf 98 lduh [ %fp + -104 ], %g1
400101fc: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
40010200: c2 07 bf 98 ld [ %fp + -104 ], %g1
40010204: 83 30 60 08 srl %g1, 8, %g1
40010208: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
4001020c: c2 07 bf 98 ld [ %fp + -104 ], %g1
40010210: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
40010214: c2 0f bf a0 ldub [ %fp + -96 ], %g1
40010218: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
4001021c: c2 17 bf a0 lduh [ %fp + -96 ], %g1
40010220: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
40010224: c2 07 bf a0 ld [ %fp + -96 ], %g1
40010228: 83 30 60 08 srl %g1, 8, %g1
4001022c: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
40010230: c2 07 bf a0 ld [ %fp + -96 ], %g1
40010234: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
40010238: c2 0f bf a4 ldub [ %fp + -92 ], %g1
4001023c: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
40010240: c2 17 bf a4 lduh [ %fp + -92 ], %g1
40010244: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
40010248: c2 07 bf a4 ld [ %fp + -92 ], %g1
4001024c: 83 30 60 08 srl %g1, 8, %g1
40010250: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
40010254: c2 07 bf a4 ld [ %fp + -92 ], %g1
40010258: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
4001025c: c2 0f bf a8 ldub [ %fp + -88 ], %g1
40010260: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
40010264: c2 17 bf a8 lduh [ %fp + -88 ], %g1
40010268: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
4001026c: c2 07 bf a8 ld [ %fp + -88 ], %g1
40010270: 83 30 60 08 srl %g1, 8, %g1
40010274: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
40010278: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4001027c: 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);
40010280: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
40010284: c0 2f 60 25 clrb [ %i5 + 0x25 ]
40010288: c0 2f 60 26 clrb [ %i5 + 0x26 ]
4001028c: 82 10 20 38 mov 0x38, %g1
40010290: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40010294: 40 00 29 a3 call 4001a920 <rtems_rfs_buffer_handle_release>
40010298: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001029c: 92 07 bf 30 add %fp, -208, %o1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400102a0: ba 10 00 08 mov %o0, %i5
if (rc > 0)
400102a4: 80 a7 60 00 cmp %i5, 0
400102a8: 04 80 00 0a ble 400102d0 <rtems_rfs_format+0x658> <== ALWAYS TAKEN
400102ac: 90 07 bf 7c add %fp, -132, %o0
{
rtems_rfs_buffer_handle_close (fs, &handle);
400102b0: 7f ff fe 5d call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400102b4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
400102b8: 40 00 49 68 call 40022858 <strerror> <== NOT EXECUTED
400102bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400102c0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400102c4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400102c8: 10 80 00 0d b 400102fc <rtems_rfs_format+0x684> <== NOT EXECUTED
400102cc: 90 12 21 60 or %o0, 0x160, %o0 ! 40032d60 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
400102d0: 7f ff fe 55 call 4000fc24 <rtems_rfs_buffer_handle_close>
400102d4: 01 00 00 00 nop
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
}
return true;
400102d8: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
400102dc: 80 a2 20 00 cmp %o0, 0
400102e0: 04 80 00 0a ble 40010308 <rtems_rfs_format+0x690> <== ALWAYS TAKEN
400102e4: ba 10 00 08 mov %o0, %i5
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
400102e8: 40 00 49 5c call 40022858 <strerror> <== NOT EXECUTED
400102ec: 01 00 00 00 nop <== NOT EXECUTED
400102f0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400102f4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400102f8: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 40032da0 <_CPU_Trap_slot_template+0x380><== NOT EXECUTED
400102fc: 40 00 44 eb call 400216a8 <printf> <== NOT EXECUTED
40010300: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
return false;
40010304: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
40010308: 80 88 60 ff btst 0xff, %g1
4001030c: 12 80 00 f3 bne 400106d8 <rtems_rfs_format+0xa60> <== ALWAYS TAKEN
40010310: ba 10 20 00 clr %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
40010314: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010318: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 40032de8 <_CPU_Trap_slot_template+0x3c8><== NOT EXECUTED
4001031c: 40 00 45 7b call 40021908 <puts> <== NOT EXECUTED
40010320: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40010324: 30 80 01 93 b,a 40010970 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
40010328: f8 07 bf a4 ld [ %fp + -92 ], %i4
4001032c: 90 10 00 1d mov %i5, %o0
40010330: 7f ff c8 99 call 40002594 <.umul>
40010334: 92 10 00 1c mov %i4, %o1
if (group_base > rtems_rfs_fs_blocks (fs))
40010338: c2 07 bf 80 ld [ %fp + -128 ], %g1
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
4001033c: a0 02 20 01 add %o0, 1, %l0
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
40010340: ec 0e 60 14 ldub [ %i1 + 0x14 ], %l6
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
40010344: 80 a4 00 01 cmp %l0, %g1
40010348: 08 80 00 08 bleu 40010368 <rtems_rfs_format+0x6f0> <== ALWAYS TAKEN
4001034c: b4 10 00 08 mov %o0, %i2
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40010350: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010354: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010358: 40 00 44 d4 call 400216a8 <printf> <== NOT EXECUTED
4001035c: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
40010360: 10 80 00 d9 b 400106c4 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
40010364: 82 10 20 00 clr %g1 <== NOT EXECUTED
/*
* Be nice to strange sizes of disks. These are embedded systems after all
* and nice numbers do not always work out. Let the last block pick up the
* remainder of the blocks.
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
40010368: 84 04 00 1c add %l0, %i4, %g2
4001036c: 80 a0 80 01 cmp %g2, %g1
40010370: 38 80 00 02 bgu,a 40010378 <rtems_rfs_format+0x700> <== ALWAYS TAKEN
40010374: b8 20 40 10 sub %g1, %l0, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
40010378: 80 8d e0 ff btst 0xff, %l7
4001037c: 22 80 00 09 be,a 400103a0 <rtems_rfs_format+0x728> <== ALWAYS TAKEN
40010380: c0 2f bf 30 clrb [ %fp + -208 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40010384: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010388: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001038c: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
40010390: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40010394: 40 00 44 c5 call 400216a8 <printf> <== NOT EXECUTED
40010398: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001039c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400103a0: c0 27 bf 34 clr [ %fp + -204 ]
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
400103a4: 80 8d e0 ff btst 0xff, %l7
400103a8: 02 80 00 05 be 400103bc <rtems_rfs_format+0x744> <== ALWAYS TAKEN
400103ac: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
400103b0: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400103b4: 40 00 44 bd call 400216a8 <printf> <== NOT EXECUTED
400103b8: 90 12 22 90 or %o0, 0x290, %o0 ! 40032e90 <_CPU_Trap_slot_template+0x470><== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
400103bc: 98 10 00 10 mov %l0, %o4
400103c0: b6 07 bf 3c add %fp, -196, %i3
400103c4: 92 07 bf 7c add %fp, -132, %o1
400103c8: 90 10 00 1b mov %i3, %o0
400103cc: 94 07 bf 30 add %fp, -208, %o2
400103d0: 40 00 24 c4 call 400196e0 <rtems_rfs_bitmap_open>
400103d4: 96 10 00 1c mov %i4, %o3
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
400103d8: a0 92 20 00 orcc %o0, 0, %l0
400103dc: 04 80 00 0a ble 40010404 <rtems_rfs_format+0x78c> <== ALWAYS TAKEN
400103e0: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
400103e4: 7f ff fe 10 call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400103e8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
400103ec: 40 00 49 1b call 40022858 <strerror> <== NOT EXECUTED
400103f0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400103f4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400103f8: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400103fc: 10 80 00 17 b 40010458 <rtems_rfs_format+0x7e0> <== NOT EXECUTED
40010400: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 40032ea0 <_CPU_Trap_slot_template+0x480><== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40010404: c2 07 bf 38 ld [ %fp + -200 ], %g1
40010408: d4 07 bf 84 ld [ %fp + -124 ], %o2
4001040c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40010410: 40 00 44 28 call 400214b0 <memset>
40010414: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40010418: 40 00 24 0b call 40019444 <rtems_rfs_bitmap_map_clear_all>
4001041c: 90 10 00 1b mov %i3, %o0
40010420: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40010424: 80 a4 20 00 cmp %l0, 0
40010428: 04 80 00 0f ble 40010464 <rtems_rfs_format+0x7ec> <== ALWAYS TAKEN
4001042c: 90 10 00 1b mov %i3, %o0
{
rtems_rfs_bitmap_close (&bitmap);
40010430: 40 00 24 bd call 40019724 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40010434: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
40010438: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
4001043c: 7f ff fd fa call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
40010440: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
40010444: 40 00 49 05 call 40022858 <strerror> <== NOT EXECUTED
40010448: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001044c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40010450: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40010454: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40032ee8 <_CPU_Trap_slot_template+0x4c8><== NOT EXECUTED
40010458: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001045c: 10 80 00 5e b 400105d4 <rtems_rfs_format+0x95c> <== NOT EXECUTED
40010460: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
40010464: 40 00 23 74 call 40019234 <rtems_rfs_bitmap_map_set>
40010468: 92 10 20 00 clr %o1
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
4001046c: 92 10 20 01 mov 1, %o1
40010470: 40 00 23 71 call 40019234 <rtems_rfs_bitmap_map_set>
40010474: 90 10 00 1b mov %i3, %o0
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40010478: d0 07 bf a8 ld [ %fp + -88 ], %o0
4001047c: d2 07 bf ac ld [ %fp + -84 ], %o1
40010480: 7f ff fd f3 call 4000fc4c <rtems_rfs_rup_quotient>
40010484: a2 10 20 00 clr %l1
40010488: 10 80 00 05 b 4001049c <rtems_rfs_format+0x824>
4001048c: a0 10 00 08 mov %o0, %l0
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40010490: 92 04 60 02 add %l1, 2, %o1
40010494: 40 00 23 68 call 40019234 <rtems_rfs_bitmap_map_set>
40010498: a2 04 60 01 inc %l1
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4001049c: 80 a4 40 10 cmp %l1, %l0
400104a0: 06 bf ff fc bl 40010490 <rtems_rfs_format+0x818>
400104a4: 90 10 00 1b mov %i3, %o0
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
400104a8: 40 00 24 9f call 40019724 <rtems_rfs_bitmap_close>
400104ac: 01 00 00 00 nop
if (rc > 0)
400104b0: b6 92 20 00 orcc %o0, 0, %i3
400104b4: 24 80 00 0d ble,a 400104e8 <rtems_rfs_format+0x870> <== ALWAYS TAKEN
400104b8: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
400104bc: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
400104c0: 7f ff fd d9 call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400104c4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
400104c8: 40 00 48 e4 call 40022858 <strerror> <== NOT EXECUTED
400104cc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400104d0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400104d4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400104d8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
400104dc: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400104e0: 10 80 00 3d b 400105d4 <rtems_rfs_format+0x95c> <== NOT EXECUTED
400104e4: 90 12 23 38 or %o0, 0x338, %o0 ! 40032f38 <_CPU_Trap_slot_template+0x518><== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
400104e8: 80 8d e0 ff btst 0xff, %l7
400104ec: 02 80 00 05 be 40010500 <rtems_rfs_format+0x888> <== ALWAYS TAKEN
400104f0: c2 2f bf 30 stb %g1, [ %fp + -208 ]
printf (", inodes");
400104f4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
400104f8: 40 00 44 6c call 400216a8 <printf> <== NOT EXECUTED
400104fc: 90 12 23 80 or %o0, 0x380, %o0 ! 40032f80 <_CPU_Trap_slot_template+0x560><== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40010500: 96 10 00 1c mov %i4, %o3
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
40010504: ae 07 bf 7c add %fp, -132, %l7
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40010508: b6 07 bf 30 add %fp, -208, %i3
4001050c: 90 07 bf 3c add %fp, -196, %o0
40010510: 92 10 00 17 mov %l7, %o1
40010514: 94 10 00 1b mov %i3, %o2
40010518: 40 00 24 72 call 400196e0 <rtems_rfs_bitmap_open>
4001051c: 98 06 a0 02 add %i2, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40010520: b8 92 20 00 orcc %o0, 0, %i4
40010524: 04 80 00 09 ble 40010548 <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
40010528: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001052c: 7f ff fd be call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
40010530: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
40010534: 40 00 48 c9 call 40022858 <strerror> <== NOT EXECUTED
40010538: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001053c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40010540: 10 80 00 23 b 400105cc <rtems_rfs_format+0x954> <== NOT EXECUTED
40010544: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
40010548: c2 07 bf 38 ld [ %fp + -200 ], %g1
4001054c: d4 07 bf 84 ld [ %fp + -124 ], %o2
40010550: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40010554: 40 00 43 d7 call 400214b0 <memset>
40010558: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4001055c: 40 00 23 ba call 40019444 <rtems_rfs_bitmap_map_clear_all>
40010560: 90 07 bf 3c add %fp, -196, %o0
40010564: b8 10 00 08 mov %o0, %i4
if (rc > 0)
40010568: 80 a7 20 00 cmp %i4, 0
4001056c: 04 80 00 0c ble 4001059c <rtems_rfs_format+0x924> <== ALWAYS TAKEN
40010570: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
40010574: 40 00 24 6c call 40019724 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40010578: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
4001057c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40010580: 7f ff fd a9 call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
40010584: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
40010588: 40 00 48 b4 call 40022858 <strerror> <== NOT EXECUTED
4001058c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40010590: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40010594: 10 80 00 0e b 400105cc <rtems_rfs_format+0x954> <== NOT EXECUTED
40010598: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
4001059c: 40 00 24 62 call 40019724 <rtems_rfs_bitmap_close>
400105a0: 01 00 00 00 nop
if (rc > 0)
400105a4: b8 92 20 00 orcc %o0, 0, %i4
400105a8: 24 80 00 0f ble,a 400105e4 <rtems_rfs_format+0x96c> <== ALWAYS TAKEN
400105ac: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
400105b0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400105b4: 7f ff fd 9c call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400105b8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
400105bc: 40 00 48 a7 call 40022858 <strerror> <== NOT EXECUTED
400105c0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400105c4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400105c8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
400105cc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400105d0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400105d4: 40 00 44 35 call 400216a8 <printf> <== NOT EXECUTED
400105d8: 01 00 00 00 nop <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
400105dc: 10 80 00 3a b 400106c4 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
400105e0: 82 10 20 00 clr %g1 ! 0 <PROM_START> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
400105e4: c2 2f bf 30 stb %g1, [ %fp + -208 ]
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
400105e8: 80 8d a0 ff btst 0xff, %l6
400105ec: 12 80 00 27 bne 40010688 <rtems_rfs_format+0xa10> <== NEVER TAKEN
400105f0: a2 10 20 00 clr %l1
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
400105f4: 90 07 bf 7c add %fp, -132, %o0
400105f8: 7f ff fd 8b call 4000fc24 <rtems_rfs_buffer_handle_close>
400105fc: 92 07 bf 30 add %fp, -208, %o1
if (rc > 0)
40010600: b8 92 20 00 orcc %o0, 0, %i4
40010604: 04 80 00 30 ble 400106c4 <rtems_rfs_format+0xa4c> <== ALWAYS TAKEN
40010608: 82 10 20 01 mov 1, %g1
4001060c: 30 80 00 27 b,a 400106a8 <rtems_rfs_format+0xa30> <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40010610: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
40010614: b8 00 40 11 add %g1, %l1, %i4 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40010618: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001061c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40010620: 40 00 29 34 call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40010624: 96 10 20 00 clr %o3 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
40010628: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001062c: 04 80 00 10 ble 4001066c <rtems_rfs_format+0x9f4> <== NOT EXECUTED
40010630: c4 07 bf 38 ld [ %fp + -200 ], %g2 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
40010634: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40010638: 7f ff fd 7b call 4000fc24 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001063c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40010640: 40 00 48 86 call 40022858 <strerror> <== NOT EXECUTED
40010644: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40010648: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001064c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
40010650: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40010654: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010658: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4001065c: 40 00 44 13 call 400216a8 <printf> <== NOT EXECUTED
40010660: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
40010664: 10 80 00 18 b 400106c4 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
40010668: 82 10 20 00 clr %g1 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4001066c: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
40010670: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0 <== NOT EXECUTED
40010674: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
40010678: 40 00 43 8e call 400214b0 <memset> <== NOT EXECUTED
4001067c: a2 04 60 01 inc %l1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
40010680: 10 80 00 05 b 40010694 <rtems_rfs_format+0xa1c> <== NOT EXECUTED
40010684: ec 2f bf 30 stb %l6, [ %fp + -208 ] <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
40010688: b4 06 a0 03 add %i2, 3, %i2 <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
4001068c: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
40010690: f4 27 bf 24 st %i2, [ %fp + -220 ] <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
40010694: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
40010698: 06 bf ff de bl 40010610 <rtems_rfs_format+0x998> <== NOT EXECUTED
4001069c: c2 07 bf 24 ld [ %fp + -220 ], %g1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
400106a0: 10 bf ff d6 b 400105f8 <rtems_rfs_format+0x980> <== NOT EXECUTED
400106a4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
400106a8: 40 00 48 6c call 40022858 <strerror> <== NOT EXECUTED
400106ac: 01 00 00 00 nop <== NOT EXECUTED
400106b0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400106b4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400106b8: 40 00 43 fc call 400216a8 <printf> <== NOT EXECUTED
400106bc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rc, strerror (rc));
return false;
400106c0: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
400106c4: 80 88 60 ff btst 0xff, %g1
400106c8: 02 80 00 a9 be 4001096c <rtems_rfs_format+0xcf4> <== NEVER TAKEN
400106cc: ba 07 60 01 inc %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
400106d0: 10 80 00 0b b 400106fc <rtems_rfs_format+0xa84>
400106d4: c2 07 bf a0 ld [ %fp + -96 ], %g1
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
400106d8: 25 10 00 cc sethi %hi(0x40033000), %l2
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
400106dc: 27 10 00 cc sethi %hi(0x40033000), %l3
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
400106e0: 29 10 00 cb sethi %hi(0x40032c00), %l4
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400106e4: 2b 10 00 cb sethi %hi(0x40032c00), %l5
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
400106e8: a4 14 a0 b8 or %l2, 0xb8, %l2
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
400106ec: a6 14 e0 28 or %l3, 0x28, %l3
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
400106f0: a8 15 23 d8 or %l4, 0x3d8, %l4
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400106f4: aa 15 63 90 or %l5, 0x390, %l5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
400106f8: c2 07 bf a0 ld [ %fp + -96 ], %g1
400106fc: 80 a7 40 01 cmp %i5, %g1
40010700: 06 bf ff 0a bl 40010328 <rtems_rfs_format+0x6b0>
40010704: ee 0e 60 15 ldub [ %i1 + 0x15 ], %l7
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
40010708: 80 8d e0 ff btst 0xff, %l7
4001070c: 02 80 00 04 be 4001071c <rtems_rfs_format+0xaa4> <== ALWAYS TAKEN
40010710: 01 00 00 00 nop
printf ("\n");
40010714: 40 00 44 4f call 40021850 <putchar> <== NOT EXECUTED
40010718: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
4001071c: 40 00 2a 76 call 4001b0f4 <rtems_rfs_buffer_close>
40010720: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
40010724: ba 92 20 00 orcc %o0, 0, %i5
40010728: 24 80 00 08 ble,a 40010748 <rtems_rfs_format+0xad0> <== ALWAYS TAKEN
4001072c: 90 10 00 18 mov %i0, %o0
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
40010730: 40 00 48 4a call 40022858 <strerror> <== NOT EXECUTED
40010734: 01 00 00 00 nop <== NOT EXECUTED
40010738: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001073c: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010740: 10 80 00 87 b 4001095c <rtems_rfs_format+0xce4> <== NOT EXECUTED
40010744: 90 12 20 f8 or %o0, 0xf8, %o0 ! 400330f8 <_CPU_Trap_slot_template+0x6d8><== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
40010748: 92 10 20 00 clr %o1
4001074c: 94 10 20 06 mov 6, %o2
40010750: 96 10 20 00 clr %o3
40010754: 40 00 33 0c call 4001d384 <rtems_rfs_fs_open>
40010758: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
4001075c: 80 a2 20 00 cmp %o0, 0
40010760: 36 80 00 0e bge,a 40010798 <rtems_rfs_format+0xb20> <== ALWAYS TAKEN
40010764: d0 07 bf 28 ld [ %fp + -216 ], %o0
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
40010768: 40 00 3e 77 call 40020144 <__errno> <== NOT EXECUTED
4001076c: b0 10 20 00 clr %i0 <== NOT EXECUTED
40010770: 40 00 3e 75 call 40020144 <__errno> <== NOT EXECUTED
40010774: 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",
40010778: 40 00 48 38 call 40022858 <strerror> <== NOT EXECUTED
4001077c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40010780: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010784: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010788: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
4001078c: 40 00 43 c7 call 400216a8 <printf> <== NOT EXECUTED
40010790: 90 12 21 28 or %o0, 0x128, %o0 ! 40033128 <_CPU_Trap_slot_template+0x708><== NOT EXECUTED
40010794: 30 80 00 77 b,a 40010970 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
40010798: 92 10 20 01 mov 1, %o1
4001079c: 40 00 02 38 call 4001107c <rtems_rfs_inode_alloc>
400107a0: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
400107a4: ba 92 20 00 orcc %o0, 0, %i5
400107a8: 04 80 00 0a ble 400107d0 <rtems_rfs_format+0xb58> <== ALWAYS TAKEN
400107ac: d2 07 bf 2c ld [ %fp + -212 ], %o1
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
400107b0: 40 00 48 2a call 40022858 <strerror> <== NOT EXECUTED
400107b4: 01 00 00 00 nop <== NOT EXECUTED
400107b8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400107bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400107c0: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
400107c4: 40 00 43 b9 call 400216a8 <printf> <== NOT EXECUTED
400107c8: 90 12 21 60 or %o0, 0x160, %o0 ! 40033160 <_CPU_Trap_slot_template+0x740><== NOT EXECUTED
400107cc: 30 80 00 06 b,a 400107e4 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
400107d0: 80 a2 60 01 cmp %o1, 1
400107d4: 02 80 00 08 be 400107f4 <rtems_rfs_format+0xb7c> <== ALWAYS TAKEN
400107d8: 11 10 00 cc sethi %hi(0x40033000), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
400107dc: 40 00 43 b3 call 400216a8 <printf> <== NOT EXECUTED
400107e0: 90 12 21 98 or %o0, 0x198, %o0 ! 40033198 <_CPU_Trap_slot_template+0x778><== NOT EXECUTED
rtems_rfs_fs_close (fs);
400107e4: 40 00 34 e3 call 4001db70 <rtems_rfs_fs_close> <== NOT EXECUTED
400107e8: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
400107ec: 10 80 00 55 b 40010940 <rtems_rfs_format+0xcc8> <== NOT EXECUTED
400107f0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400107f4: d0 07 bf 28 ld [ %fp + -216 ], %o0
400107f8: 92 10 20 01 mov 1, %o1
400107fc: 94 07 bf 54 add %fp, -172, %o2
40010800: 40 00 02 5b call 4001116c <rtems_rfs_inode_open>
40010804: 96 10 20 01 mov 1, %o3
if (rc > 0)
40010808: ba 92 20 00 orcc %o0, 0, %i5
4001080c: 24 80 00 0e ble,a 40010844 <rtems_rfs_format+0xbcc> <== ALWAYS TAKEN
40010810: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
40010814: 40 00 48 11 call 40022858 <strerror> <== NOT EXECUTED
40010818: 01 00 00 00 nop <== NOT EXECUTED
4001081c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010820: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010824: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010828: 40 00 43 a0 call 400216a8 <printf> <== NOT EXECUTED
4001082c: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400331d0 <_CPU_Trap_slot_template+0x7b0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
40010830: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40010834: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
40010838: 40 00 01 7c call 40010e28 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001083c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40010840: 30 bf ff e9 b,a 400107e4 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
40010844: 92 10 20 00 clr %o1
40010848: 15 00 00 10 sethi %hi(0x4000), %o2
4001084c: 96 10 20 00 clr %o3
40010850: 94 12 a1 c9 or %o2, 0x1c9, %o2
40010854: 40 00 03 39 call 40011538 <rtems_rfs_inode_initialise>
40010858: 98 10 20 00 clr %o4
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
4001085c: ba 92 20 00 orcc %o0, 0, %i5
40010860: 24 80 00 0a ble,a 40010888 <rtems_rfs_format+0xc10> <== ALWAYS TAKEN
40010864: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
40010868: 40 00 47 fc call 40022858 <strerror> <== NOT EXECUTED
4001086c: 01 00 00 00 nop <== NOT EXECUTED
40010870: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010874: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010878: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
4001087c: 40 00 43 8b call 400216a8 <printf> <== NOT EXECUTED
40010880: 90 12 22 00 or %o0, 0x200, %o0 ! 40033200 <_CPU_Trap_slot_template+0x7e0><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40010884: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40010888: d8 07 bf 2c ld [ %fp + -212 ], %o4
4001088c: 92 07 bf 54 add %fp, -172, %o1
40010890: 15 10 00 c4 sethi %hi(0x40031000), %o2
40010894: 96 10 20 01 mov 1, %o3
40010898: 40 00 2b 93 call 4001b6e4 <rtems_rfs_dir_add_entry>
4001089c: 94 12 a3 50 or %o2, 0x350, %o2
if (rc > 0)
400108a0: ba 92 20 00 orcc %o0, 0, %i5
400108a4: 24 80 00 0a ble,a 400108cc <rtems_rfs_format+0xc54> <== ALWAYS TAKEN
400108a8: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
400108ac: 40 00 47 eb call 40022858 <strerror> <== NOT EXECUTED
400108b0: 01 00 00 00 nop <== NOT EXECUTED
400108b4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400108b8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400108bc: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
400108c0: 40 00 43 7a call 400216a8 <printf> <== NOT EXECUTED
400108c4: 90 12 22 38 or %o0, 0x238, %o0 ! 40033238 <_CPU_Trap_slot_template+0x818><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
400108c8: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
400108cc: 40 00 02 9a call 40011334 <rtems_rfs_inode_close>
400108d0: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
400108d4: ba 92 20 00 orcc %o0, 0, %i5
400108d8: 04 80 00 09 ble 400108fc <rtems_rfs_format+0xc84> <== ALWAYS TAKEN
400108dc: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
400108e0: 40 00 47 de call 40022858 <strerror> <== NOT EXECUTED
400108e4: 01 00 00 00 nop <== NOT EXECUTED
400108e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400108ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400108f0: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
400108f4: 40 00 43 6d call 400216a8 <printf> <== NOT EXECUTED
400108f8: 90 12 22 70 or %o0, 0x270, %o0 ! 40033270 <_CPU_Trap_slot_template+0x850><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
400108fc: 40 00 34 9d call 4001db70 <rtems_rfs_fs_close>
40010900: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
40010904: ba 92 20 00 orcc %o0, 0, %i5
40010908: 16 80 00 0e bge 40010940 <rtems_rfs_format+0xcc8> <== ALWAYS TAKEN
4001090c: 80 a7 60 00 cmp %i5, 0
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
40010910: 40 00 3e 0d call 40020144 <__errno> <== NOT EXECUTED
40010914: 01 00 00 00 nop <== NOT EXECUTED
40010918: 40 00 3e 0b call 40020144 <__errno> <== NOT EXECUTED
4001091c: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
40010920: 40 00 47 ce call 40022858 <strerror> <== NOT EXECUTED
40010924: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40010928: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001092c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010930: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010934: 40 00 43 5d call 400216a8 <printf> <== NOT EXECUTED
40010938: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 400332a0 <_CPU_Trap_slot_template+0x880><== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
4001093c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
40010940: 24 80 00 0c ble,a 40010970 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
40010944: b0 10 20 00 clr %i0
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
40010948: 40 00 47 c4 call 40022858 <strerror> <== NOT EXECUTED
4001094c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40010950: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010954: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010958: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400332d8 <_CPU_Trap_slot_template+0x8b8><== NOT EXECUTED
4001095c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010960: 40 00 43 52 call 400216a8 <printf> <== NOT EXECUTED
40010964: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40010968: 30 80 00 02 b,a 40010970 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
4001096c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40010970: 81 c7 e0 08 ret
40010974: 81 e8 00 00 restore
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
40010978: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
4001097c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40010980: 80 a0 60 00 cmp %g1, 0
40010984: 02 bf fd d0 be 400100c4 <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
40010988: d2 07 bf 84 ld [ %fp + -124 ], %o1
4001098c: 30 bf fd 6f b,a 4000ff48 <rtems_rfs_format+0x2d0> <== NOT EXECUTED
4001db70 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001db70: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
4001db74: 90 10 20 00 clr %o0
4001db78: 7f ff d4 06 call 40012b90 <rtems_rfs_trace>
4001db7c: 92 10 20 02 mov 2, %o1
4001db80: 80 8a 20 ff btst 0xff, %o0
4001db84: 22 80 00 06 be,a 4001db9c <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
4001db88: b8 10 20 00 clr %i4
printf ("rtems-rfs: close\n");
4001db8c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001db90: 40 00 0f 5e call 40021908 <puts> <== NOT EXECUTED
4001db94: 90 12 23 98 or %o0, 0x398, %o0 ! 40035798 <CSWTCH.2+0x13e8><== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001db98: b8 10 20 00 clr %i4 <== NOT EXECUTED
4001db9c: 10 80 00 07 b 4001dbb8 <rtems_rfs_fs_close+0x48>
4001dba0: ba 10 20 00 clr %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
rtems_rfs_group_close (fs, &fs->groups[group]);
4001dba4: 90 10 00 18 mov %i0, %o0
4001dba8: 92 02 40 1c add %o1, %i4, %o1
4001dbac: 7f ff cb f7 call 40010b88 <rtems_rfs_group_close>
4001dbb0: ba 07 60 01 inc %i5
4001dbb4: b8 07 20 50 add %i4, 0x50, %i4
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
4001dbb8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001dbbc: 80 a7 40 01 cmp %i5, %g1
4001dbc0: 26 bf ff f9 bl,a 4001dba4 <rtems_rfs_fs_close+0x34>
4001dbc4: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
4001dbc8: 7f ff f5 4b call 4001b0f4 <rtems_rfs_buffer_close>
4001dbcc: 90 10 00 18 mov %i0, %o0
free (fs);
4001dbd0: 90 10 00 18 mov %i0, %o0
4001dbd4: 7f ff a6 dc call 40007744 <free>
4001dbd8: b0 10 20 00 clr %i0
return 0;
}
4001dbdc: 81 c7 e0 08 ret
4001dbe0: 81 e8 00 00 restore
4001d384 <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)
{
4001d384: 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))
4001d388: 90 10 20 00 clr %o0
4001d38c: 7f ff d6 01 call 40012b90 <rtems_rfs_trace>
4001d390: 92 10 20 01 mov 1, %o1
4001d394: 80 8a 20 ff btst 0xff, %o0
4001d398: 02 80 00 05 be 4001d3ac <rtems_rfs_fs_open+0x28> <== ALWAYS TAKEN
4001d39c: 11 10 00 d5 sethi %hi(0x40035400), %o0
printf ("rtems-rfs: open: %s\n", name);
4001d3a0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001d3a4: 40 00 10 c1 call 400216a8 <printf> <== NOT EXECUTED
4001d3a8: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
4001d3ac: 7f ff aa 77 call 40007d88 <malloc>
4001d3b0: 90 10 20 84 mov 0x84, %o0
if (!*fs)
4001d3b4: 80 a2 20 00 cmp %o0, 0
4001d3b8: 12 80 00 0f bne 4001d3f4 <rtems_rfs_fs_open+0x70> <== ALWAYS TAKEN
4001d3bc: d0 27 00 00 st %o0, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d3c0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d3c4: 7f ff d5 f3 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d3c8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d3cc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d3d0: 02 80 00 05 be 4001d3e4 <rtems_rfs_fs_open+0x60> <== NOT EXECUTED
4001d3d4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
4001d3d8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d3dc: 40 00 11 4b call 40021908 <puts> <== NOT EXECUTED
4001d3e0: 90 12 20 70 or %o0, 0x70, %o0 ! 40035470 <CSWTCH.2+0x10c0><== NOT EXECUTED
errno = ENOMEM;
4001d3e4: 40 00 0b 58 call 40020144 <__errno> <== NOT EXECUTED
4001d3e8: 01 00 00 00 nop <== NOT EXECUTED
4001d3ec: 10 80 01 c5 b 4001db00 <rtems_rfs_fs_open+0x77c> <== NOT EXECUTED
4001d3f0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
4001d3f4: 92 10 20 00 clr %o1
4001d3f8: 40 00 10 2e call 400214b0 <memset>
4001d3fc: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
4001d400: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001d404: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
4001d408: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
4001d40c: 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;
4001d410: 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 );
4001d414: 84 00 60 44 add %g1, 0x44, %g2
4001d418: 86 00 60 48 add %g1, 0x48, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001d41c: c4 20 60 4c st %g2, [ %g1 + 0x4c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4001d420: c6 20 60 44 st %g3, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
4001d424: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001d428: 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 );
4001d42c: 84 00 60 54 add %g1, 0x54, %g2
4001d430: 86 00 60 58 add %g1, 0x58, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001d434: 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;
4001d438: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
4001d43c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001d440: 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 );
4001d444: 84 00 60 64 add %g1, 0x64, %g2
4001d448: 86 00 60 68 add %g1, 0x68, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001d44c: c4 20 60 6c st %g2, [ %g1 + 0x6c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4001d450: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
4001d454: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001d458: 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 );
4001d45c: 84 00 60 74 add %g1, 0x74, %g2
4001d460: 86 00 60 78 add %g1, 0x78, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001d464: c4 20 60 7c st %g2, [ %g1 + 0x7c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4001d468: c6 20 60 74 st %g3, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
4001d46c: d2 07 00 00 ld [ %i4 ], %o1
4001d470: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
4001d474: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
4001d478: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
4001d47c: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001d480: 7f ff f6 42 call 4001ad88 <rtems_rfs_buffer_open>
4001d484: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
4001d488: ba 92 20 00 orcc %o0, 0, %i5
4001d48c: 04 80 00 16 ble 4001d4e4 <rtems_rfs_fs_open+0x160> <== ALWAYS TAKEN
4001d490: f6 07 00 00 ld [ %i4 ], %i3
{
free (*fs);
4001d494: 7f ff a8 ac call 40007744 <free> <== NOT EXECUTED
4001d498: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d49c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d4a0: 7f ff d5 bc call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d4a4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d4a8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d4ac: 02 80 00 09 be 4001d4d0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001d4b0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
4001d4b4: 40 00 14 e9 call 40022858 <strerror> <== NOT EXECUTED
4001d4b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d4bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d4c0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d4c4: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400354a0 <CSWTCH.2+0x10f0><== NOT EXECUTED
4001d4c8: 40 00 10 78 call 400216a8 <printf> <== NOT EXECUTED
4001d4cc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
4001d4d0: 40 00 0b 1d call 40020144 <__errno> <== NOT EXECUTED
4001d4d4: 01 00 00 00 nop <== NOT EXECUTED
4001d4d8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
4001d4dc: 81 c7 e0 08 ret <== NOT EXECUTED
4001d4e0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001d4e4: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
4001d4e8: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
4001d4ec: 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);
4001d4f0: 90 10 00 1b mov %i3, %o0
4001d4f4: 92 07 bf cc add %fp, -52, %o1
4001d4f8: 94 10 20 00 clr %o2
4001d4fc: 7f ff f5 7d call 4001aaf0 <rtems_rfs_buffer_handle_request>
4001d500: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001d504: ba 92 20 00 orcc %o0, 0, %i5
4001d508: 04 80 00 0d ble 4001d53c <rtems_rfs_fs_open+0x1b8> <== ALWAYS TAKEN
4001d50c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d510: 7f ff d5 a0 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d514: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d518: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d51c: 22 80 01 2d be,a 4001d9d0 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001d520: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
4001d524: 40 00 14 cd call 40022858 <strerror> <== NOT EXECUTED
4001d528: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d52c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d530: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d534: 10 80 00 de b 4001d8ac <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
4001d538: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400354d0 <CSWTCH.2+0x1120><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
4001d53c: c2 07 bf d4 ld [ %fp + -44 ], %g1
4001d540: 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)
4001d544: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001d548: c4 0f 40 00 ldub [ %i5 ], %g2
4001d54c: 83 28 60 10 sll %g1, 0x10, %g1
4001d550: 85 28 a0 18 sll %g2, 0x18, %g2
4001d554: 84 10 80 01 or %g2, %g1, %g2
4001d558: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
4001d55c: 84 10 80 01 or %g2, %g1, %g2
4001d560: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
4001d564: 83 28 60 08 sll %g1, 8, %g1
4001d568: 84 10 80 01 or %g2, %g1, %g2
4001d56c: 03 0a 02 48 sethi %hi(0x28092000), %g1
4001d570: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_SIZE+0x27c92001>
4001d574: 80 a0 80 01 cmp %g2, %g1
4001d578: 22 80 00 0b be,a 4001d5a4 <rtems_rfs_fs_open+0x220> <== ALWAYS TAKEN
4001d57c: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d580: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d584: 7f ff d5 83 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d588: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d58c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d590: 22 80 00 57 be,a 4001d6ec <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001d594: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
4001d598: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d59c: 10 80 00 2f b 4001d658 <rtems_rfs_fs_open+0x2d4> <== NOT EXECUTED
4001d5a0: 90 12 21 08 or %o0, 0x108, %o0 ! 40035508 <CSWTCH.2+0x1158><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
4001d5a4: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
4001d5a8: 83 28 60 10 sll %g1, 0x10, %g1
4001d5ac: 97 2a e0 18 sll %o3, 0x18, %o3
4001d5b0: 96 12 c0 01 or %o3, %g1, %o3
4001d5b4: c2 0f 60 0f ldub [ %i5 + 0xf ], %g1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
4001d5b8: 94 10 20 00 clr %o2
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
4001d5bc: 96 12 c0 01 or %o3, %g1, %o3
4001d5c0: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
4001d5c4: 90 10 20 00 clr %o0
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
4001d5c8: 83 28 60 08 sll %g1, 8, %g1
4001d5cc: 96 12 c0 01 or %o3, %g1, %o3
4001d5d0: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001d5d4: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
4001d5d8: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
4001d5dc: 83 28 60 10 sll %g1, 0x10, %g1
4001d5e0: b5 2e a0 18 sll %i2, 0x18, %i2
4001d5e4: b4 16 80 01 or %i2, %g1, %i2
4001d5e8: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
4001d5ec: b4 16 80 01 or %i2, %g1, %i2
4001d5f0: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
4001d5f4: 83 28 60 08 sll %g1, 8, %g1
4001d5f8: b4 16 80 01 or %i2, %g1, %i2
4001d5fc: 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;
4001d600: 40 00 42 8e call 4002e038 <__muldi3>
4001d604: 92 10 00 1a mov %i2, %o1
4001d608: b2 10 00 08 mov %o0, %i1
4001d60c: b0 10 00 09 mov %o1, %i0
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
4001d610: 7f ff ff 53 call 4001d35c <rtems_rfs_fs_media_size>
4001d614: 90 10 00 1b mov %i3, %o0
4001d618: 80 a6 40 08 cmp %i1, %o0
4001d61c: 38 80 00 08 bgu,a 4001d63c <rtems_rfs_fs_open+0x2b8> <== NEVER TAKEN
4001d620: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d624: 32 80 00 11 bne,a 4001d668 <rtems_rfs_fs_open+0x2e4> <== NEVER TAKEN
4001d628: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
4001d62c: 80 a6 00 09 cmp %i0, %o1
4001d630: 28 80 00 0e bleu,a 4001d668 <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
4001d634: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d638: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d63c: 7f ff d5 55 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d640: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d644: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d648: 22 80 00 29 be,a 4001d6ec <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001d64c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
4001d650: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d654: 90 12 21 48 or %o0, 0x148, %o0 ! 40035548 <CSWTCH.2+0x1198><== NOT EXECUTED
4001d658: 40 00 10 ac call 40021908 <puts> <== NOT EXECUTED
4001d65c: 01 00 00 00 nop <== NOT EXECUTED
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
4001d660: 10 80 00 23 b 4001d6ec <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001d664: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
4001d668: c2 0f 60 25 ldub [ %i5 + 0x25 ], %g1
4001d66c: 85 28 a0 18 sll %g2, 0x18, %g2
4001d670: 83 28 60 10 sll %g1, 0x10, %g1
4001d674: 82 10 80 01 or %g2, %g1, %g1
4001d678: c4 0f 60 27 ldub [ %i5 + 0x27 ], %g2
4001d67c: 82 10 40 02 or %g1, %g2, %g1
4001d680: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
4001d684: 85 28 a0 08 sll %g2, 8, %g2
4001d688: 82 10 40 02 or %g1, %g2, %g1
4001d68c: 80 a0 60 38 cmp %g1, 0x38
4001d690: 22 80 00 1b be,a 4001d6fc <rtems_rfs_fs_open+0x378> <== ALWAYS TAKEN
4001d694: c4 0f 60 10 ldub [ %i5 + 0x10 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d698: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d69c: 7f ff d5 3d call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d6a0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d6a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d6a8: 22 80 00 11 be,a 4001d6ec <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001d6ac: 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);
4001d6b0: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
4001d6b4: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
4001d6b8: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
4001d6bc: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
4001d6c0: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
4001d6c4: c2 0f 60 07 ldub [ %i5 + 7 ], %g1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001d6c8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001d6cc: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
4001d6d0: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001d6d4: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001d6d8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001d6dc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001d6e0: 40 00 0f f2 call 400216a8 <printf> <== NOT EXECUTED
4001d6e4: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
4001d6e8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001d6ec: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001d6f0: 7f ff ff 08 call 4001d310 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001d6f4: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
4001d6f8: 30 80 00 b8 b,a 4001d9d8 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
4001d6fc: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
4001d700: 85 28 a0 18 sll %g2, 0x18, %g2
4001d704: 83 28 60 10 sll %g1, 0x10, %g1
4001d708: 82 10 80 01 or %g2, %g1, %g1
4001d70c: c4 0f 60 13 ldub [ %i5 + 0x13 ], %g2
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
4001d710: 91 36 a0 02 srl %i2, 2, %o0
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
4001d714: 82 10 40 02 or %g1, %g2, %g1
4001d718: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001d71c: 92 10 00 08 mov %o0, %o1
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
4001d720: 85 28 a0 08 sll %g2, 8, %g2
4001d724: 82 10 40 02 or %g1, %g2, %g1
4001d728: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
4001d72c: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
4001d730: c2 0f 60 15 ldub [ %i5 + 0x15 ], %g1
4001d734: 85 28 a0 18 sll %g2, 0x18, %g2
4001d738: 83 28 60 10 sll %g1, 0x10, %g1
4001d73c: 82 10 80 01 or %g2, %g1, %g1
4001d740: c4 0f 60 17 ldub [ %i5 + 0x17 ], %g2
4001d744: 82 10 40 02 or %g1, %g2, %g1
4001d748: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
4001d74c: 85 28 a0 08 sll %g2, 8, %g2
4001d750: 82 10 40 02 or %g1, %g2, %g1
4001d754: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
4001d758: c2 0f 60 19 ldub [ %i5 + 0x19 ], %g1
4001d75c: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
4001d760: 83 28 60 10 sll %g1, 0x10, %g1
4001d764: b1 2e 20 18 sll %i0, 0x18, %i0
4001d768: b0 16 00 01 or %i0, %g1, %i0
4001d76c: c2 0f 60 1b ldub [ %i5 + 0x1b ], %g1
4001d770: b0 16 00 01 or %i0, %g1, %i0
4001d774: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
4001d778: 83 28 60 08 sll %g1, 8, %g1
4001d77c: b0 16 00 01 or %i0, %g1, %i0
4001d780: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
4001d784: c2 0f 60 1d ldub [ %i5 + 0x1d ], %g1
4001d788: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
4001d78c: 83 28 60 10 sll %g1, 0x10, %g1
4001d790: b3 2e 60 18 sll %i1, 0x18, %i1
4001d794: b2 16 40 01 or %i1, %g1, %i1
4001d798: c2 0f 60 1f ldub [ %i5 + 0x1f ], %g1
4001d79c: b2 16 40 01 or %i1, %g1, %i1
4001d7a0: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
4001d7a4: 83 28 60 08 sll %g1, 8, %g1
4001d7a8: b2 16 40 01 or %i1, %g1, %i1
4001d7ac: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001d7b0: c2 0f 60 21 ldub [ %i5 + 0x21 ], %g1
4001d7b4: c4 0f 60 20 ldub [ %i5 + 0x20 ], %g2
4001d7b8: 83 28 60 10 sll %g1, 0x10, %g1
4001d7bc: 85 28 a0 18 sll %g2, 0x18, %g2
4001d7c0: 84 10 80 01 or %g2, %g1, %g2
4001d7c4: c2 0f 60 23 ldub [ %i5 + 0x23 ], %g1
4001d7c8: 84 10 80 01 or %g2, %g1, %g2
4001d7cc: c2 0f 60 22 ldub [ %i5 + 0x22 ], %g1
fs->blocks_per_block =
4001d7d0: d0 26 e0 34 st %o0, [ %i3 + 0x34 ]
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001d7d4: 83 28 60 08 sll %g1, 8, %g1
4001d7d8: ba 10 80 01 or %g2, %g1, %i5
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001d7dc: 85 2a 20 02 sll %o0, 2, %g2
4001d7e0: 84 00 80 08 add %g2, %o0, %g2
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001d7e4: fa 26 e0 2c st %i5, [ %i3 + 0x2c ]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001d7e8: 7f ff 93 6b call 40002594 <.umul>
4001d7ec: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
4001d7f0: 83 2a 20 02 sll %o0, 2, %g1
4001d7f4: 90 00 40 08 add %g1, %o0, %o0
fs->inodes = fs->group_count * fs->group_inodes;
4001d7f8: 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 =
4001d7fc: d0 26 e0 3c st %o0, [ %i3 + 0x3c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
4001d800: 7f ff 93 65 call 40002594 <.umul>
4001d804: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001d808: 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;
4001d80c: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001d810: 7f ff 93 9b call 4000267c <.udiv>
4001d814: 90 10 00 1a mov %i2, %o0
4001d818: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
4001d81c: b5 2e a0 03 sll %i2, 3, %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001d820: 90 10 00 1b mov %i3, %o0
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
4001d824: 80 a6 40 1a cmp %i1, %i2
4001d828: 08 80 00 0c bleu 4001d858 <rtems_rfs_fs_open+0x4d4> <== ALWAYS TAKEN
4001d82c: 92 07 bf cc add %fp, -52, %o1
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001d830: 7f ff fe b8 call 4001d310 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001d834: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d838: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d83c: 7f ff d4 d5 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d840: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d844: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d848: 02 80 00 64 be 4001d9d8 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
4001d84c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
4001d850: 10 80 00 2e b 4001d908 <rtems_rfs_fs_open+0x584> <== NOT EXECUTED
4001d854: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400355d0 <CSWTCH.2+0x1220><== NOT EXECUTED
return EIO;
}
rtems_rfs_buffer_handle_close (fs, &handle);
4001d858: 7f ff fe ae call 4001d310 <rtems_rfs_buffer_handle_close>
4001d85c: 01 00 00 00 nop
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
4001d860: d2 06 e0 08 ld [ %i3 + 8 ], %o1
4001d864: 7f ff f5 e9 call 4001b008 <rtems_rfs_buffer_setblksize>
4001d868: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001d86c: ba 92 20 00 orcc %o0, 0, %i5
4001d870: 04 80 00 13 ble 4001d8bc <rtems_rfs_fs_open+0x538> <== ALWAYS TAKEN
4001d874: 92 07 bf cc add %fp, -52, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001d878: 7f ff fe a6 call 4001d310 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001d87c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d880: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d884: 7f ff d4 c3 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d888: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d88c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d890: 22 80 00 50 be,a 4001d9d0 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001d894: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
4001d898: 40 00 13 f0 call 40022858 <strerror> <== NOT EXECUTED
4001d89c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d8a0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d8a4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d8a8: 90 12 22 18 or %o0, 0x218, %o0 ! 40035618 <CSWTCH.2+0x1268><== NOT EXECUTED
4001d8ac: 40 00 0f 7f call 400216a8 <printf> <== NOT EXECUTED
4001d8b0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
4001d8b4: 10 80 00 47 b 4001d9d0 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001d8b8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
4001d8bc: d0 06 e0 24 ld [ %i3 + 0x24 ], %o0
4001d8c0: 7f ff a7 3d call 400075b4 <calloc>
4001d8c4: 92 10 20 50 mov 0x50, %o1
4001d8c8: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if (!fs->groups)
4001d8cc: b2 10 20 00 clr %i1
4001d8d0: 80 a2 20 00 cmp %o0, 0
4001d8d4: 12 80 00 39 bne 4001d9b8 <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
4001d8d8: b4 10 20 00 clr %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001d8dc: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001d8e0: 7f ff fe 8c call 4001d310 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001d8e4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d8e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d8ec: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d8f0: 7f ff d4 a8 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d8f4: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
4001d8f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d8fc: 02 80 00 37 be 4001d9d8 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
4001d900: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
4001d904: 90 12 22 60 or %o0, 0x260, %o0 ! 40035660 <CSWTCH.2+0x12b0><== NOT EXECUTED
4001d908: 40 00 10 00 call 40021908 <puts> <== NOT EXECUTED
4001d90c: 01 00 00 00 nop <== NOT EXECUTED
4001d910: 30 80 00 32 b,a 4001d9d8 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
4001d914: 90 10 00 1a mov %i2, %o0
4001d918: 7f ff 93 1f call 40002594 <.umul>
4001d91c: 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,
4001d920: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
4001d924: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
4001d928: 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,
4001d92c: 94 10 00 1d mov %i5, %o2
4001d930: 98 03 00 19 add %o4, %i1, %o4
4001d934: 90 10 00 1b mov %i3, %o0
4001d938: 7f ff cc 16 call 40010990 <rtems_rfs_group_open>
4001d93c: b2 06 60 50 add %i1, 0x50, %i1
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
4001d940: 80 a2 20 00 cmp %o0, 0
4001d944: 04 80 00 1c ble 4001d9b4 <rtems_rfs_fs_open+0x630> <== ALWAYS TAKEN
4001d948: ba 10 00 08 mov %o0, %i5
4001d94c: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001d950: 10 80 00 07 b 4001d96c <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
4001d954: b2 10 20 00 clr %i1 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
4001d958: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001d95c: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
4001d960: 7f ff cc 8a call 40010b88 <rtems_rfs_group_close> <== NOT EXECUTED
4001d964: b2 06 60 01 inc %i1 <== NOT EXECUTED
4001d968: b0 06 20 50 add %i0, 0x50, %i0 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
4001d96c: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
4001d970: 26 bf ff fa bl,a 4001d958 <rtems_rfs_fs_open+0x5d4> <== NOT EXECUTED
4001d974: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
4001d978: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001d97c: 7f ff fe 65 call 4001d310 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001d980: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d984: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d988: 7f ff d4 82 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d98c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d990: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d994: 22 80 00 0f be,a 4001d9d0 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001d998: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
4001d99c: 40 00 13 af call 40022858 <strerror> <== NOT EXECUTED
4001d9a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d9a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d9a8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001d9ac: 10 bf ff c0 b 4001d8ac <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
4001d9b0: 90 12 22 98 or %o0, 0x298, %o0 ! 40035698 <CSWTCH.2+0x12e8><== NOT EXECUTED
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
4001d9b4: b4 06 a0 01 inc %i2
4001d9b8: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
4001d9bc: 80 a6 80 01 cmp %i2, %g1
4001d9c0: 26 bf ff d5 bl,a 4001d914 <rtems_rfs_fs_open+0x590>
4001d9c4: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001d9c8: 10 80 00 14 b 4001da18 <rtems_rfs_fs_open+0x694>
4001d9cc: d0 07 00 00 ld [ %i4 ], %o0
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
4001d9d0: 22 80 00 12 be,a 4001da18 <rtems_rfs_fs_open+0x694> <== NOT EXECUTED
4001d9d4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
4001d9d8: 7f ff f5 c7 call 4001b0f4 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001d9dc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001d9e0: 7f ff a7 59 call 40007744 <free> <== NOT EXECUTED
4001d9e4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001d9e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d9ec: 7f ff d4 69 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001d9f0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001d9f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d9f8: 02 bf fe b6 be 4001d4d0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001d9fc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
4001da00: 40 00 13 96 call 40022858 <strerror> <== NOT EXECUTED
4001da04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001da08: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001da0c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001da10: 10 bf fe ae b 4001d4c8 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
4001da14: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400356d8 <CSWTCH.2+0x1328><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001da18: 92 10 20 01 mov 1, %o1
4001da1c: 94 07 bf d8 add %fp, -40, %o2
4001da20: 7f ff cd d3 call 4001116c <rtems_rfs_inode_open>
4001da24: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001da28: ba 92 20 00 orcc %o0, 0, %i5
4001da2c: 04 80 00 12 ble 4001da74 <rtems_rfs_fs_open+0x6f0> <== ALWAYS TAKEN
4001da30: d0 07 00 00 ld [ %i4 ], %o0
{
rtems_rfs_buffer_close (*fs);
4001da34: 7f ff f5 b0 call 4001b0f4 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001da38: 01 00 00 00 nop <== NOT EXECUTED
free (*fs);
4001da3c: 7f ff a7 42 call 40007744 <free> <== NOT EXECUTED
4001da40: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001da44: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001da48: 7f ff d4 52 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001da4c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001da50: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001da54: 02 bf fe 9f be 4001d4d0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001da58: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
4001da5c: 40 00 13 7f call 40022858 <strerror> <== NOT EXECUTED
4001da60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001da64: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001da68: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001da6c: 10 bf fe 97 b 4001d4c8 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
4001da70: 90 12 23 08 or %o0, 0x308, %o0 ! 40035708 <CSWTCH.2+0x1358><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
4001da74: c2 02 00 00 ld [ %o0 ], %g1
4001da78: 80 88 60 04 btst 4, %g1
4001da7c: 12 80 00 23 bne 4001db08 <rtems_rfs_fs_open+0x784>
4001da80: c4 07 bf e4 ld [ %fp + -28 ], %g2
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4001da84: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
4001da88: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
4001da8c: 83 28 60 08 sll %g1, 8, %g1
4001da90: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
4001da94: 05 3f ff c0 sethi %hi(0xffff0000), %g2
4001da98: 87 28 60 10 sll %g1, 0x10, %g3
4001da9c: 80 a0 c0 02 cmp %g3, %g2
4001daa0: 02 80 00 07 be 4001dabc <rtems_rfs_fs_open+0x738> <== NEVER TAKEN
4001daa4: 05 00 00 3c sethi %hi(0xf000), %g2
4001daa8: 82 08 40 02 and %g1, %g2, %g1
4001daac: 05 00 00 10 sethi %hi(0x4000), %g2
4001dab0: 80 a0 40 02 cmp %g1, %g2
4001dab4: 02 80 00 15 be 4001db08 <rtems_rfs_fs_open+0x784> <== ALWAYS TAKEN
4001dab8: 01 00 00 00 nop
{
rtems_rfs_inode_close (*fs, &inode);
4001dabc: 7f ff ce 1e call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001dac0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001dac4: 7f ff f5 8c call 4001b0f4 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001dac8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001dacc: 7f ff a7 1e call 40007744 <free> <== NOT EXECUTED
4001dad0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001dad4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001dad8: 7f ff d4 2e call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001dadc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001dae0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001dae4: 02 80 00 04 be 4001daf4 <rtems_rfs_fs_open+0x770> <== NOT EXECUTED
4001dae8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
4001daec: 40 00 0f 87 call 40021908 <puts> <== NOT EXECUTED
4001daf0: 90 12 23 38 or %o0, 0x338, %o0 ! 40035738 <CSWTCH.2+0x1388><== NOT EXECUTED
errno = EIO;
4001daf4: 40 00 09 94 call 40020144 <__errno> <== NOT EXECUTED
4001daf8: 01 00 00 00 nop <== NOT EXECUTED
4001dafc: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
4001db00: 10 bf fe 77 b 4001d4dc <rtems_rfs_fs_open+0x158> <== NOT EXECUTED
4001db04: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
4001db08: 7f ff ce 0b call 40011334 <rtems_rfs_inode_close>
4001db0c: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001db10: ba 92 20 00 orcc %o0, 0, %i5
4001db14: 04 80 00 12 ble 4001db5c <rtems_rfs_fs_open+0x7d8> <== ALWAYS TAKEN
4001db18: 01 00 00 00 nop
{
rtems_rfs_buffer_close (*fs);
4001db1c: 7f ff f5 76 call 4001b0f4 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001db20: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001db24: 7f ff a7 08 call 40007744 <free> <== NOT EXECUTED
4001db28: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001db2c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001db30: 7f ff d4 18 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001db34: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001db38: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001db3c: 02 bf fe 65 be 4001d4d0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001db40: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
4001db44: 40 00 13 45 call 40022858 <strerror> <== NOT EXECUTED
4001db48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001db4c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001db50: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001db54: 10 bf fe 5d b 4001d4c8 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
4001db58: 90 12 23 68 or %o0, 0x368, %o0 ! 40035768 <CSWTCH.2+0x13b8><== NOT EXECUTED
errno = rc;
return -1;
}
errno = 0;
4001db5c: 40 00 09 7a call 40020144 <__errno>
4001db60: b0 10 20 00 clr %i0
4001db64: c0 22 00 00 clr [ %o0 ]
return 0;
}
4001db68: 81 c7 e0 08 ret
4001db6c: 81 e8 00 00 restore
4001d338 <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)
{
4001d338: 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;
4001d33c: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
4001d340: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
4001d344: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001d348: 40 00 43 3c call 4002e038 <__muldi3> <== NOT EXECUTED
4001d34c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
4001d350: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4001d354: 81 c7 e0 08 ret <== NOT EXECUTED
4001d358: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
40010c18 <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)
{
40010c18: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40010c1c: 80 a6 a0 00 cmp %i2, 0
40010c20: 02 80 00 05 be 40010c34 <rtems_rfs_group_bitmap_alloc+0x1c>
40010c24: ba 10 00 18 mov %i0, %i5
{
size = fs->group_inodes;
40010c28: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
40010c2c: 10 80 00 03 b 40010c38 <rtems_rfs_group_bitmap_alloc+0x20>
40010c30: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
40010c34: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
group_start = goal / size;
40010c38: 92 10 00 11 mov %l1, %o1
40010c3c: 7f ff c6 90 call 4000267c <.udiv>
40010c40: 90 10 00 19 mov %i1, %o0
bit = (rtems_rfs_bitmap_bit) (goal % size);
40010c44: 92 10 00 11 mov %l1, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
40010c48: a8 10 00 08 mov %o0, %l4
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
40010c4c: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40010c50: 90 10 00 19 mov %i1, %o0
40010c54: 40 00 74 4d call 4002dd88 <.urem>
40010c58: a4 10 20 01 mov 1, %l2
offset = 0;
40010c5c: a0 10 20 00 clr %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40010c60: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40010c64: 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);
40010c68: 90 10 00 1c mov %i4, %o0
40010c6c: 7f ff c6 4a call 40002594 <.umul>
40010c70: 92 10 00 10 mov %l0, %o1
if (offset)
40010c74: 80 a4 20 00 cmp %l0, 0
40010c78: 02 80 00 07 be 40010c94 <rtems_rfs_group_bitmap_alloc+0x7c>
40010c7c: b2 05 00 08 add %l4, %o0, %i1
bit = direction > 0 ? 0 : size - 1;
40010c80: 80 a7 20 00 cmp %i4, 0
40010c84: 14 80 00 03 bg 40010c90 <rtems_rfs_group_bitmap_alloc+0x78>
40010c88: 82 10 20 00 clr %g1
40010c8c: 82 04 7f ff add %l1, -1, %g1
40010c90: 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))
40010c94: 80 a6 60 00 cmp %i1, 0
40010c98: 06 80 00 07 bl 40010cb4 <rtems_rfs_group_bitmap_alloc+0x9c>
40010c9c: 80 8c a0 ff btst 0xff, %l2
40010ca0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40010ca4: 80 a6 40 01 cmp %i1, %g1
40010ca8: 26 80 00 0a bl,a 40010cd0 <rtems_rfs_group_bitmap_alloc+0xb8>
40010cac: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
{
if (!updown)
40010cb0: 80 8c a0 ff btst 0xff, %l2
40010cb4: 02 80 00 50 be 40010df4 <rtems_rfs_group_bitmap_alloc+0x1dc>
40010cb8: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
40010cbc: 24 80 00 03 ble,a 40010cc8 <rtems_rfs_group_bitmap_alloc+0xb0><== ALWAYS TAKEN
40010cc0: b8 10 20 01 mov 1, %i4
40010cc4: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
updown = false;
40010cc8: 10 bf ff e7 b 40010c64 <rtems_rfs_group_bitmap_alloc+0x4c>
40010ccc: a4 10 20 00 clr %l2
40010cd0: a7 2e 60 04 sll %i1, 4, %l3
40010cd4: 85 2e 60 06 sll %i1, 6, %g2
continue;
}
if (inode)
40010cd8: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
40010cdc: a6 04 c0 02 add %l3, %g2, %l3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
40010ce0: 02 80 00 04 be 40010cf0 <rtems_rfs_group_bitmap_alloc+0xd8>
40010ce4: a6 00 40 13 add %g1, %l3, %l3
bitmap = &fs->groups[group].inode_bitmap;
40010ce8: 10 80 00 03 b 40010cf4 <rtems_rfs_group_bitmap_alloc+0xdc>
40010cec: a6 04 e0 2c add %l3, 0x2c, %l3
else
bitmap = &fs->groups[group].block_bitmap;
40010cf0: a6 04 e0 08 add %l3, 8, %l3
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
40010cf4: d2 07 bf fc ld [ %fp + -4 ], %o1
40010cf8: 90 10 00 13 mov %l3, %o0
40010cfc: 94 07 bf fb add %fp, -5, %o2
40010d00: 40 00 21 fe call 400194f8 <rtems_rfs_bitmap_map_alloc>
40010d04: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
40010d08: b0 92 20 00 orcc %o0, 0, %i0
40010d0c: 14 80 00 45 bg 40010e20 <rtems_rfs_group_bitmap_alloc+0x208><== NEVER TAKEN
40010d10: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
40010d14: c2 07 40 00 ld [ %i5 ], %g1
40010d18: 80 88 60 01 btst 1, %g1
40010d1c: 12 80 00 06 bne 40010d34 <rtems_rfs_group_bitmap_alloc+0x11c><== NEVER TAKEN
40010d20: c2 0f bf fb ldub [ %fp + -5 ], %g1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40010d24: d2 04 c0 00 ld [ %l3 ], %o1
40010d28: 40 00 26 fe call 4001a920 <rtems_rfs_buffer_handle_release>
40010d2c: 90 10 00 1d mov %i5, %o0
if (allocated)
40010d30: c2 0f bf fb ldub [ %fp + -5 ], %g1
40010d34: 80 a0 60 00 cmp %g1, 0
40010d38: 02 80 00 27 be 40010dd4 <rtems_rfs_group_bitmap_alloc+0x1bc>
40010d3c: 80 8c a0 ff btst 0xff, %l2
{
if (inode)
40010d40: 80 a6 a0 00 cmp %i2, 0
40010d44: 02 80 00 09 be 40010d68 <rtems_rfs_group_bitmap_alloc+0x150>
40010d48: c2 07 bf fc ld [ %fp + -4 ], %g1
*result = rtems_rfs_group_inode (fs, group, bit);
40010d4c: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
40010d50: b8 00 60 01 add %g1, 1, %i4
40010d54: 7f ff c6 10 call 40002594 <.umul>
40010d58: 90 10 00 19 mov %i1, %o0
40010d5c: 90 07 00 08 add %i4, %o0, %o0
40010d60: 10 80 00 09 b 40010d84 <rtems_rfs_group_bitmap_alloc+0x16c>
40010d64: d0 26 c0 00 st %o0, [ %i3 ]
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
40010d68: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40010d6c: 87 2e 60 04 sll %i1, 4, %g3
40010d70: b3 2e 60 06 sll %i1, 6, %i1
40010d74: b2 00 c0 19 add %g3, %i1, %i1
40010d78: c4 00 80 19 ld [ %g2 + %i1 ], %g2
40010d7c: 82 00 40 02 add %g1, %g2, %g1
40010d80: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40010d84: 90 10 20 00 clr %o0
40010d88: 13 00 00 80 sethi %hi(0x20000), %o1
40010d8c: 40 00 07 81 call 40012b90 <rtems_rfs_trace>
40010d90: b0 10 20 00 clr %i0
40010d94: 80 8a 20 ff btst 0xff, %o0
40010d98: 02 80 00 0d be 40010dcc <rtems_rfs_group_bitmap_alloc+0x1b4><== ALWAYS TAKEN
40010d9c: 80 a6 a0 00 cmp %i2, 0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40010da0: 22 80 00 05 be,a 40010db4 <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
40010da4: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED
40010da8: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED
40010dac: 10 80 00 03 b 40010db8 <rtems_rfs_group_bitmap_alloc+0x1a0><== NOT EXECUTED
40010db0: 92 12 60 30 or %o1, 0x30, %o1 ! 40033430 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
40010db4: 92 12 60 38 or %o1, 0x38, %o1 <== NOT EXECUTED
40010db8: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
40010dbc: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
40010dc0: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40010dc4: 40 00 42 39 call 400216a8 <printf> <== NOT EXECUTED
40010dc8: 90 12 20 40 or %o0, 0x40, %o0 <== NOT EXECUTED
40010dcc: 81 c7 e0 08 ret
40010dd0: 81 e8 00 00 restore
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
40010dd4: 22 bf ff a4 be,a 40010c64 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
40010dd8: a0 04 20 01 inc %l0 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40010ddc: 80 a7 20 00 cmp %i4, 0
40010de0: 24 80 00 03 ble,a 40010dec <rtems_rfs_group_bitmap_alloc+0x1d4><== NEVER TAKEN
40010de4: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
40010de8: b8 10 3f ff mov -1, %i4
offset++;
40010dec: 10 bf ff 9e b 40010c64 <rtems_rfs_group_bitmap_alloc+0x4c>
40010df0: a0 04 20 01 inc %l0
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40010df4: 90 10 20 00 clr %o0
40010df8: 40 00 07 66 call 40012b90 <rtems_rfs_trace>
40010dfc: 13 00 00 80 sethi %hi(0x20000), %o1
40010e00: 80 8a 20 ff btst 0xff, %o0
40010e04: 12 80 00 04 bne 40010e14 <rtems_rfs_group_bitmap_alloc+0x1fc><== NEVER TAKEN
40010e08: 11 10 00 cd sethi %hi(0x40033400), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
40010e0c: 81 c7 e0 08 ret
40010e10: 91 e8 20 1c restore %g0, 0x1c, %o0
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
40010e14: 40 00 42 bd call 40021908 <puts> <== NOT EXECUTED
40010e18: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
return ENOSPC;
40010e1c: b0 10 20 1c mov 0x1c, %i0 <== NOT EXECUTED
}
40010e20: 81 c7 e0 08 ret <== NOT EXECUTED
40010e24: 81 e8 00 00 restore <== NOT EXECUTED
40010e28 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
40010e28: 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))
40010e2c: 90 10 20 00 clr %o0
40010e30: 13 00 00 80 sethi %hi(0x20000), %o1
40010e34: 40 00 07 57 call 40012b90 <rtems_rfs_trace>
40010e38: ba 10 00 18 mov %i0, %i5
40010e3c: 80 8a 20 ff btst 0xff, %o0
40010e40: 02 80 00 0d be 40010e74 <rtems_rfs_group_bitmap_free+0x4c><== ALWAYS TAKEN
40010e44: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40010e48: 22 80 00 05 be,a 40010e5c <rtems_rfs_group_bitmap_free+0x34><== NOT EXECUTED
40010e4c: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED
40010e50: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED
40010e54: 10 80 00 03 b 40010e60 <rtems_rfs_group_bitmap_free+0x38> <== NOT EXECUTED
40010e58: 92 12 60 30 or %o1, 0x30, %o1 ! 40033430 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
40010e5c: 92 12 60 38 or %o1, 0x38, %o1 <== NOT EXECUTED
40010e60: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40010e64: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40010e68: 40 00 42 10 call 400216a8 <printf> <== NOT EXECUTED
40010e6c: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40010e70: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40010e74: 02 80 00 04 be 40010e84 <rtems_rfs_group_bitmap_free+0x5c>
40010e78: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
40010e7c: 10 80 00 03 b 40010e88 <rtems_rfs_group_bitmap_free+0x60>
40010e80: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
40010e84: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
}
group = no / size;
40010e88: 92 10 00 1b mov %i3, %o1
40010e8c: 7f ff c5 fc call 4000267c <.udiv>
40010e90: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
40010e94: 92 10 00 1b mov %i3, %o1
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
40010e98: b0 10 00 08 mov %o0, %i0
bit = (rtems_rfs_bitmap_bit) (no % size);
40010e9c: 40 00 73 bb call 4002dd88 <.urem>
40010ea0: 90 10 00 1a mov %i2, %o0
40010ea4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40010ea8: b9 2e 20 04 sll %i0, 4, %i4
40010eac: 92 10 00 08 mov %o0, %o1
40010eb0: b1 2e 20 06 sll %i0, 6, %i0
if (inode)
40010eb4: 80 a6 60 00 cmp %i1, 0
bitmap = &fs->groups[group].inode_bitmap;
40010eb8: b8 07 00 18 add %i4, %i0, %i4
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
40010ebc: 02 80 00 04 be 40010ecc <rtems_rfs_group_bitmap_free+0xa4>
40010ec0: b8 00 40 1c add %g1, %i4, %i4
bitmap = &fs->groups[group].inode_bitmap;
40010ec4: 10 80 00 03 b 40010ed0 <rtems_rfs_group_bitmap_free+0xa8>
40010ec8: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
40010ecc: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40010ed0: 40 00 20 fe call 400192c8 <rtems_rfs_bitmap_map_clear>
40010ed4: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40010ed8: 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);
40010edc: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40010ee0: 40 00 26 90 call 4001a920 <rtems_rfs_buffer_handle_release>
40010ee4: 90 10 00 1d mov %i5, %o0
return rc;
}
40010ee8: 81 c7 e0 08 ret
40010eec: 81 e8 00 00 restore
40010ef0 <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)
{
40010ef0: 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))
40010ef4: 90 10 20 00 clr %o0 <== NOT EXECUTED
40010ef8: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
40010efc: 40 00 07 25 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
40010f00: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
40010f04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40010f08: 02 80 00 0d be 40010f3c <rtems_rfs_group_bitmap_test+0x4c><== NOT EXECUTED
40010f0c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
40010f10: 22 80 00 05 be,a 40010f24 <rtems_rfs_group_bitmap_test+0x34><== NOT EXECUTED
40010f14: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED
40010f18: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED
40010f1c: 10 80 00 03 b 40010f28 <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
40010f20: 92 12 60 30 or %o1, 0x30, %o1 ! 40033430 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
40010f24: 92 12 60 38 or %o1, 0x38, %o1 <== NOT EXECUTED
40010f28: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40010f2c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40010f30: 40 00 41 de call 400216a8 <printf> <== NOT EXECUTED
40010f34: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40010f38: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40010f3c: 22 80 00 0b be,a 40010f68 <rtems_rfs_group_bitmap_test+0x78><== NOT EXECUTED
40010f40: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
40010f44: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40010f48: 04 80 00 25 ble 40010fdc <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
40010f4c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
40010f50: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
40010f54: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
40010f58: 18 80 00 21 bgu 40010fdc <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
40010f5c: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
40010f60: 10 80 00 06 b 40010f78 <rtems_rfs_group_bitmap_test+0x88> <== NOT EXECUTED
40010f64: f0 07 60 2c ld [ %i5 + 0x2c ], %i0 <== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
40010f68: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
40010f6c: 1a 80 00 1c bcc 40010fdc <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
40010f70: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
40010f74: f0 07 60 28 ld [ %i5 + 0x28 ], %i0 <== NOT EXECUTED
}
group = no / size;
40010f78: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40010f7c: 7f ff c5 c0 call 4000267c <.udiv> <== NOT EXECUTED
40010f80: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
40010f84: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
40010f88: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
40010f8c: 40 00 73 7f call 4002dd88 <.urem> <== NOT EXECUTED
40010f90: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40010f94: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
40010f98: b9 2c 20 04 sll %l0, 4, %i4 <== NOT EXECUTED
40010f9c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40010fa0: a1 2c 20 06 sll %l0, 6, %l0 <== NOT EXECUTED
if (inode)
40010fa4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
40010fa8: b8 07 00 10 add %i4, %l0, %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
40010fac: 02 80 00 04 be 40010fbc <rtems_rfs_group_bitmap_test+0xcc><== NOT EXECUTED
40010fb0: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
40010fb4: 10 80 00 03 b 40010fc0 <rtems_rfs_group_bitmap_test+0xd0> <== NOT EXECUTED
40010fb8: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
40010fbc: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
40010fc0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40010fc4: 40 00 20 e4 call 40019354 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
40010fc8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40010fcc: 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);
40010fd0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40010fd4: 40 00 26 53 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40010fd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
40010fdc: 81 c7 e0 08 ret <== NOT EXECUTED
40010fe0: 81 e8 00 00 restore <== NOT EXECUTED
40010b88 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40010b88: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
40010b8c: 90 10 20 00 clr %o0
40010b90: 13 00 00 40 sethi %hi(0x10000), %o1
40010b94: 40 00 07 ff call 40012b90 <rtems_rfs_trace>
40010b98: ba 10 00 18 mov %i0, %i5
40010b9c: 80 8a 20 ff btst 0xff, %o0
40010ba0: 02 80 00 06 be 40010bb8 <rtems_rfs_group_close+0x30> <== ALWAYS TAKEN
40010ba4: 01 00 00 00 nop
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
40010ba8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40010bac: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40010bb0: 40 00 42 be call 400216a8 <printf> <== NOT EXECUTED
40010bb4: 90 12 20 08 or %o0, 8, %o0 ! 40033408 <_CPU_Trap_slot_template+0x9e8><== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
40010bb8: 40 00 22 db call 40019724 <rtems_rfs_bitmap_close>
40010bbc: 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);
40010bc0: 92 06 60 44 add %i1, 0x44, %o1
40010bc4: b8 10 00 08 mov %o0, %i4
40010bc8: 40 00 27 56 call 4001a920 <rtems_rfs_buffer_handle_release>
40010bcc: 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);
40010bd0: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
40010bd4: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
40010bd8: c0 26 60 48 clr [ %i1 + 0x48 ]
40010bdc: 40 00 22 d2 call 40019724 <rtems_rfs_bitmap_close>
40010be0: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
40010be4: b0 92 20 00 orcc %o0, 0, %i0
40010be8: 14 80 00 05 bg 40010bfc <rtems_rfs_group_close+0x74> <== NEVER TAKEN
40010bec: 90 10 00 1d mov %i5, %o0
40010bf0: b0 38 00 1c xnor %g0, %i4, %i0
40010bf4: b1 3e 20 1f sra %i0, 0x1f, %i0
40010bf8: b0 0f 00 18 and %i4, %i0, %i0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40010bfc: 40 00 27 49 call 4001a920 <rtems_rfs_buffer_handle_release>
40010c00: 92 06 60 20 add %i1, 0x20, %o1
handle->dirty = false;
40010c04: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40010c08: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
40010c0c: 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;
}
40010c10: 81 c7 e0 08 ret
40010c14: 81 e8 00 00 restore
40010990 <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)
{
40010990: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40010994: c2 06 20 04 ld [ %i0 + 4 ], %g1
40010998: 80 a6 40 01 cmp %i1, %g1
4001099c: 0a 80 00 10 bcs 400109dc <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
400109a0: 84 06 80 19 add %i2, %i1, %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
400109a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
400109a8: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
400109ac: 40 00 08 79 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
400109b0: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
400109b4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400109b8: 22 80 00 72 be,a 40010b80 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
400109bc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
400109c0: 40 00 47 a6 call 40022858 <strerror> <== NOT EXECUTED
400109c4: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
400109c8: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
400109cc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400109d0: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
400109d4: 10 80 00 36 b 40010aac <rtems_rfs_group_open+0x11c> <== NOT EXECUTED
400109d8: 90 12 23 10 or %o0, 0x310, %o0 ! 40033310 <_CPU_Trap_slot_template+0x8f0><== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
400109dc: 80 a0 80 01 cmp %g2, %g1
400109e0: 3a 80 00 02 bcc,a 400109e8 <rtems_rfs_group_open+0x58> <== ALWAYS TAKEN
400109e4: b4 20 40 19 sub %g1, %i1, %i2
400109e8: 80 a6 80 1b cmp %i2, %i3
400109ec: 08 80 00 03 bleu 400109f8 <rtems_rfs_group_open+0x68> <== NEVER TAKEN
400109f0: a0 10 00 1a mov %i2, %l0
400109f4: a0 10 00 1b mov %i3, %l0
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
400109f8: 90 10 20 00 clr %o0
400109fc: 40 00 08 65 call 40012b90 <rtems_rfs_trace>
40010a00: 13 00 00 20 sethi %hi(0x8000), %o1
40010a04: 80 8a 20 ff btst 0xff, %o0
40010a08: 22 80 00 09 be,a 40010a2c <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
40010a0c: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40010a10: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010a14: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40010a18: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
40010a1c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40010a20: 40 00 43 22 call 400216a8 <printf> <== NOT EXECUTED
40010a24: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
base, size, inodes);
group->base = base;
40010a28: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
40010a2c: 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;
40010a30: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
40010a34: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
40010a38: 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,
40010a3c: a2 07 20 08 add %i4, 8, %l1
40010a40: b6 07 20 20 add %i4, 0x20, %i3
40010a44: 90 10 00 11 mov %l1, %o0
40010a48: 92 10 00 18 mov %i0, %o1
40010a4c: 94 10 00 1b mov %i3, %o2
40010a50: 96 10 00 1a mov %i2, %o3
40010a54: 40 00 23 23 call 400196e0 <rtems_rfs_bitmap_open>
40010a58: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40010a5c: ba 92 20 00 orcc %o0, 0, %i5
40010a60: 04 80 00 16 ble 40010ab8 <rtems_rfs_group_open+0x128> <== ALWAYS TAKEN
40010a64: 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);
40010a68: 40 00 27 ae call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40010a6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40010a70: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40010a74: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40010a78: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
40010a7c: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40010a80: 40 00 08 44 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
40010a84: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40010a88: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40010a8c: 22 80 00 3d be,a 40010b80 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
40010a90: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40010a94: 40 00 47 71 call 40022858 <strerror> <== NOT EXECUTED
40010a98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40010a9c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010aa0: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010aa4: 90 12 23 88 or %o0, 0x388, %o0 ! 40033388 <_CPU_Trap_slot_template+0x968><== NOT EXECUTED
40010aa8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010aac: 40 00 42 ff call 400216a8 <printf> <== NOT EXECUTED
40010ab0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40010ab4: 30 80 00 33 b,a 40010b80 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
40010ab8: 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;
40010abc: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
40010ac0: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
40010ac4: c0 27 20 4c clr [ %i4 + 0x4c ]
40010ac8: b4 07 20 44 add %i4, 0x44, %i2
40010acc: 90 07 20 2c add %i4, 0x2c, %o0
40010ad0: 92 10 00 18 mov %i0, %o1
40010ad4: 94 10 00 1a mov %i2, %o2
40010ad8: 96 10 00 10 mov %l0, %o3
40010adc: 40 00 23 01 call 400196e0 <rtems_rfs_bitmap_open>
40010ae0: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40010ae4: ba 92 20 00 orcc %o0, 0, %i5
40010ae8: 04 80 00 1b ble 40010b54 <rtems_rfs_group_open+0x1c4> <== ALWAYS TAKEN
40010aec: 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);
40010af0: 40 00 27 8c call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40010af4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
40010af8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
40010afc: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
40010b00: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
40010b04: 40 00 23 08 call 40019724 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40010b08: 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);
40010b0c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40010b10: 40 00 27 84 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40010b14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40010b18: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40010b1c: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40010b20: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
40010b24: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40010b28: 40 00 08 1a call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
40010b2c: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40010b30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40010b34: 22 80 00 13 be,a 40010b80 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
40010b38: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40010b3c: 40 00 47 47 call 40022858 <strerror> <== NOT EXECUTED
40010b40: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40010b44: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010b48: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40010b4c: 10 bf ff d7 b 40010aa8 <rtems_rfs_group_open+0x118> <== NOT EXECUTED
40010b50: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 400333c8 <_CPU_Trap_slot_template+0x9a8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
40010b54: c2 06 00 00 ld [ %i0 ], %g1
40010b58: 80 88 60 01 btst 1, %g1
40010b5c: 12 80 00 08 bne 40010b7c <rtems_rfs_group_open+0x1ec> <== NEVER TAKEN
40010b60: ba 10 20 00 clr %i5
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40010b64: d2 07 20 08 ld [ %i4 + 8 ], %o1
40010b68: 40 00 27 6e call 4001a920 <rtems_rfs_buffer_handle_release>
40010b6c: 90 10 00 18 mov %i0, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40010b70: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40010b74: 40 00 27 6b call 4001a920 <rtems_rfs_buffer_handle_release>
40010b78: 90 10 00 18 mov %i0, %o0
}
return 0;
}
40010b7c: b0 10 00 1d mov %i5, %i0
40010b80: 81 c7 e0 08 ret
40010b84: 81 e8 00 00 restore
40010fe4 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
40010fe4: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
40010fe8: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40010fec: 86 10 20 00 clr %g3 <== NOT EXECUTED
40010ff0: 10 80 00 11 b 40011034 <rtems_rfs_group_usage+0x50> <== NOT EXECUTED
40010ff4: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
40010ff8: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
40010ffc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
40011000: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
40011004: d8 00 60 14 ld [ %g1 + 0x14 ], %o4 <== NOT EXECUTED
40011008: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
4001100c: 86 00 e0 50 add %g3, 0x50, %g3 <== NOT EXECUTED
40011010: 9a 23 00 0d sub %o4, %o5, %o5 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
40011014: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
40011018: c8 22 40 00 st %g4, [ %o1 ] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
4001101c: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 <== NOT EXECUTED
40011020: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED
40011024: 82 21 00 01 sub %g4, %g1, %g1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
40011028: c8 02 80 00 ld [ %o2 ], %g4 <== NOT EXECUTED
4001102c: 82 01 00 01 add %g4, %g1, %g1 <== NOT EXECUTED
40011030: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
40011034: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
40011038: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4001103c: 06 bf ff ef bl 40010ff8 <rtems_rfs_group_usage+0x14> <== NOT EXECUTED
40011040: c8 02 40 00 ld [ %o1 ], %g4 <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
40011044: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
40011048: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
4001104c: 08 80 00 03 bleu 40011058 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
40011050: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
40011054: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
40011058: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
4001105c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
40011060: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
40011064: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40011068: 38 80 00 02 bgu,a 40011070 <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
4001106c: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
40011070: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
40011074: 81 c3 e0 08 retl <== NOT EXECUTED
40011078: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011334 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40011334: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40011338: 90 10 20 00 clr %o0
4001133c: 40 00 06 15 call 40012b90 <rtems_rfs_trace>
40011340: 13 00 02 00 sethi %hi(0x80000), %o1
40011344: 80 8a 20 ff btst 0xff, %o0
40011348: 22 80 00 07 be,a 40011364 <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
4001134c: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
40011350: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40011354: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40011358: 40 00 40 d4 call 400216a8 <printf> <== NOT EXECUTED
4001135c: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400335b0 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40011360: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011364: 92 10 00 19 mov %i1, %o1
40011368: 7f ff ff b7 call 40011244 <rtems_rfs_inode_unload>
4001136c: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
40011370: b0 92 20 00 orcc %o0, 0, %i0
40011374: 32 80 00 11 bne,a 400113b8 <rtems_rfs_inode_close+0x84> <== NEVER TAKEN
40011378: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
4001137c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40011380: 80 a0 60 00 cmp %g1, 0
40011384: 04 80 00 0c ble 400113b4 <rtems_rfs_inode_close+0x80> <== ALWAYS TAKEN
40011388: 13 00 02 00 sethi %hi(0x80000), %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
4001138c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011390: 40 00 06 00 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
40011394: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40011398: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001139c: 22 80 00 07 be,a 400113b8 <rtems_rfs_inode_close+0x84> <== NOT EXECUTED
400113a0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
400113a4: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
400113a8: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
400113ac: 40 00 40 bf call 400216a8 <printf> <== NOT EXECUTED
400113b0: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400335d8 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
400113b4: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
400113b8: 81 c7 e0 08 ret
400113bc: 81 e8 00 00 restore
40011688 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40011688: 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))
4001168c: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40011690: e2 07 a0 64 ld [ %fp + 0x64 ], %l1
40011694: e8 17 a0 5e lduh [ %fp + 0x5e ], %l4
40011698: e6 17 a0 62 lduh [ %fp + 0x62 ], %l3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4001169c: 40 00 05 3d call 40012b90 <rtems_rfs_trace>
400116a0: 13 00 10 00 sethi %hi(0x400000), %o1
400116a4: 80 8a 20 ff btst 0xff, %o0
400116a8: 02 80 00 36 be 40011780 <rtems_rfs_inode_create+0xf8> <== ALWAYS TAKEN
400116ac: a4 0f 30 00 and %i4, -4096, %l2
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
400116b0: 82 0f 30 00 and %i4, -4096, %g1 <== NOT EXECUTED
400116b4: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
400116b8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400116bc: 02 80 00 11 be 40011700 <rtems_rfs_inode_create+0x78> <== NOT EXECUTED
400116c0: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
400116c4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400116c8: 02 80 00 11 be 4001170c <rtems_rfs_inode_create+0x84> <== NOT EXECUTED
400116cc: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
400116d0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400116d4: 02 80 00 11 be 40011718 <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
400116d8: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
400116dc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400116e0: 02 80 00 11 be 40011724 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
400116e4: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
400116e8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400116ec: 22 80 00 11 be,a 40011730 <rtems_rfs_inode_create+0xa8> <== NOT EXECUTED
400116f0: 21 10 00 cd sethi %hi(0x40033400), %l0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
400116f4: 21 10 00 cd sethi %hi(0x40033400), %l0 <== NOT EXECUTED
400116f8: 10 80 00 0f b 40011734 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
400116fc: a0 14 22 50 or %l0, 0x250, %l0 ! 40033650 <_CPU_Trap_slot_template+0xc30><== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
40011700: 21 10 00 cd sethi %hi(0x40033400), %l0 <== NOT EXECUTED
40011704: 10 80 00 0c b 40011734 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
40011708: a0 14 22 38 or %l0, 0x238, %l0 ! 40033638 <_CPU_Trap_slot_template+0xc18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
4001170c: 21 10 00 cd sethi %hi(0x40033400), %l0 <== NOT EXECUTED
40011710: 10 80 00 09 b 40011734 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
40011714: a0 14 22 40 or %l0, 0x240, %l0 ! 40033640 <_CPU_Trap_slot_template+0xc20><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
40011718: 21 10 00 cd sethi %hi(0x40033400), %l0 <== NOT EXECUTED
4001171c: 10 80 00 06 b 40011734 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
40011720: a0 14 20 38 or %l0, 0x38, %l0 ! 40033438 <_CPU_Trap_slot_template+0xa18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
40011724: 21 10 00 cd sethi %hi(0x40033400), %l0 <== NOT EXECUTED
40011728: 10 80 00 03 b 40011734 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
4001172c: a0 14 22 48 or %l0, 0x248, %l0 ! 40033648 <_CPU_Trap_slot_template+0xc28><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
40011730: a0 14 22 58 or %l0, 0x258, %l0 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
40011734: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40011738: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001173c: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
40011740: 40 00 3f da call 400216a8 <printf> <== NOT EXECUTED
40011744: a4 10 00 1a mov %i2, %l2 <== NOT EXECUTED
for (c = 0; c < length; c++)
40011748: 10 80 00 04 b 40011758 <rtems_rfs_inode_create+0xd0> <== NOT EXECUTED
4001174c: aa 06 80 1b add %i2, %i3, %l5 <== NOT EXECUTED
printf ("%c", name[c]);
40011750: 40 00 40 40 call 40021850 <putchar> <== NOT EXECUTED
40011754: a4 04 a0 01 inc %l2 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
40011758: 80 a4 80 15 cmp %l2, %l5 <== NOT EXECUTED
4001175c: 32 bf ff fd bne,a 40011750 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
40011760: d0 4c 80 00 ldsb [ %l2 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
40011764: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40011768: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001176c: 90 12 22 90 or %o0, 0x290, %o0 <== NOT EXECUTED
40011770: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40011774: 40 00 3f cd call 400216a8 <printf> <== NOT EXECUTED
40011778: 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)
4001177c: a4 0f 30 00 and %i4, -4096, %l2 <== NOT EXECUTED
40011780: 05 00 00 18 sethi %hi(0x6000), %g2
40011784: 80 a4 80 02 cmp %l2, %g2
40011788: 02 80 00 11 be 400117cc <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
4001178c: 82 10 00 12 mov %l2, %g1
40011790: 80 a4 80 02 cmp %l2, %g2
40011794: 18 80 00 08 bgu 400117b4 <rtems_rfs_inode_create+0x12c>
40011798: 05 00 00 20 sethi %hi(0x8000), %g2
4001179c: 05 00 00 08 sethi %hi(0x2000), %g2
400117a0: 80 a4 80 02 cmp %l2, %g2
400117a4: 02 80 00 0a be 400117cc <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
400117a8: 05 00 00 10 sethi %hi(0x4000), %g2
400117ac: 10 80 00 06 b 400117c4 <rtems_rfs_inode_create+0x13c>
400117b0: 80 a0 40 02 cmp %g1, %g2
400117b4: 80 a4 80 02 cmp %l2, %g2
400117b8: 02 80 00 05 be 400117cc <rtems_rfs_inode_create+0x144>
400117bc: 05 00 00 28 sethi %hi(0xa000), %g2
400117c0: 80 a0 40 02 cmp %g1, %g2
400117c4: 12 80 00 81 bne 400119c8 <rtems_rfs_inode_create+0x340> <== NEVER TAKEN
400117c8: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
400117cc: 90 10 00 18 mov %i0, %o0
400117d0: 92 10 00 19 mov %i1, %o1
400117d4: 7f ff fe 2a call 4001107c <rtems_rfs_inode_alloc>
400117d8: 94 10 00 11 mov %l1, %o2
if (rc > 0)
400117dc: a0 92 20 00 orcc %o0, 0, %l0
400117e0: 34 80 00 7b bg,a 400119cc <rtems_rfs_inode_create+0x344>
400117e4: b0 10 00 10 mov %l0, %i0
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
400117e8: d2 04 40 00 ld [ %l1 ], %o1
400117ec: 90 10 00 18 mov %i0, %o0
400117f0: 94 07 bf d8 add %fp, -40, %o2
400117f4: 7f ff fe 5e call 4001116c <rtems_rfs_inode_open>
400117f8: 96 10 20 01 mov 1, %o3
if (rc > 0)
400117fc: a0 92 20 00 orcc %o0, 0, %l0
40011800: 04 80 00 04 ble 40011810 <rtems_rfs_inode_create+0x188> <== ALWAYS TAKEN
40011804: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
40011808: 10 80 00 6c b 400119b8 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
4001180c: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
40011810: 92 10 00 1d mov %i5, %o1
40011814: 94 10 00 1c mov %i4, %o2
40011818: 96 10 00 14 mov %l4, %o3
4001181c: 7f ff ff 47 call 40011538 <rtems_rfs_inode_initialise>
40011820: 98 10 00 13 mov %l3, %o4
if (rc > 0)
40011824: a0 92 20 00 orcc %o0, 0, %l0
40011828: 04 80 00 07 ble 40011844 <rtems_rfs_inode_create+0x1bc> <== ALWAYS TAKEN
4001182c: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_close (fs, &inode);
40011830: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011834: 7f ff fe c0 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
40011838: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
4001183c: 10 80 00 5f b 400119b8 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
40011840: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
/*
* Only handle the specifics of a directory. Let caller handle the others.
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
40011844: 80 a4 80 01 cmp %l2, %g1
40011848: 12 80 00 17 bne 400118a4 <rtems_rfs_inode_create+0x21c>
4001184c: 90 10 00 18 mov %i0, %o0
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
40011850: d8 04 40 00 ld [ %l1 ], %o4
40011854: 92 07 bf d8 add %fp, -40, %o1
40011858: 15 10 00 c4 sethi %hi(0x40031000), %o2
4001185c: 96 10 20 01 mov 1, %o3
40011860: 40 00 27 a1 call 4001b6e4 <rtems_rfs_dir_add_entry>
40011864: 94 12 a3 50 or %o2, 0x350, %o2
if (rc == 0)
40011868: a0 92 20 00 orcc %o0, 0, %l0
4001186c: 12 80 00 0b bne 40011898 <rtems_rfs_inode_create+0x210> <== NEVER TAKEN
40011870: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
40011874: 90 10 00 18 mov %i0, %o0
40011878: 92 07 bf d8 add %fp, -40, %o1
4001187c: 15 10 00 c4 sethi %hi(0x40031000), %o2
40011880: 96 10 20 02 mov 2, %o3
40011884: 94 12 a3 58 or %o2, 0x358, %o2
40011888: 40 00 27 97 call 4001b6e4 <rtems_rfs_dir_add_entry>
4001188c: 98 10 00 19 mov %i1, %o4
40011890: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40011894: 80 a4 20 00 cmp %l0, 0
40011898: 14 80 00 0b bg 400118c4 <rtems_rfs_inode_create+0x23c> <== NEVER TAKEN
4001189c: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
400118a0: 90 10 00 18 mov %i0, %o0
400118a4: 92 10 00 19 mov %i1, %o1
400118a8: 94 07 bf b0 add %fp, -80, %o2
400118ac: 7f ff fe 30 call 4001116c <rtems_rfs_inode_open>
400118b0: 96 10 20 01 mov 1, %o3
400118b4: a0 10 00 08 mov %o0, %l0
if (rc > 0)
400118b8: 80 a4 20 00 cmp %l0, 0
400118bc: 04 80 00 04 ble 400118cc <rtems_rfs_inode_create+0x244> <== ALWAYS TAKEN
400118c0: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
400118c4: 10 80 00 30 b 40011984 <rtems_rfs_inode_create+0x2fc> <== NOT EXECUTED
400118c8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
400118cc: d8 04 40 00 ld [ %l1 ], %o4
400118d0: 92 07 bf b0 add %fp, -80, %o1
400118d4: 94 10 00 1a mov %i2, %o2
400118d8: 40 00 27 83 call 4001b6e4 <rtems_rfs_dir_add_entry>
400118dc: 96 10 00 1b mov %i3, %o3
if (rc > 0)
400118e0: a0 92 20 00 orcc %o0, 0, %l0
400118e4: 04 80 00 0b ble 40011910 <rtems_rfs_inode_create+0x288> <== ALWAYS TAKEN
400118e8: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_delete (fs, &inode);
400118ec: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
400118f0: 7f ff fe b4 call 400113c0 <rtems_rfs_inode_delete> <== NOT EXECUTED
400118f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400118f8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
400118fc: 7f ff fe 8e call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
40011900: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40011904: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011908: 10 80 00 23 b 40011994 <rtems_rfs_inode_create+0x30c> <== NOT EXECUTED
4001190c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
40011910: 80 a4 80 01 cmp %l2, %g1
40011914: 12 80 00 15 bne 40011968 <rtems_rfs_inode_create+0x2e0>
40011918: 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);
4001191c: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
40011920: 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);
40011924: c6 08 60 01 ldub [ %g1 + 1 ], %g3
40011928: c4 08 40 00 ldub [ %g1 ], %g2
4001192c: 85 28 a0 08 sll %g2, 8, %g2
40011930: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
40011934: 87 28 a0 10 sll %g2, 0x10, %g3
40011938: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
4001193c: 86 39 00 03 xnor %g4, %g3, %g3
40011940: 80 a0 00 03 cmp %g0, %g3
40011944: 86 60 20 00 subx %g0, 0, %g3
40011948: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
4001194c: 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);
40011950: 87 30 a0 08 srl %g2, 8, %g3
40011954: c6 28 40 00 stb %g3, [ %g1 ]
40011958: c2 07 bf bc ld [ %fp + -68 ], %g1
4001195c: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011960: 82 10 20 01 mov 1, %g1
40011964: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
40011968: 7f ff fe 73 call 40011334 <rtems_rfs_inode_close>
4001196c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
40011970: 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);
40011974: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40011978: 80 a4 20 00 cmp %l0, 0
4001197c: 04 80 00 09 ble 400119a0 <rtems_rfs_inode_create+0x318> <== ALWAYS TAKEN
40011980: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
40011984: 7f ff fe 8f call 400113c0 <rtems_rfs_inode_delete> <== NOT EXECUTED
40011988: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001198c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011990: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40011994: 7f ff fe 68 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
40011998: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
4001199c: 30 80 00 0c b,a 400119cc <rtems_rfs_inode_create+0x344> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
400119a0: 7f ff fe 65 call 40011334 <rtems_rfs_inode_close>
400119a4: 01 00 00 00 nop
if (rc > 0)
400119a8: a0 92 20 00 orcc %o0, 0, %l0
400119ac: 24 80 00 07 ble,a 400119c8 <rtems_rfs_inode_create+0x340><== ALWAYS TAKEN
400119b0: a0 10 20 00 clr %l0
{
rtems_rfs_inode_free (fs, *ino);
400119b4: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
400119b8: 7f ff fd bb call 400110a4 <rtems_rfs_inode_free> <== NOT EXECUTED
400119bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
return 0;
}
400119c0: 81 c7 e0 08 ret <== NOT EXECUTED
400119c4: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
400119c8: b0 10 00 10 mov %l0, %i0
400119cc: 81 c7 e0 08 ret
400119d0: 81 e8 00 00 restore
400113c0 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400113c0: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
400113c4: 90 10 20 00 clr %o0
400113c8: 40 00 05 f2 call 40012b90 <rtems_rfs_trace>
400113cc: 13 00 20 00 sethi %hi(0x800000), %o1
400113d0: 80 8a 20 ff btst 0xff, %o0
400113d4: 22 80 00 0f be,a 40011410 <rtems_rfs_inode_delete+0x50> <== ALWAYS TAKEN
400113d8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
400113dc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
400113e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400113e4: 02 80 00 05 be 400113f8 <rtems_rfs_inode_delete+0x38> <== NOT EXECUTED
400113e8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400113ec: 15 10 00 cd sethi %hi(0x40033400), %o2 <== NOT EXECUTED
400113f0: 10 80 00 04 b 40011400 <rtems_rfs_inode_delete+0x40> <== NOT EXECUTED
400113f4: 94 12 a1 10 or %o2, 0x110, %o2 ! 40033510 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
400113f8: 15 10 00 c6 sethi %hi(0x40031800), %o2 <== NOT EXECUTED
400113fc: 94 12 a2 f8 or %o2, 0x2f8, %o2 ! 40031af8 <__FUNCTION__.6193+0x2f0><== NOT EXECUTED
40011400: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40011404: 40 00 40 a9 call 400216a8 <printf> <== NOT EXECUTED
40011408: 90 12 22 08 or %o0, 0x208, %o0 ! 40033608 <_CPU_Trap_slot_template+0xbe8><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
4001140c: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
40011410: 80 a0 a0 00 cmp %g2, 0
40011414: 02 80 00 1e be 4001148c <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
40011418: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
4001141c: d2 06 60 08 ld [ %i1 + 8 ], %o1
40011420: 7f ff ff 21 call 400110a4 <rtems_rfs_inode_free>
40011424: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40011428: 80 a2 20 00 cmp %o0, 0
4001142c: 14 80 00 18 bg 4001148c <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
40011430: 92 10 00 19 mov %i1, %o1
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
40011434: 90 10 00 18 mov %i0, %o0
40011438: 40 00 21 c1 call 40019b3c <rtems_rfs_block_map_open>
4001143c: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
40011440: 80 a2 20 00 cmp %o0, 0
40011444: 12 80 00 12 bne 4001148c <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
40011448: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
4001144c: 40 00 24 d1 call 4001a790 <rtems_rfs_block_map_free_all>
40011450: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
40011454: 92 07 bf b0 add %fp, -80, %o1
40011458: 40 00 22 1a call 40019cc0 <rtems_rfs_block_map_close>
4001145c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40011460: d0 06 60 0c ld [ %i1 + 0xc ], %o0
40011464: 92 10 20 ff mov 0xff, %o1
40011468: 40 00 40 12 call 400214b0 <memset>
4001146c: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011470: 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);
40011474: 90 10 00 18 mov %i0, %o0
rrc = rtems_rfs_block_map_free_all (fs, &map);
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011478: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
/*
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4001147c: 40 00 25 29 call 4001a920 <rtems_rfs_buffer_handle_release>
40011480: 92 06 60 10 add %i1, 0x10, %o1
handle->loads = 0;
40011484: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
40011488: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
4001148c: 81 c7 e0 08 ret
40011490: 91 e8 00 08 restore %g0, %o0, %o0
40011a54 <rtems_rfs_inode_get_block>:
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
40011a54: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40011a58: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
40011a5c: 85 2a 60 02 sll %o1, 2, %g2 <== NOT EXECUTED
40011a60: 84 00 40 02 add %g1, %g2, %g2 <== NOT EXECUTED
40011a64: 82 00 a0 04 add %g2, 4, %g1 <== NOT EXECUTED
40011a68: d0 08 a0 04 ldub [ %g2 + 4 ], %o0 <== NOT EXECUTED
40011a6c: c4 08 a0 05 ldub [ %g2 + 5 ], %g2 <== NOT EXECUTED
40011a70: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
40011a74: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
40011a78: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
40011a7c: c4 08 60 03 ldub [ %g1 + 3 ], %g2 <== NOT EXECUTED
40011a80: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
40011a84: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
40011a88: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
40011a8c: 81 c3 e0 08 retl <== NOT EXECUTED
40011a90: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
400110b8 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400110b8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
400110bc: 90 10 20 00 clr %o0
400110c0: 40 00 06 b4 call 40012b90 <rtems_rfs_trace>
400110c4: 13 00 04 00 sethi %hi(0x100000), %o1
400110c8: 80 8a 20 ff btst 0xff, %o0
400110cc: 02 80 00 0f be 40011108 <rtems_rfs_inode_load+0x50> <== ALWAYS TAKEN
400110d0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
400110d4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400110d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400110dc: 02 80 00 05 be 400110f0 <rtems_rfs_inode_load+0x38> <== NOT EXECUTED
400110e0: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
400110e4: 17 10 00 cd sethi %hi(0x40033400), %o3 <== NOT EXECUTED
400110e8: 10 80 00 04 b 400110f8 <rtems_rfs_inode_load+0x40> <== NOT EXECUTED
400110ec: 96 12 e1 10 or %o3, 0x110, %o3 ! 40033510 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
400110f0: 17 10 00 c6 sethi %hi(0x40031800), %o3 <== NOT EXECUTED
400110f4: 96 12 e2 f8 or %o3, 0x2f8, %o3 ! 40031af8 <__FUNCTION__.6193+0x2f0><== NOT EXECUTED
400110f8: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
400110fc: 40 00 41 6b call 400216a8 <printf> <== NOT EXECUTED
40011100: 90 12 21 18 or %o0, 0x118, %o0 ! 40033518 <_CPU_Trap_slot_template+0xaf8><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
40011104: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40011108: 80 a0 60 00 cmp %g1, 0
4001110c: 32 80 00 13 bne,a 40011158 <rtems_rfs_inode_load+0xa0>
40011110: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
40011114: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
40011118: 90 10 00 18 mov %i0, %o0
4001111c: 92 06 60 10 add %i1, 0x10, %o1
40011120: 40 00 26 74 call 4001aaf0 <rtems_rfs_buffer_handle_request>
40011124: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
40011128: b0 92 20 00 orcc %o0, 0, %i0
4001112c: 14 80 00 0e bg 40011164 <rtems_rfs_inode_load+0xac> <== NEVER TAKEN
40011130: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
40011134: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
40011138: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4001113c: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40011140: 87 28 60 03 sll %g1, 3, %g3
40011144: 83 28 60 06 sll %g1, 6, %g1
40011148: 82 20 40 03 sub %g1, %g3, %g1
4001114c: 82 00 80 01 add %g2, %g1, %g1
40011150: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
handle->loads++;
40011154: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
40011158: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
4001115c: 82 00 60 01 inc %g1
40011160: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
40011164: 81 c7 e0 08 ret
40011168: 81 e8 00 00 restore
4001116c <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)
{
4001116c: 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))
40011170: 90 10 20 00 clr %o0
40011174: 40 00 06 87 call 40012b90 <rtems_rfs_trace>
40011178: 13 00 01 00 sethi %hi(0x40000), %o1
4001117c: 80 8a 20 ff btst 0xff, %o0
40011180: 02 80 00 07 be 4001119c <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
40011184: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
40011188: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
4001118c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40011190: 40 00 41 46 call 400216a8 <printf> <== NOT EXECUTED
40011194: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
40011198: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4001119c: 02 80 00 28 be 4001123c <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
400111a0: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
400111a4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
400111a8: ba 06 7f ff add %i1, -1, %i5
400111ac: 80 a7 40 02 cmp %i5, %g2
400111b0: 18 80 00 23 bgu 4001123c <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
400111b4: 90 10 00 1d mov %i5, %o0
return EINVAL;
handle->ino = ino;
400111b8: 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;
400111bc: f2 06 20 2c ld [ %i0 + 0x2c ], %i1
gino = gino % fs->group_inodes;
400111c0: 92 10 00 19 mov %i1, %o1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
400111c4: 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;
400111c8: 40 00 72 f0 call 4002dd88 <.urem>
400111cc: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
400111d0: 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;
400111d4: a0 10 00 08 mov %o0, %l0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
400111d8: 40 00 72 ec call 4002dd88 <.urem>
400111dc: 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;
400111e0: 92 10 00 19 mov %i1, %o1
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
400111e4: 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;
400111e8: 7f ff c5 25 call 4000267c <.udiv>
400111ec: 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);
400111f0: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
400111f4: 87 2a 20 04 sll %o0, 4, %g3
400111f8: 83 2a 20 06 sll %o0, 6, %g1
400111fc: 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;
40011200: fa 00 80 01 ld [ %g2 + %g1 ], %i5
40011204: 90 10 00 10 mov %l0, %o0
40011208: ba 07 60 02 add %i5, 2, %i5
4001120c: 7f ff c5 1c call 4000267c <.udiv>
40011210: 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;
40011214: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40011218: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
4001121c: c0 26 a0 14 clr [ %i2 + 0x14 ]
40011220: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
40011224: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
40011228: 80 a6 e0 00 cmp %i3, 0
4001122c: 02 80 00 04 be 4001123c <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
40011230: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
40011234: 7f ff ff a1 call 400110b8 <rtems_rfs_inode_load>
40011238: 93 e8 00 1a restore %g0, %i2, %o1
return rc;
}
4001123c: 81 c7 e0 08 ret <== NOT EXECUTED
40011240: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
40011a94 <rtems_rfs_inode_set_block>:
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
40011a94: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40011a98: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
40011a9c: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
40011aa0: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
40011aa4: 85 32 a0 18 srl %o2, 0x18, %g2 <== NOT EXECUTED
40011aa8: c4 28 60 04 stb %g2, [ %g1 + 4 ] <== NOT EXECUTED
40011aac: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40011ab0: 85 32 a0 10 srl %o2, 0x10, %g2 <== NOT EXECUTED
40011ab4: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
40011ab8: c4 28 60 05 stb %g2, [ %g1 + 5 ] <== NOT EXECUTED
40011abc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40011ac0: 85 32 a0 08 srl %o2, 8, %g2 <== NOT EXECUTED
40011ac4: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
40011ac8: c4 28 60 06 stb %g2, [ %g1 + 6 ] <== NOT EXECUTED
40011acc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40011ad0: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
40011ad4: d4 2a 60 07 stb %o2, [ %o1 + 7 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011ad8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40011adc: 81 c3 e0 08 retl <== NOT EXECUTED
40011ae0: c2 2a 20 10 stb %g1, [ %o0 + 0x10 ] <== NOT EXECUTED
40011494 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40011494: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40011498: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
4001149c: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
400114a0: 80 a0 60 00 cmp %g1, 0
400114a4: 02 80 00 23 be 40011530 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
400114a8: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
400114ac: 40 00 50 e5 call 40025840 <time>
400114b0: 90 10 20 00 clr %o0
if (atime)
400114b4: 80 a6 60 00 cmp %i1, 0
400114b8: 02 80 00 0f be 400114f4 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
400114bc: 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);
400114c0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400114c4: 85 32 20 18 srl %o0, 0x18, %g2
400114c8: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
400114cc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400114d0: 85 32 20 10 srl %o0, 0x10, %g2
400114d4: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
400114d8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400114dc: 85 32 20 08 srl %o0, 8, %g2
400114e0: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
400114e4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400114e8: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400114ec: 82 10 20 01 mov 1, %g1
400114f0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
400114f4: 02 80 00 0f be 40011530 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
400114f8: 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);
400114fc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011500: 85 32 20 18 srl %o0, 0x18, %g2
40011504: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
40011508: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001150c: 85 32 20 10 srl %o0, 0x10, %g2
40011510: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40011514: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011518: 85 32 20 08 srl %o0, 8, %g2
4001151c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40011520: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011524: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011528: 82 10 20 01 mov 1, %g1
4001152c: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
40011530: 81 c7 e0 08 ret
40011534: 81 e8 00 00 restore
40011244 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
40011244: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
40011248: 90 10 20 00 clr %o0
4001124c: 40 00 06 51 call 40012b90 <rtems_rfs_trace>
40011250: 13 00 08 00 sethi %hi(0x200000), %o1
40011254: 80 8a 20 ff btst 0xff, %o0
40011258: 02 80 00 0f be 40011294 <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
4001125c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40011260: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40011264: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40011268: 02 80 00 05 be 4001127c <rtems_rfs_inode_unload+0x38> <== NOT EXECUTED
4001126c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40011270: 17 10 00 cd sethi %hi(0x40033400), %o3 <== NOT EXECUTED
40011274: 10 80 00 04 b 40011284 <rtems_rfs_inode_unload+0x40> <== NOT EXECUTED
40011278: 96 12 e1 10 or %o3, 0x110, %o3 ! 40033510 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
4001127c: 17 10 00 c6 sethi %hi(0x40031800), %o3 <== NOT EXECUTED
40011280: 96 12 e2 f8 or %o3, 0x2f8, %o3 ! 40031af8 <__FUNCTION__.6193+0x2f0><== NOT EXECUTED
40011284: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40011288: 40 00 41 08 call 400216a8 <printf> <== NOT EXECUTED
4001128c: 90 12 21 78 or %o0, 0x178, %o0 ! 40033578 <_CPU_Trap_slot_template+0xb58><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40011290: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40011294: 80 a0 60 00 cmp %g1, 0
40011298: 32 80 00 04 bne,a 400112a8 <rtems_rfs_inode_unload+0x64>
4001129c: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
400112a0: 10 80 00 23 b 4001132c <rtems_rfs_inode_unload+0xe8>
400112a4: 90 10 20 00 clr %o0
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
400112a8: 80 a0 a0 00 cmp %g2, 0
400112ac: 02 80 00 20 be 4001132c <rtems_rfs_inode_unload+0xe8> <== NEVER TAKEN
400112b0: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
400112b4: 82 00 bf ff add %g2, -1, %g1
if (handle->loads == 0)
400112b8: 80 a0 60 00 cmp %g1, 0
400112bc: 12 bf ff f9 bne 400112a0 <rtems_rfs_inode_unload+0x5c>
400112c0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
400112c4: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
400112c8: 80 a0 60 00 cmp %g1, 0
400112cc: 02 80 00 15 be 40011320 <rtems_rfs_inode_unload+0xdc>
400112d0: 90 10 00 18 mov %i0, %o0
400112d4: 80 a6 a0 00 cmp %i2, 0
400112d8: 02 80 00 12 be 40011320 <rtems_rfs_inode_unload+0xdc> <== NEVER TAKEN
400112dc: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
400112e0: 40 00 51 58 call 40025840 <time>
400112e4: 90 10 20 00 clr %o0 ! 0 <PROM_START>
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
400112e8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
400112ec: 87 32 20 18 srl %o0, 0x18, %g3
400112f0: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ]
400112f4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
400112f8: 87 32 20 10 srl %o0, 0x10, %g3
400112fc: c6 28 a0 19 stb %g3, [ %g2 + 0x19 ]
40011300: c4 06 60 0c ld [ %i1 + 0xc ], %g2
40011304: 87 32 20 08 srl %o0, 8, %g3
40011308: c6 28 a0 1a stb %g3, [ %g2 + 0x1a ]
4001130c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011310: 82 10 20 01 mov 1, %g1
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
40011314: d0 28 a0 1b stb %o0, [ %g2 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011318: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4001131c: 90 10 00 18 mov %i0, %o0
40011320: 40 00 25 80 call 4001a920 <rtems_rfs_buffer_handle_release>
40011324: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
40011328: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
4001132c: 81 c7 e0 08 ret
40011330: 91 e8 00 08 restore %g0, %o0, %o0
4001dc20 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
4001dc20: 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))
4001dc24: 90 10 20 00 clr %o0
4001dc28: 7f ff d3 da call 40012b90 <rtems_rfs_trace>
4001dc2c: 13 00 40 00 sethi %hi(0x1000000), %o1
4001dc30: 80 8a 20 ff btst 0xff, %o0
4001dc34: 02 80 00 13 be 4001dc80 <rtems_rfs_link+0x60> <== ALWAYS TAKEN
4001dc38: 90 10 00 18 mov %i0, %o0
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
4001dc3c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001dc40: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001dc44: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED
4001dc48: 40 00 0e 98 call 400216a8 <printf> <== NOT EXECUTED
4001dc4c: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
4001dc50: 10 80 00 05 b 4001dc64 <rtems_rfs_link+0x44> <== NOT EXECUTED
4001dc54: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
4001dc58: 40 00 0e fe call 40021850 <putchar> <== NOT EXECUTED
4001dc5c: 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++)
4001dc60: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
4001dc64: 26 bf ff fd bl,a 4001dc58 <rtems_rfs_link+0x38> <== NOT EXECUTED
4001dc68: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
4001dc6c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001dc70: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001dc74: 40 00 0e 8d call 400216a8 <printf> <== NOT EXECUTED
4001dc78: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001dc7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001dc80: 92 10 00 1c mov %i4, %o1
4001dc84: 94 07 bf d8 add %fp, -40, %o2
4001dc88: 7f ff cd 39 call 4001116c <rtems_rfs_inode_open>
4001dc8c: 96 10 20 01 mov 1, %o3
if (rc)
4001dc90: a0 92 20 00 orcc %o0, 0, %l0
4001dc94: 12 80 00 49 bne 4001ddb8 <rtems_rfs_link+0x198> <== NEVER TAKEN
4001dc98: 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)))
4001dc9c: 12 80 00 10 bne 4001dcdc <rtems_rfs_link+0xbc> <== NEVER TAKEN
4001dca0: 90 10 00 18 mov %i0, %o0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4001dca4: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001dca8: c4 08 60 02 ldub [ %g1 + 2 ], %g2
4001dcac: 03 00 00 3c sethi %hi(0xf000), %g1
4001dcb0: 85 28 a0 08 sll %g2, 8, %g2
4001dcb4: 84 08 80 01 and %g2, %g1, %g2
4001dcb8: 03 00 00 10 sethi %hi(0x4000), %g1
4001dcbc: 80 a0 80 01 cmp %g2, %g1
4001dcc0: 12 80 00 08 bne 4001dce0 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
4001dcc4: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
4001dcc8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001dccc: 7f ff cd 9a call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001dcd0: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
4001dcd4: 81 c7 e0 08 ret <== NOT EXECUTED
4001dcd8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001dcdc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001dce0: 94 07 bf b0 add %fp, -80, %o2
4001dce4: 7f ff cd 22 call 4001116c <rtems_rfs_inode_open>
4001dce8: 96 10 20 01 mov 1, %o3
4001dcec: a0 10 00 08 mov %o0, %l0
if (rc)
4001dcf0: 80 a4 20 00 cmp %l0, 0
4001dcf4: 02 80 00 04 be 4001dd04 <rtems_rfs_link+0xe4> <== ALWAYS TAKEN
4001dcf8: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
4001dcfc: 10 80 00 0f b 4001dd38 <rtems_rfs_link+0x118> <== NOT EXECUTED
4001dd00: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
4001dd04: 92 07 bf b0 add %fp, -80, %o1
4001dd08: 94 10 00 19 mov %i1, %o2
4001dd0c: 96 10 00 1a mov %i2, %o3
4001dd10: 7f ff f6 75 call 4001b6e4 <rtems_rfs_dir_add_entry>
4001dd14: 98 10 00 1c mov %i4, %o4
if (rc > 0)
4001dd18: a0 92 20 00 orcc %o0, 0, %l0
4001dd1c: 04 80 00 0a ble 4001dd44 <rtems_rfs_link+0x124> <== ALWAYS TAKEN
4001dd20: 92 07 bf b0 add %fp, -80, %o1
{
rtems_rfs_inode_close (fs, &parent_inode);
4001dd24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001dd28: 7f ff cd 83 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001dd2c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001dd30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001dd34: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001dd38: 7f ff cd 7f call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001dd3c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
4001dd40: 30 80 00 1f b,a 4001ddbc <rtems_rfs_link+0x19c> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
4001dd44: 7f ff ff a8 call 4001dbe4 <rtems_rfs_inode_get_links>
4001dd48: 90 07 bf d8 add %fp, -40, %o0
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
4001dd4c: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001dd50: 90 02 20 01 inc %o0
4001dd54: 85 32 20 08 srl %o0, 8, %g2
4001dd58: c4 28 40 00 stb %g2, [ %g1 ]
4001dd5c: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001dd60: 92 10 20 01 mov 1, %o1
4001dd64: d0 28 60 01 stb %o0, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001dd68: 82 10 20 01 mov 1, %g1
4001dd6c: 90 07 bf b0 add %fp, -80, %o0
4001dd70: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4001dd74: 7f ff cd c8 call 40011494 <rtems_rfs_inode_time_stamp_now>
4001dd78: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
4001dd7c: 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);
4001dd80: a0 10 00 08 mov %o0, %l0
if (rc > 0)
4001dd84: 80 a4 20 00 cmp %l0, 0
4001dd88: 14 bf ff e8 bg 4001dd28 <rtems_rfs_link+0x108> <== NEVER TAKEN
4001dd8c: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001dd90: 7f ff cd 69 call 40011334 <rtems_rfs_inode_close>
4001dd94: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
4001dd98: 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);
4001dd9c: a0 10 00 08 mov %o0, %l0
if (rc > 0)
4001dda0: 80 a4 20 00 cmp %l0, 0
4001dda4: 14 bf ff e5 bg 4001dd38 <rtems_rfs_link+0x118> <== NEVER TAKEN
4001dda8: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
4001ddac: 7f ff cd 62 call 40011334 <rtems_rfs_inode_close>
4001ddb0: 01 00 00 00 nop
4001ddb4: a0 10 00 08 mov %o0, %l0
return rc;
}
4001ddb8: b0 10 00 10 mov %l0, %i0
4001ddbc: 81 c7 e0 08 ret
4001ddc0: 81 e8 00 00 restore
4001e59c <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
4001e59c: 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'),
4001e5a0: 11 14 91 94 sethi %hi(0x52465000), %o0
4001e5a4: 98 10 00 18 mov %i0, %o4
4001e5a8: 90 12 23 6d or %o0, 0x36d, %o0
4001e5ac: 92 10 20 01 mov 1, %o1
4001e5b0: 94 10 20 54 mov 0x54, %o2
4001e5b4: 96 10 20 00 clr %o3
4001e5b8: 7f ff b6 25 call 4000be4c <rtems_semaphore_create>
4001e5bc: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
4001e5c0: 80 a2 20 00 cmp %o0, 0
4001e5c4: 02 80 00 0f be 4001e600 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
4001e5c8: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001e5cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e5d0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001e5d4: 7f ff d1 6f call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e5d8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001e5dc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e5e0: 02 80 00 08 be 4001e600 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
4001e5e4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
4001e5e8: 7f ff de b0 call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001e5ec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e5f0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001e5f4: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e5f8: 40 00 0c 2c call 400216a8 <printf> <== NOT EXECUTED
4001e5fc: 90 12 22 08 or %o0, 0x208, %o0 ! 40035a08 <CSWTCH.2+0x1658><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
4001e600: 81 c7 e0 08 ret
4001e604: 81 e8 00 00 restore
4001e608 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
4001e608: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
4001e60c: d0 06 00 00 ld [ %i0 ], %o0
4001e610: 7f ff b6 7d call 4000c004 <rtems_semaphore_delete>
4001e614: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001e618: 80 a2 20 00 cmp %o0, 0
4001e61c: 02 80 00 0f be 4001e658 <rtems_rfs_mutex_destroy+0x50> <== ALWAYS TAKEN
4001e620: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001e624: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e628: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001e62c: 7f ff d1 59 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e630: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001e634: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e638: 02 80 00 08 be 4001e658 <rtems_rfs_mutex_destroy+0x50> <== NOT EXECUTED
4001e63c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
4001e640: 7f ff de 9a call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001e644: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e648: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001e64c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e650: 40 00 0c 16 call 400216a8 <printf> <== NOT EXECUTED
4001e654: 90 12 22 30 or %o0, 0x230, %o0 ! 40035a30 <CSWTCH.2+0x1680><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
4001e658: 81 c7 e0 08 ret
4001e65c: 81 e8 00 00 restore
4001e878 <rtems_rfs_mutex_lock.isra.0>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
4001e878: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4001e87c: 92 10 20 00 clr %o1
4001e880: 90 10 00 18 mov %i0, %o0
4001e884: 94 10 20 00 clr %o2
4001e888: 7f ff b6 0e call 4000c0c0 <rtems_semaphore_obtain>
4001e88c: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001e890: 80 a2 20 00 cmp %o0, 0
4001e894: 02 80 00 0f be 4001e8d0 <rtems_rfs_mutex_lock.isra.0+0x58><== ALWAYS TAKEN
4001e898: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001e89c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e8a0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001e8a4: 7f ff d0 bb call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e8a8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001e8ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e8b0: 02 80 00 08 be 4001e8d0 <rtems_rfs_mutex_lock.isra.0+0x58><== NOT EXECUTED
4001e8b4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001e8b8: 7f ff dd fc call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001e8bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e8c0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001e8c4: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
4001e8c8: 40 00 0b 78 call 400216a8 <printf> <== NOT EXECUTED
4001e8cc: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400336d8 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
4001e8d0: 81 c7 e0 08 ret
4001e8d4: 81 e8 00 00 restore
40012154 <rtems_rfs_mutex_lock.isra.2>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
40012154: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40012158: 92 10 20 00 clr %o1
4001215c: 90 10 00 18 mov %i0, %o0
40012160: 94 10 20 00 clr %o2
40012164: 7f ff e7 d7 call 4000c0c0 <rtems_semaphore_obtain>
40012168: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001216c: 80 a2 20 00 cmp %o0, 0
40012170: 02 80 00 0f be 400121ac <rtems_rfs_mutex_lock.isra.2+0x58><== ALWAYS TAKEN
40012174: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40012178: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001217c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40012180: 40 00 02 84 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
40012184: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40012188: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001218c: 02 80 00 08 be 400121ac <rtems_rfs_mutex_lock.isra.2+0x58><== NOT EXECUTED
40012190: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40012194: 40 00 0f c5 call 400160a8 <rtems_status_text> <== NOT EXECUTED
40012198: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001219c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400121a0: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
400121a4: 40 00 3d 41 call 400216a8 <printf> <== NOT EXECUTED
400121a8: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400336d8 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
400121ac: 81 c7 e0 08 ret
400121b0: 81 e8 00 00 restore
400120fc <rtems_rfs_mutex_unlock.isra.1>:
* @param mutex The mutex to unlock.
* @retval true The mutex is unlocked.
* @retval false The mutex could not be unlocked.
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
400120fc: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40012100: 90 10 00 18 mov %i0, %o0
40012104: 7f ff e8 38 call 4000c1e4 <rtems_semaphore_release>
40012108: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001210c: 80 a2 20 00 cmp %o0, 0
40012110: 02 80 00 0f be 4001214c <rtems_rfs_mutex_unlock.isra.1+0x50><== ALWAYS TAKEN
40012114: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40012118: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001211c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40012120: 40 00 02 9c call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
40012124: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40012128: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001212c: 02 80 00 08 be 4001214c <rtems_rfs_mutex_unlock.isra.1+0x50><== NOT EXECUTED
40012130: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40012134: 40 00 0f dd call 400160a8 <rtems_status_text> <== NOT EXECUTED
40012138: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001213c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40012140: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40012144: 40 00 3d 59 call 400216a8 <printf> <== NOT EXECUTED
40012148: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 400336b0 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
4001214c: 81 c7 e0 08 ret
40012150: 81 e8 00 00 restore
4001a7a0 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
4001a7a0: 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))
4001a7a4: 90 10 20 00 clr %o0
4001a7a8: 92 10 20 80 mov 0x80, %o1
4001a7ac: 7f ff e0 f9 call 40012b90 <rtems_rfs_trace>
4001a7b0: ba 10 00 18 mov %i0, %i5
4001a7b4: 80 8a 20 ff btst 0xff, %o0
4001a7b8: 22 80 00 07 be,a 4001a7d4 <rtems_rfs_release_chain+0x34> <== ALWAYS TAKEN
4001a7bc: b0 10 20 00 clr %i0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
4001a7c0: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001a7c4: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001a7c8: 40 00 1b b8 call 400216a8 <printf> <== NOT EXECUTED
4001a7cc: 90 12 20 b8 or %o0, 0xb8, %o0 ! 400344b8 <CSWTCH.2+0x108> <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
4001a7d0: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001a7d4: 10 80 00 10 b 4001a814 <rtems_rfs_release_chain+0x74>
4001a7d8: b8 07 60 04 add %i5, 4, %i4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4001a7dc: 7f ff c8 fd call 4000cbd0 <_Chain_Get>
4001a7e0: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
4001a7e4: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001a7e8: 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)--;
4001a7ec: 82 00 7f ff add %g1, -1, %g1
4001a7f0: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001a7f4: 40 00 15 39 call 4001fcd8 <rtems_rfs_buffer_bdbuf_release>
4001a7f8: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
4001a7fc: 80 a2 20 00 cmp %o0, 0
4001a800: 24 80 00 06 ble,a 4001a818 <rtems_rfs_release_chain+0x78><== ALWAYS TAKEN
4001a804: c2 07 40 00 ld [ %i5 ], %g1
4001a808: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001a80c: 22 80 00 02 be,a 4001a814 <rtems_rfs_release_chain+0x74> <== NOT EXECUTED
4001a810: 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))
4001a814: c2 07 40 00 ld [ %i5 ], %g1
4001a818: 80 a0 40 1c cmp %g1, %i4
4001a81c: 12 bf ff f0 bne 4001a7dc <rtems_rfs_release_chain+0x3c>
4001a820: 01 00 00 00 nop
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
4001a824: 81 c7 e0 08 ret
4001a828: 81 e8 00 00 restore
40011e00 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
40011e00: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40011e04: 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);
40011e08: 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);
40011e0c: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40011e10: 94 07 bf d8 add %fp, -40, %o2
40011e14: 90 10 00 1d mov %i5, %o0
40011e18: 7f ff fc d5 call 4001116c <rtems_rfs_inode_open>
40011e1c: 96 10 20 01 mov 1, %o3
if (rc > 0)
40011e20: b8 92 20 00 orcc %o0, 0, %i4
40011e24: 04 80 00 07 ble 40011e40 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
40011e28: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
40011e2c: 40 00 38 c6 call 40020144 <__errno> <== NOT EXECUTED
40011e30: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40011e34: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40011e38: 81 c7 e0 08 ret <== NOT EXECUTED
40011e3c: 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();
40011e40: 40 00 11 71 call 40016404 <geteuid>
40011e44: 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;
40011e48: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
40011e4c: 91 2a 20 10 sll %o0, 0x10, %o0
40011e50: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40011e54: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40011e58: 85 28 a0 08 sll %g2, 8, %g2
40011e5c: 84 10 80 03 or %g2, %g3, %g2
40011e60: 85 28 a0 10 sll %g2, 0x10, %g2
40011e64: 80 a0 80 08 cmp %g2, %o0
40011e68: 02 80 00 0e be 40011ea0 <rtems_rfs_rtems_chown+0xa0> <== ALWAYS TAKEN
40011e6c: 87 32 20 10 srl %o0, 0x10, %g3
40011e70: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40011e74: 22 80 00 0c be,a 40011ea4 <rtems_rfs_rtems_chown+0xa4> <== NOT EXECUTED
40011e78: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
40011e7c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40011e80: 7f ff fd 2d call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
40011e84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
40011e88: 40 00 38 af call 40020144 <__errno> <== NOT EXECUTED
40011e8c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011e90: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40011e94: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40011e98: 81 c7 e0 08 ret <== NOT EXECUTED
40011e9c: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
40011ea0: b5 2e a0 10 sll %i2, 0x10, %i2
40011ea4: b4 16 80 19 or %i2, %i1, %i2
40011ea8: 85 36 a0 18 srl %i2, 0x18, %g2
40011eac: c4 28 60 04 stb %g2, [ %g1 + 4 ]
40011eb0: c2 07 bf e4 ld [ %fp + -28 ], %g1
40011eb4: 85 36 a0 10 srl %i2, 0x10, %g2
40011eb8: c4 28 60 05 stb %g2, [ %g1 + 5 ]
40011ebc: c2 07 bf e4 ld [ %fp + -28 ], %g1
40011ec0: b5 36 a0 08 srl %i2, 8, %i2
40011ec4: f4 28 60 06 stb %i2, [ %g1 + 6 ]
40011ec8: 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);
40011ecc: 90 10 00 1d mov %i5, %o0
40011ed0: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011ed4: 82 10 20 01 mov 1, %g1
40011ed8: 92 07 bf d8 add %fp, -40, %o1
40011edc: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40011ee0: 7f ff fd 15 call 40011334 <rtems_rfs_inode_close>
40011ee4: b0 10 20 00 clr %i0
if (rc)
40011ee8: 80 a2 20 00 cmp %o0, 0
40011eec: 02 80 00 05 be 40011f00 <rtems_rfs_rtems_chown+0x100> <== ALWAYS TAKEN
40011ef0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
40011ef4: 40 00 38 94 call 40020144 <__errno> <== NOT EXECUTED
40011ef8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011efc: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40011f00: 81 c7 e0 08 ret
40011f04: 81 e8 00 00 restore
4001e6e4 <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);
4001e6e4: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
4001e6e8: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
4001e6ec: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001e6f0: 40 00 03 4d call 4001f424 <rtems_deviceio_close> <== NOT EXECUTED
4001e6f4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001e6a0 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
4001e6a0: 81 c3 e0 08 retl <== NOT EXECUTED
4001e6a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e6a8 <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);
4001e6a8: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
4001e6ac: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4001e6b0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001e6b4: 40 00 03 9c call 4001f524 <rtems_deviceio_control> <== NOT EXECUTED
4001e6b8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001e74c <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
4001e74c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001e750: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
4001e754: 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);
4001e758: 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);
4001e75c: 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
};
4001e760: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
4001e764: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001e768: 7f ff b6 56 call 4000c0c0 <rtems_semaphore_obtain> <== NOT EXECUTED
4001e76c: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4001e770: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001e774: 02 80 00 0f be 4001e7b0 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
4001e778: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001e77c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e780: 7f ff d1 04 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e784: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001e788: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e78c: 22 80 00 09 be,a 4001e7b0 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
4001e790: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001e794: 7f ff de 45 call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001e798: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001e79c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001e7a0: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
4001e7a4: 40 00 0b c1 call 400216a8 <printf> <== NOT EXECUTED
4001e7a8: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400336d8 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001e7ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e7b0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001e7b4: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
4001e7b8: 7f ff ca 6d call 4001116c <rtems_rfs_inode_open> <== NOT EXECUTED
4001e7bc: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
4001e7c0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001e7c4: 04 80 00 09 ble 4001e7e8 <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
4001e7c8: 92 10 20 00 clr %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4001e7cc: 7f ff ff cb call 4001e6f8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001e7d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
4001e7d4: 40 00 06 5c call 40020144 <__errno> <== NOT EXECUTED
4001e7d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001e7dc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001e7e0: 81 c7 e0 08 ret <== NOT EXECUTED
4001e7e4: 81 e8 00 00 restore <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
4001e7e8: 7f ff ff 9e call 4001e660 <rtems_rfs_inode_get_block> <== NOT EXECUTED
4001e7ec: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
4001e7f0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
4001e7f4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
4001e7f8: 7f ff ff 9a call 4001e660 <rtems_rfs_inode_get_block> <== NOT EXECUTED
4001e7fc: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4001e800: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
4001e804: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4001e808: 7f ff ca cb call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001e80c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e810: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
if (rc > 0)
4001e814: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4001e818: 04 80 00 09 ble 4001e83c <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
4001e81c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4001e820: 7f ff ff b6 call 4001e6f8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001e824: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
4001e828: 40 00 06 47 call 40020144 <__errno> <== NOT EXECUTED
4001e82c: 01 00 00 00 nop <== NOT EXECUTED
4001e830: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
4001e834: 81 c7 e0 08 ret <== NOT EXECUTED
4001e838: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4001e83c: 7f ff ff af call 4001e6f8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001e840: 01 00 00 00 nop <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
4001e844: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
4001e848: f8 26 20 2c st %i4, [ %i0 + 0x2c ] <== NOT EXECUTED
iop->data1 = (void *) minor;
4001e84c: e0 26 20 30 st %l0, [ %i0 + 0x30 ] <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
4001e850: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001e854: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001e858: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001e85c: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
4001e860: 40 00 02 e4 call 4001f3f0 <rtems_deviceio_open> <== NOT EXECUTED
4001e864: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
4001e868: 81 c7 e0 08 ret <== NOT EXECUTED
4001e86c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4001e6d0 <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);
4001e6d0: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
4001e6d4: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4001e6d8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001e6dc: 40 00 03 5e call 4001f454 <rtems_deviceio_read> <== NOT EXECUTED
4001e6e0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001e6bc <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);
4001e6bc: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
4001e6c0: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4001e6c4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001e6c8: 40 00 03 7d call 4001f4bc <rtems_deviceio_write> <== NOT EXECUTED
4001e6cc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001ea1c <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
4001ea1c: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001ea20: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
4001ea24: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001ea28: fa 00 60 08 ld [ %g1 + 8 ], %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
4001ea2c: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
4001ea30: 7f ff ff 92 call 4001e878 <rtems_rfs_mutex_lock.isra.0>
4001ea34: d0 00 40 00 ld [ %g1 ], %o0
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001ea38: 92 10 00 1c mov %i4, %o1
4001ea3c: 90 10 00 1d mov %i5, %o0
4001ea40: 94 07 bf d8 add %fp, -40, %o2
4001ea44: 7f ff c9 ca call 4001116c <rtems_rfs_inode_open>
4001ea48: 96 10 20 01 mov 1, %o3
if (rc)
4001ea4c: b8 92 20 00 orcc %o0, 0, %i4
4001ea50: 02 80 00 09 be 4001ea74 <rtems_rfs_rtems_dir_open+0x58> <== ALWAYS TAKEN
4001ea54: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_rfs_rtems_unlock (fs);
4001ea58: 7f ff ff a0 call 4001e8d8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001ea5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
4001ea60: 40 00 05 b9 call 40020144 <__errno> <== NOT EXECUTED
4001ea64: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001ea68: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001ea6c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ea70: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4001ea74: c4 08 60 02 ldub [ %g1 + 2 ], %g2
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
4001ea78: 03 00 00 3c sethi %hi(0xf000), %g1
4001ea7c: 85 28 a0 08 sll %g2, 8, %g2
4001ea80: 84 08 80 01 and %g2, %g1, %g2
4001ea84: 03 00 00 10 sethi %hi(0x4000), %g1
4001ea88: 80 a0 80 01 cmp %g2, %g1
4001ea8c: 02 80 00 0c be 4001eabc <rtems_rfs_rtems_dir_open+0xa0> <== ALWAYS TAKEN
4001ea90: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &inode);
4001ea94: 7f ff ca 28 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001ea98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4001ea9c: 7f ff ff 8f call 4001e8d8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001eaa0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
4001eaa4: 40 00 05 a8 call 40020144 <__errno> <== NOT EXECUTED
4001eaa8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001eaac: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
4001eab0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001eab4: 81 c7 e0 08 ret <== NOT EXECUTED
4001eab8: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
4001eabc: c0 26 20 08 clr [ %i0 + 8 ]
4001eac0: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_rfs_inode_close (fs, &inode);
4001eac4: 7f ff ca 1c call 40011334 <rtems_rfs_inode_close>
4001eac8: 90 10 00 1d mov %i5, %o0
rtems_rfs_rtems_unlock (fs);
4001eacc: 90 10 00 1d mov %i5, %o0
4001ead0: 7f ff ff 82 call 4001e8d8 <rtems_rfs_rtems_unlock>
4001ead4: b0 10 20 00 clr %i0
return 0;
}
4001ead8: 81 c7 e0 08 ret
4001eadc: 81 e8 00 00 restore
4001e92c <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
4001e92c: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001e930: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
4001e934: 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);
4001e938: fa 00 60 08 ld [ %g1 + 8 ], %i5
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001e93c: a0 07 bf d8 add %fp, -40, %l0
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
4001e940: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
4001e944: 7f ff ff cd call 4001e878 <rtems_rfs_mutex_lock.isra.0>
4001e948: d0 00 40 00 ld [ %g1 ], %o0
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001e94c: 92 10 00 1c mov %i4, %o1
4001e950: 90 10 00 1d mov %i5, %o0
4001e954: 94 10 00 10 mov %l0, %o2
4001e958: 7f ff ca 05 call 4001116c <rtems_rfs_inode_open>
4001e95c: 96 10 20 01 mov 1, %o3
if (rc)
4001e960: b8 92 20 00 orcc %o0, 0, %i4
4001e964: 02 80 00 1f be 4001e9e0 <rtems_rfs_rtems_dir_read+0xb4> <== ALWAYS TAKEN
4001e968: 90 10 00 1a mov %i2, %o0
{
rtems_rfs_rtems_unlock (fs);
4001e96c: 7f ff ff db call 4001e8d8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001e970: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
4001e974: 40 00 05 f4 call 40020144 <__errno> <== NOT EXECUTED
4001e978: 01 00 00 00 nop <== NOT EXECUTED
4001e97c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001e980: 10 80 00 25 b 4001ea14 <rtems_rfs_rtems_dir_read+0xe8> <== NOT EXECUTED
4001e984: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
4001e988: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
4001e98c: 90 10 00 1d mov %i5, %o0
4001e990: 92 10 00 10 mov %l0, %o1
4001e994: 7f ff f5 35 call 4001be68 <rtems_rfs_dir_read>
4001e998: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
4001e99c: 80 a2 20 02 cmp %o0, 2
4001e9a0: 02 80 00 18 be 4001ea00 <rtems_rfs_rtems_dir_read+0xd4>
4001e9a4: b4 10 00 08 mov %o0, %i2
{
rc = 0;
break;
}
if (rc > 0)
4001e9a8: 80 a2 20 00 cmp %o0, 0
4001e9ac: 24 80 00 06 ble,a 4001e9c4 <rtems_rfs_rtems_dir_read+0x98><== ALWAYS TAKEN
4001e9b0: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
4001e9b4: 40 00 05 e4 call 40020144 <__errno> <== NOT EXECUTED
4001e9b8: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
4001e9bc: 10 80 00 11 b 4001ea00 <rtems_rfs_rtems_dir_read+0xd4> <== NOT EXECUTED
4001e9c0: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
break;
}
iop->offset += size;
4001e9c4: c2 07 bf d4 ld [ %fp + -44 ], %g1
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
4001e9c8: b8 07 21 18 add %i4, 0x118, %i4
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
4001e9cc: 86 80 c0 01 addcc %g3, %g1, %g3
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
4001e9d0: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
4001e9d4: 84 40 a0 00 addx %g2, 0, %g2
4001e9d8: 10 80 00 07 b 4001e9f4 <rtems_rfs_rtems_dir_read+0xc8>
4001e9dc: c4 3e 20 08 std %g2, [ %i0 + 8 ]
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
4001e9e0: 92 10 21 18 mov 0x118, %o1
4001e9e4: 7f ff 8f 26 call 4000267c <.udiv>
4001e9e8: b6 10 20 00 clr %i3
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
4001e9ec: b8 10 20 00 clr %i4
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
4001e9f0: a2 10 00 08 mov %o0, %l1
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
4001e9f4: 80 a6 c0 11 cmp %i3, %l1
4001e9f8: 12 bf ff e4 bne 4001e988 <rtems_rfs_rtems_dir_read+0x5c>
4001e9fc: 98 06 40 1c add %i1, %i4, %o4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
4001ea00: 90 10 00 1d mov %i5, %o0
4001ea04: 7f ff ca 4c call 40011334 <rtems_rfs_inode_close>
4001ea08: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_rtems_unlock (fs);
4001ea0c: 7f ff ff b3 call 4001e8d8 <rtems_rfs_rtems_unlock>
4001ea10: 90 10 00 1d mov %i5, %o0
return bytes_transferred;
}
4001ea14: 81 c7 e0 08 ret
4001ea18: 91 e8 00 1c restore %g0, %i4, %o0
40012058 <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)
{
40012058: 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);
4001205c: 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);
40012060: 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);
40012064: 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);
40012068: 94 07 bf d8 add %fp, -40, %o2
4001206c: 90 10 00 1d mov %i5, %o0
40012070: 7f ff fc 3f call 4001116c <rtems_rfs_inode_open>
40012074: 96 10 20 01 mov 1, %o3
if (rc == 0) {
40012078: b8 92 20 00 orcc %o0, 0, %i4
4001207c: 12 80 00 10 bne 400120bc <rtems_rfs_rtems_eval_path+0x64> <== NEVER TAKEN
40012080: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_generic (
40012084: 92 07 bf d8 add %fp, -40, %o1
40012088: 15 10 00 cd sethi %hi(0x40033400), %o2
4001208c: 40 00 12 03 call 40016898 <rtems_filesystem_eval_path_generic>
40012090: 94 12 a3 c0 or %o2, 0x3c0, %o2 ! 400337c0 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
40012094: 90 10 00 1d mov %i5, %o0
40012098: 7f ff fc a7 call 40011334 <rtems_rfs_inode_close>
4001209c: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
400120a0: ba 92 20 00 orcc %o0, 0, %i5
400120a4: 02 80 00 0c be 400120d4 <rtems_rfs_rtems_eval_path+0x7c> <== ALWAYS TAKEN
400120a8: 01 00 00 00 nop
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
400120ac: 40 00 38 26 call 40020144 <__errno> <== NOT EXECUTED
400120b0: 01 00 00 00 nop <== NOT EXECUTED
400120b4: 10 80 00 05 b 400120c8 <rtems_rfs_rtems_eval_path+0x70> <== NOT EXECUTED
400120b8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
400120bc: 40 00 38 22 call 40020144 <__errno> <== NOT EXECUTED
400120c0: 01 00 00 00 nop <== NOT EXECUTED
400120c4: 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 (
400120c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400120cc: 7f ff db 27 call 40008d68 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400120d0: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
400120d4: 81 c7 e0 08 ret
400120d8: 81 e8 00 00 restore
400124b0 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
400124b0: 9d e3 bf 90 save %sp, -112, %sp
400124b4: f8 06 60 0c ld [ %i1 + 0xc ], %i4
400124b8: ba 10 00 18 mov %i0, %i5
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
400124bc: c2 0f 20 07 ldub [ %i4 + 7 ], %g1
400124c0: f0 0f 20 06 ldub [ %i4 + 6 ], %i0
static bool
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
int eval_flags,
rtems_rfs_inode_handle* inode)
{
return rtems_filesystem_eval_path_check_access(
400124c4: 90 10 00 19 mov %i1, %o0
400124c8: b1 2e 20 08 sll %i0, 8, %i0
400124cc: 7f ff fd 5a call 40011a34 <rtems_rfs_inode_get_gid>
400124d0: b0 16 00 01 or %i0, %g1, %i0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
400124d4: c2 0f 20 02 ldub [ %i4 + 2 ], %g1
400124d8: d4 0f 20 03 ldub [ %i4 + 3 ], %o2
400124dc: 83 28 60 08 sll %g1, 8, %g1
400124e0: 97 2e 20 10 sll %i0, 0x10, %o3
400124e4: 99 2a 20 10 sll %o0, 0x10, %o4
400124e8: 92 10 20 01 mov 1, %o1
400124ec: 90 10 00 1d mov %i5, %o0
400124f0: 94 12 80 01 or %o2, %g1, %o2
400124f4: 97 32 e0 10 srl %o3, 0x10, %o3
400124f8: 99 33 20 10 srl %o4, 0x10, %o4
400124fc: 40 00 10 d9 call 40016860 <rtems_filesystem_eval_path_check_access>
40012500: 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) {
40012504: 80 8a 20 ff btst 0xff, %o0
40012508: 02 80 00 71 be 400126cc <rtems_rfs_rtems_eval_token+0x21c>
4001250c: 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] == '.';
40012510: 12 80 00 06 bne 40012528 <rtems_rfs_rtems_eval_token+0x78>
40012514: 82 10 20 00 clr %g1
40012518: c2 4e 80 00 ldsb [ %i2 ], %g1
4001251c: 82 18 60 2e xor %g1, 0x2e, %g1
40012520: 80 a0 00 01 cmp %g0, %g1
40012524: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
40012528: 80 a0 60 00 cmp %g1, 0
4001252c: 22 80 00 04 be,a 4001253c <rtems_rfs_rtems_eval_token+0x8c>
40012530: 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;
40012534: 10 80 00 44 b 40012644 <rtems_rfs_rtems_eval_token+0x194>
40012538: c0 27 60 0c clr [ %i5 + 0xc ]
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
4001253c: 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);
40012540: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
40012544: 94 10 00 1a mov %i2, %o2
40012548: 90 10 00 1c mov %i4, %o0
4001254c: 96 10 00 1b mov %i3, %o3
40012550: 98 07 bf f4 add %fp, -12, %o4
40012554: 9a 07 bf f8 add %fp, -8, %o5
40012558: 40 00 23 25 call 4001b1ec <rtems_rfs_dir_lookup_ino>
4001255c: b0 10 20 02 mov 2, %i0
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
40012560: 80 a2 20 00 cmp %o0, 0
40012564: 12 80 00 5a bne 400126cc <rtems_rfs_rtems_eval_token+0x21c>
40012568: 90 10 00 1c mov %i4, %o0
rc = rtems_rfs_inode_close (fs, inode);
4001256c: 7f ff fb 72 call 40011334 <rtems_rfs_inode_close>
40012570: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
40012574: 80 a2 20 00 cmp %o0, 0
40012578: 02 80 00 07 be 40012594 <rtems_rfs_rtems_eval_token+0xe4> <== ALWAYS TAKEN
4001257c: 90 10 00 19 mov %i1, %o0
if (rc != 0) {
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
40012580: 92 10 20 00 clr %o1 <== NOT EXECUTED
40012584: 40 00 3b cb call 400214b0 <memset> <== NOT EXECUTED
40012588: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4001258c: 81 c7 e0 08 ret <== NOT EXECUTED
40012590: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
if (rc == 0) {
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
40012594: d2 07 bf f4 ld [ %fp + -12 ], %o1
40012598: 90 10 00 1c mov %i4, %o0
4001259c: 94 10 00 19 mov %i1, %o2
400125a0: 7f ff fa f3 call 4001116c <rtems_rfs_inode_open>
400125a4: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
400125a8: 80 a2 20 00 cmp %o0, 0
400125ac: 02 80 00 2f be 40012668 <rtems_rfs_rtems_eval_token+0x1b8><== ALWAYS TAKEN
400125b0: 90 10 00 19 mov %i1, %o0
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
400125b4: 10 bf ff f4 b 40012584 <rtems_rfs_rtems_eval_token+0xd4> <== NOT EXECUTED
400125b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
400125bc: 02 80 00 04 be 400125cc <rtems_rfs_rtems_eval_token+0x11c>
400125c0: 80 88 a0 ff btst 0xff, %g2
400125c4: 02 80 00 23 be 40012650 <rtems_rfs_rtems_eval_token+0x1a0>
400125c8: 90 07 60 18 add %i5, 0x18, %o0
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
400125cc: 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);
400125d0: f4 07 bf f4 ld [ %fp + -12 ], %i2
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
400125d4: c2 27 bf fc st %g1, [ %fp + -4 ]
char *link = malloc(len + 1);
400125d8: 7f ff d5 ec call 40007d88 <malloc>
400125dc: 90 10 24 01 mov 0x401, %o0
if (link != NULL) {
400125e0: b6 92 20 00 orcc %o0, 0, %i3
400125e4: 02 80 00 14 be 40012634 <rtems_rfs_rtems_eval_token+0x184><== NEVER TAKEN
400125e8: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
400125ec: 92 10 00 1a mov %i2, %o1
400125f0: 94 10 00 1b mov %i3, %o2
400125f4: 96 10 24 00 mov 0x400, %o3
400125f8: 40 00 2f 78 call 4001e3d8 <rtems_rfs_symlink_read>
400125fc: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
40012600: 80 a2 20 00 cmp %o0, 0
40012604: 12 80 00 06 bne 4001261c <rtems_rfs_rtems_eval_token+0x16c><== NEVER TAKEN
40012608: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
4001260c: d4 07 bf fc ld [ %fp + -4 ], %o2
40012610: 7f ff da d4 call 40009160 <rtems_filesystem_eval_path_recursive>
40012614: 92 10 00 1b mov %i3, %o1
40012618: 30 80 00 03 b,a 40012624 <rtems_rfs_rtems_eval_token+0x174>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
4001261c: 7f ff d9 d3 call 40008d68 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40012620: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
free(link);
40012624: 7f ff d4 48 call 40007744 <free>
40012628: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4001262c: 81 c7 e0 08 ret
40012630: 91 e8 20 01 restore %g0, 1, %o0
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
40012634: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012638: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
4001263c: 7f ff d9 cb call 40008d68 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40012640: 01 00 00 00 nop <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40012644: 81 c7 e0 08 ret
40012648: 91 e8 20 01 restore %g0, 1, %o0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
4001264c: 90 07 60 18 add %i5, 0x18, %o0
40012650: 40 00 01 1d call 40012ac4 <rtems_rfs_rtems_set_handlers>
40012654: 92 10 00 19 mov %i1, %o1
40012658: 80 8a 20 ff btst 0xff, %o0
4001265c: 12 80 00 18 bne 400126bc <rtems_rfs_rtems_eval_token+0x20c><== ALWAYS TAKEN
40012660: c2 07 bf f4 ld [ %fp + -12 ], %g1
40012664: 30 80 00 0f b,a 400126a0 <rtems_rfs_rtems_eval_token+0x1f0><== NOT EXECUTED
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
rc = -1;
}
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
40012668: 7f ff ff 53 call 400123b4 <rtems_rfs_rtems_node_type_by_inode>
4001266c: 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);
40012670: 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;
40012674: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40012678: 80 a0 00 01 cmp %g0, %g1
4001267c: c0 27 60 0c clr [ %i5 + 0xc ]
40012680: 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;
40012684: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40012688: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
4001268c: 80 a2 20 03 cmp %o0, 3
40012690: 12 bf ff ef bne 4001264c <rtems_rfs_rtems_eval_token+0x19c>
40012694: 84 08 a0 01 and %g2, 1, %g2
40012698: 10 bf ff c9 b 400125bc <rtems_rfs_rtems_eval_token+0x10c>
4001269c: 80 a0 60 00 cmp %g1, 0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
400126a0: 40 00 36 a9 call 40020144 <__errno> <== NOT EXECUTED
400126a4: 01 00 00 00 nop <== NOT EXECUTED
400126a8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
400126ac: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
400126b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
400126b4: 10 bf ff e2 b 4001263c <rtems_rfs_rtems_eval_token+0x18c> <== NOT EXECUTED
400126b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
400126bc: 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);
400126c0: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
400126c4: c2 07 bf f8 ld [ %fp + -8 ], %g1
400126c8: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
400126cc: 81 c7 e0 08 ret
400126d0: 81 e8 00 00 restore
40012974 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
40012974: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012978: 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);
4001297c: 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);
40012980: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40012984: 94 07 bf d8 add %fp, -40, %o2
40012988: 90 10 00 1d mov %i5, %o0
4001298c: 7f ff f9 f8 call 4001116c <rtems_rfs_inode_open>
40012990: 96 10 20 01 mov 1, %o3
if (rc)
40012994: b8 92 20 00 orcc %o0, 0, %i4
40012998: 02 80 00 07 be 400129b4 <rtems_rfs_rtems_fchmod+0x40> <== ALWAYS TAKEN
4001299c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
400129a0: 40 00 35 e9 call 40020144 <__errno> <== NOT EXECUTED
400129a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400129a8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400129ac: 81 c7 e0 08 ret <== NOT EXECUTED
400129b0: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
400129b4: f8 08 60 02 ldub [ %g1 + 2 ], %i4
400129b8: c2 08 60 03 ldub [ %g1 + 3 ], %g1
400129bc: b9 2f 20 08 sll %i4, 8, %i4
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
400129c0: 40 00 0e 91 call 40016404 <geteuid>
400129c4: b8 17 00 01 or %i4, %g1, %i4
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
400129c8: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
400129cc: 91 2a 20 10 sll %o0, 0x10, %o0
400129d0: c6 08 60 07 ldub [ %g1 + 7 ], %g3
400129d4: c4 08 60 06 ldub [ %g1 + 6 ], %g2
400129d8: 85 28 a0 08 sll %g2, 8, %g2
400129dc: 84 10 80 03 or %g2, %g3, %g2
400129e0: 85 28 a0 10 sll %g2, 0x10, %g2
400129e4: 80 a0 80 08 cmp %g2, %o0
400129e8: 02 80 00 0e be 40012a20 <rtems_rfs_rtems_fchmod+0xac> <== ALWAYS TAKEN
400129ec: 87 32 20 10 srl %o0, 0x10, %g3
400129f0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
400129f4: 22 80 00 0c be,a 40012a24 <rtems_rfs_rtems_fchmod+0xb0> <== NOT EXECUTED
400129f8: b8 0f 30 00 and %i4, -4096, %i4 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
400129fc: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012a00: 7f ff fa 4d call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
40012a04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
40012a08: 40 00 35 cf call 40020144 <__errno> <== NOT EXECUTED
40012a0c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012a10: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40012a14: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012a18: 81 c7 e0 08 ret <== NOT EXECUTED
40012a1c: 81 e8 00 00 restore <== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40012a20: b8 0f 30 00 and %i4, -4096, %i4
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40012a24: b2 0e 6f ff and %i1, 0xfff, %i1
40012a28: b2 17 00 19 or %i4, %i1, %i1
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
40012a2c: 85 36 60 08 srl %i1, 8, %g2
40012a30: c4 28 60 02 stb %g2, [ %g1 + 2 ]
40012a34: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
40012a38: 90 10 00 1d mov %i5, %o0
40012a3c: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012a40: 82 10 20 01 mov 1, %g1
40012a44: 92 07 bf d8 add %fp, -40, %o1
40012a48: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40012a4c: 7f ff fa 3a call 40011334 <rtems_rfs_inode_close>
40012a50: b0 10 20 00 clr %i0
if (rc > 0)
40012a54: 80 a2 20 00 cmp %o0, 0
40012a58: 04 80 00 05 ble 40012a6c <rtems_rfs_rtems_fchmod+0xf8> <== ALWAYS TAKEN
40012a5c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
40012a60: 40 00 35 b9 call 40020144 <__errno> <== NOT EXECUTED
40012a64: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012a68: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012a6c: 81 c7 e0 08 ret
40012a70: 81 e8 00 00 restore
40012a90 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
40012a90: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40012a94: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
40012a98: 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));
40012a9c: 40 00 21 19 call 4001af00 <rtems_rfs_buffer_sync> <== NOT EXECUTED
40012aa0: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
40012aa4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012aa8: 02 80 00 05 be 40012abc <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
40012aac: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
40012ab0: 40 00 35 a5 call 40020144 <__errno> <== NOT EXECUTED
40012ab4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012ab8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
40012abc: 81 c7 e0 08 ret <== NOT EXECUTED
40012ac0: 81 e8 00 00 restore <== NOT EXECUTED
4001ee50 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
4001ee50: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001ee54: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
4001ee58: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
4001ee5c: fa 00 60 98 ld [ %g1 + 0x98 ], %i5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
4001ee60: 7f ff ff 20 call 4001eae0 <rtems_rfs_rtems_lock>
4001ee64: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_file_close (fs, file);
4001ee68: 90 10 00 1d mov %i5, %o0
4001ee6c: 7f ff f5 7a call 4001c454 <rtems_rfs_file_close>
4001ee70: 92 10 00 1c mov %i4, %o1
if (rc > 0)
4001ee74: b0 92 20 00 orcc %o0, 0, %i0
4001ee78: 04 80 00 06 ble 4001ee90 <rtems_rfs_rtems_file_close+0x40><== ALWAYS TAKEN
4001ee7c: 01 00 00 00 nop
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
4001ee80: 40 00 04 b1 call 40020144 <__errno> <== NOT EXECUTED
4001ee84: 01 00 00 00 nop <== NOT EXECUTED
4001ee88: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
4001ee8c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4001ee90: 7f ff ff 29 call 4001eb34 <rtems_rfs_rtems_unlock>
4001ee94: 90 10 00 1d mov %i5, %o0
return rc;
}
4001ee98: 81 c7 e0 08 ret
4001ee9c: 81 e8 00 00 restore
4001eb88 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
4001eb88: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001eb8c: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
4001eb90: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001eb94: 7f ff ff d3 call 4001eae0 <rtems_rfs_rtems_lock>
4001eb98: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rc = rtems_rfs_file_set_size (file, length);
4001eb9c: 90 10 00 1b mov %i3, %o0
4001eba0: 92 10 00 19 mov %i1, %o1
4001eba4: 7f ff f8 4c call 4001ccd4 <rtems_rfs_file_set_size>
4001eba8: 94 10 00 1a mov %i2, %o2
if (rc)
4001ebac: b0 92 20 00 orcc %o0, 0, %i0
4001ebb0: 22 80 00 07 be,a 4001ebcc <rtems_rfs_rtems_file_ftruncate+0x44><== ALWAYS TAKEN
4001ebb4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
4001ebb8: 40 00 05 63 call 40020144 <__errno> <== NOT EXECUTED
4001ebbc: 01 00 00 00 nop <== NOT EXECUTED
4001ebc0: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
4001ebc4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001ebc8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
4001ebcc: 7f ff ff da call 4001eb34 <rtems_rfs_rtems_unlock>
4001ebd0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return rc;
}
4001ebd4: 81 c7 e0 08 ret
4001ebd8: 81 e8 00 00 restore
4001ebdc <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
4001ebdc: 9d e3 bf 98 save %sp, -104, %sp
4001ebe0: b8 10 00 19 mov %i1, %i4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001ebe4: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
4001ebe8: ba 10 00 1a mov %i2, %i5
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
4001ebec: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
4001ebf0: a0 10 00 1b mov %i3, %l0
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
4001ebf4: 7f ff ff bb call 4001eae0 <rtems_rfs_rtems_lock>
4001ebf8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
4001ebfc: 92 10 00 1c mov %i4, %o1
4001ec00: 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;
4001ec04: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
4001ec08: 90 10 00 18 mov %i0, %o0
4001ec0c: 40 00 01 26 call 4001f0a4 <rtems_filesystem_default_lseek_file>
4001ec10: 96 10 00 10 mov %l0, %o3
4001ec14: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
4001ec18: 80 a7 3f ff cmp %i4, -1
4001ec1c: 12 80 00 05 bne 4001ec30 <rtems_rfs_rtems_file_lseek+0x54>
4001ec20: ba 10 00 09 mov %o1, %i5
4001ec24: 80 a2 7f ff cmp %o1, -1
4001ec28: 22 80 00 13 be,a 4001ec74 <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
4001ec2c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
4001ec30: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
4001ec34: 90 10 00 19 mov %i1, %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
4001ec38: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
4001ec3c: 92 10 00 02 mov %g2, %o1
4001ec40: 94 10 00 03 mov %g3, %o2
4001ec44: 7f ff f7 e6 call 4001cbdc <rtems_rfs_file_seek>
4001ec48: 96 07 bf f8 add %fp, -8, %o3
if (rc)
4001ec4c: a0 92 20 00 orcc %o0, 0, %l0
4001ec50: 22 80 00 09 be,a 4001ec74 <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
4001ec54: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
4001ec58: 40 00 05 3b call 40020144 <__errno> <== NOT EXECUTED
4001ec5c: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
4001ec60: e0 22 00 00 st %l0, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
4001ec64: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
new_offset = -1;
4001ec68: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
4001ec6c: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001ec70: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
return new_offset;
}
4001ec74: b0 10 00 1c mov %i4, %i0
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001ec78: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ec7c: 7f ff ff ae call 4001eb34 <rtems_rfs_rtems_unlock>
4001ec80: b2 10 00 1d mov %i5, %i1
return new_offset;
}
4001ec84: 81 c7 e0 08 ret
4001ec88: 81 e8 00 00 restore
4001eea0 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
4001eea0: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001eea4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4001eea8: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04i mode:%04" PRIu32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
4001eeac: 7f ff ff 0d call 4001eae0 <rtems_rfs_rtems_lock>
4001eeb0: 90 10 00 1d mov %i5, %o0
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
4001eeb4: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
4001eeb8: 90 10 00 1d mov %i5, %o0
4001eebc: 94 10 20 00 clr %o2
4001eec0: 7f ff f8 5d call 4001d034 <rtems_rfs_file_open>
4001eec4: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
4001eec8: b8 92 20 00 orcc %o0, 0, %i4
4001eecc: 04 80 00 09 ble 4001eef0 <rtems_rfs_rtems_file_open+0x50> <== ALWAYS TAKEN
4001eed0: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rtems_rfs_rtems_unlock (fs);
4001eed4: 7f ff ff 18 call 4001eb34 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001eed8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
4001eedc: 40 00 04 9a call 40020144 <__errno> <== NOT EXECUTED
4001eee0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001eee4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001eee8: 81 c7 e0 08 ret <== NOT EXECUTED
4001eeec: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
4001eef0: 90 10 00 1d mov %i5, %o0
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
4001eef4: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_rfs_rtems_unlock (fs);
4001eef8: 7f ff ff 0f call 4001eb34 <rtems_rfs_rtems_unlock>
4001eefc: b0 10 20 00 clr %i0
return 0;
}
4001ef00: 81 c7 e0 08 ret
4001ef04: 81 e8 00 00 restore
4001ef08 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
4001ef08: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001ef0c: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
4001ef10: a2 10 00 18 mov %i0, %l1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
4001ef14: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001ef18: 7f ff fe f2 call 4001eae0 <rtems_rfs_rtems_lock>
4001ef1c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
4001ef20: 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;
4001ef24: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
4001ef28: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ef2c: 7f ff ea ec call 40019adc <rtems_rfs_block_get_size>
4001ef30: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
4001ef34: 80 a2 00 1c cmp %o0, %i4
4001ef38: 38 80 00 2b bgu,a 4001efe4 <rtems_rfs_rtems_file_read+0xdc><== NEVER TAKEN
4001ef3c: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001ef40: 80 a2 00 1c cmp %o0, %i4
4001ef44: 12 80 00 2e bne 4001effc <rtems_rfs_rtems_file_read+0xf4> <== NEVER TAKEN
4001ef48: b0 10 20 00 clr %i0
4001ef4c: 80 a2 40 1d cmp %o1, %i5
4001ef50: 18 80 00 25 bgu 4001efe4 <rtems_rfs_rtems_file_read+0xdc>
4001ef54: 01 00 00 00 nop
}
}
}
if (read >= 0)
iop->offset = pos + read;
4001ef58: 10 80 00 2a b 4001f000 <rtems_rfs_rtems_file_read+0xf8>
4001ef5c: b6 86 00 1d addcc %i0, %i5, %i3
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
4001ef60: 92 07 bf fc add %fp, -4, %o1
4001ef64: 7f ff f5 e8 call 4001c704 <rtems_rfs_file_io_start>
4001ef68: 94 10 20 01 mov 1, %o2
if (rc > 0)
4001ef6c: b6 92 20 00 orcc %o0, 0, %i3
4001ef70: 14 80 00 19 bg 4001efd4 <rtems_rfs_rtems_file_read+0xcc> <== NEVER TAKEN
4001ef74: c2 07 bf fc ld [ %fp + -4 ], %g1
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
4001ef78: 80 a0 60 00 cmp %g1, 0
4001ef7c: 02 80 00 1d be 4001eff0 <rtems_rfs_rtems_file_read+0xe8>
4001ef80: 80 a0 40 1a cmp %g1, %i2
break;
if (size > count)
4001ef84: 38 80 00 02 bgu,a 4001ef8c <rtems_rfs_rtems_file_read+0x84>
4001ef88: f4 27 bf fc st %i2, [ %fp + -4 ]
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
4001ef8c: c2 04 20 0c ld [ %l0 + 0xc ], %g1
4001ef90: f6 07 bf fc ld [ %fp + -4 ], %i3
4001ef94: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
4001ef98: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
4001ef9c: 94 10 00 1b mov %i3, %o2
4001efa0: 92 02 40 01 add %o1, %g1, %o1
4001efa4: 40 00 08 b4 call 40021274 <memcpy>
4001efa8: 90 10 00 19 mov %i1, %o0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
4001efac: 92 10 00 1b mov %i3, %o1
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
4001efb0: b2 06 40 1b add %i1, %i3, %i1
count -= size;
4001efb4: b4 26 80 1b sub %i2, %i3, %i2
read += size;
4001efb8: b0 06 00 1b add %i0, %i3, %i0
rc = rtems_rfs_file_io_end (file, size, true);
4001efbc: 90 10 00 10 mov %l0, %o0
4001efc0: 7f ff f6 5a call 4001c928 <rtems_rfs_file_io_end>
4001efc4: 94 10 20 01 mov 1, %o2
if (rc > 0)
4001efc8: b6 92 20 00 orcc %o0, 0, %i3
4001efcc: 04 80 00 07 ble 4001efe8 <rtems_rfs_rtems_file_read+0xe0> <== ALWAYS TAKEN
4001efd0: 80 a6 a0 00 cmp %i2, 0
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
4001efd4: 40 00 04 5c call 40020144 <__errno> <== NOT EXECUTED
4001efd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001efdc: 10 80 00 0c b 4001f00c <rtems_rfs_rtems_file_read+0x104> <== NOT EXECUTED
4001efe0: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
4001efe4: 80 a6 a0 00 cmp %i2, 0
4001efe8: 12 bf ff de bne 4001ef60 <rtems_rfs_rtems_file_read+0x58>
4001efec: 90 10 00 10 mov %l0, %o0
break;
}
}
}
if (read >= 0)
4001eff0: 80 a6 20 00 cmp %i0, 0
4001eff4: 26 80 00 07 bl,a 4001f010 <rtems_rfs_rtems_file_read+0x108><== NEVER TAKEN
4001eff8: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
iop->offset = pos + read;
4001effc: b6 86 00 1d addcc %i0, %i5, %i3
4001f000: 85 3e 20 1f sra %i0, 0x1f, %g2
4001f004: b4 40 80 1c addx %g2, %i4, %i2
4001f008: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001f00c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001f010: 7f ff fe c9 call 4001eb34 <rtems_rfs_rtems_unlock>
4001f014: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return read;
}
4001f018: 81 c7 e0 08 ret
4001f01c: 81 e8 00 00 restore
4001ec8c <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
4001ec8c: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001ec90: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
4001ec94: a2 10 00 18 mov %i0, %l1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
4001ec98: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001ec9c: 7f ff ff 91 call 4001eae0 <rtems_rfs_rtems_lock>
4001eca0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
4001eca4: 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;
4001eca8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4001ecac: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ecb0: c4 3f bf f8 std %g2, [ %fp + -8 ]
4001ecb4: 7f ff eb 8a call 40019adc <rtems_rfs_block_get_size>
4001ecb8: 92 02 60 84 add %o1, 0x84, %o1
4001ecbc: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
4001ecc0: d2 07 bf f8 ld [ %fp + -8 ], %o1
4001ecc4: 82 10 00 08 mov %o0, %g1
4001ecc8: 80 a2 40 01 cmp %o1, %g1
4001eccc: 18 80 00 08 bgu 4001ecec <rtems_rfs_rtems_file_write+0x60><== NEVER TAKEN
4001ecd0: d4 07 bf fc ld [ %fp + -4 ], %o2
4001ecd4: 80 a2 40 01 cmp %o1, %g1
4001ecd8: 12 80 00 11 bne 4001ed1c <rtems_rfs_rtems_file_write+0x90><== NEVER TAKEN
4001ecdc: 80 a0 40 09 cmp %g1, %o1
4001ece0: 80 a2 80 03 cmp %o2, %g3
4001ece4: 08 80 00 0e bleu 4001ed1c <rtems_rfs_rtems_file_write+0x90>
4001ece8: 80 a0 40 09 cmp %g1, %o1
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
4001ecec: 7f ff f7 fa call 4001ccd4 <rtems_rfs_file_set_size>
4001ecf0: 90 10 00 10 mov %l0, %o0
4001ecf4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
if (rc)
4001ecf8: ba 92 20 00 orcc %o0, 0, %i5
4001ecfc: 12 80 00 20 bne 4001ed7c <rtems_rfs_rtems_file_write+0xf0><== NEVER TAKEN
4001ed00: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
4001ed04: d2 07 bf f8 ld [ %fp + -8 ], %o1
4001ed08: d4 07 bf fc ld [ %fp + -4 ], %o2
4001ed0c: 7f ff eb 44 call 40019a1c <rtems_rfs_block_get_bpos>
4001ed10: 96 04 20 10 add %l0, 0x10, %o3
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
4001ed14: 10 80 00 40 b 4001ee14 <rtems_rfs_rtems_file_write+0x188>
4001ed18: b0 10 20 00 clr %i0
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
4001ed1c: 38 80 00 09 bgu,a 4001ed40 <rtems_rfs_rtems_file_write+0xb4><== NEVER TAKEN
4001ed20: c4 04 60 10 ld [ %l1 + 0x10 ], %g2 <== NOT EXECUTED
4001ed24: 80 a0 40 09 cmp %g1, %o1
4001ed28: 12 80 00 3b bne 4001ee14 <rtems_rfs_rtems_file_write+0x188><== NEVER TAKEN
4001ed2c: b0 10 20 00 clr %i0
4001ed30: 80 a0 c0 0a cmp %g3, %o2
4001ed34: 08 80 00 39 bleu 4001ee18 <rtems_rfs_rtems_file_write+0x18c>
4001ed38: 80 a6 a0 00 cmp %i2, 0
4001ed3c: c4 04 60 10 ld [ %l1 + 0x10 ], %g2
4001ed40: 80 88 a2 00 btst 0x200, %g2
4001ed44: 22 80 00 34 be,a 4001ee14 <rtems_rfs_rtems_file_write+0x188>
4001ed48: b0 10 20 00 clr %i0
{
pos = file_size;
4001ed4c: c2 27 bf f8 st %g1, [ %fp + -8 ]
4001ed50: c6 27 bf fc st %g3, [ %fp + -4 ]
rc = rtems_rfs_file_seek (file, pos, &pos);
4001ed54: 90 10 00 10 mov %l0, %o0
4001ed58: 92 10 00 01 mov %g1, %o1
4001ed5c: 94 10 00 03 mov %g3, %o2
4001ed60: 7f ff f7 9f call 4001cbdc <rtems_rfs_file_seek>
4001ed64: 96 07 bf f8 add %fp, -8, %o3
if (rc)
4001ed68: ba 92 20 00 orcc %o0, 0, %i5
4001ed6c: 22 80 00 2a be,a 4001ee14 <rtems_rfs_rtems_file_write+0x188><== ALWAYS TAKEN
4001ed70: b0 10 20 00 clr %i0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001ed74: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
4001ed78: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001ed7c: 7f ff ff 6e call 4001eb34 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001ed80: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
4001ed84: 40 00 04 f0 call 40020144 <__errno> <== NOT EXECUTED
4001ed88: 01 00 00 00 nop <== NOT EXECUTED
4001ed8c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
4001ed90: 81 c7 e0 08 ret <== NOT EXECUTED
4001ed94: 81 e8 00 00 restore <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
4001ed98: 90 10 00 10 mov %l0, %o0
4001ed9c: 92 07 bf f4 add %fp, -12, %o1
4001eda0: 7f ff f6 59 call 4001c704 <rtems_rfs_file_io_start>
4001eda4: 94 10 20 00 clr %o2
if (rc)
4001eda8: ba 92 20 00 orcc %o0, 0, %i5
4001edac: 12 80 00 16 bne 4001ee04 <rtems_rfs_rtems_file_write+0x178>
4001edb0: c2 07 bf f4 ld [ %fp + -12 ], %g1
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
4001edb4: 80 a0 40 1a cmp %g1, %i2
4001edb8: 38 80 00 02 bgu,a 4001edc0 <rtems_rfs_rtems_file_write+0x134>
4001edbc: f4 27 bf f4 st %i2, [ %fp + -12 ]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
4001edc0: c2 04 20 0c ld [ %l0 + 0xc ], %g1
4001edc4: d4 07 bf f4 ld [ %fp + -12 ], %o2
4001edc8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001edcc: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
4001edd0: 92 10 00 19 mov %i1, %o1
4001edd4: 40 00 09 28 call 40021274 <memcpy>
4001edd8: 90 02 00 01 add %o0, %g1, %o0
data += size;
4001eddc: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
4001ede0: 90 10 00 10 mov %l0, %o0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
4001ede4: b2 06 40 09 add %i1, %o1, %i1
count -= size;
4001ede8: b4 26 80 09 sub %i2, %o1, %i2
write += size;
4001edec: b0 06 00 09 add %i0, %o1, %i0
rc = rtems_rfs_file_io_end (file, size, false);
4001edf0: 7f ff f6 ce call 4001c928 <rtems_rfs_file_io_end>
4001edf4: 94 10 20 00 clr %o2
if (rc)
4001edf8: ba 92 20 00 orcc %o0, 0, %i5
4001edfc: 02 80 00 07 be 4001ee18 <rtems_rfs_rtems_file_write+0x18c><== ALWAYS TAKEN
4001ee00: 80 a6 a0 00 cmp %i2, 0
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
4001ee04: 40 00 04 d0 call 40020144 <__errno>
4001ee08: b0 10 3f ff mov -1, %i0
4001ee0c: 10 80 00 0c b 4001ee3c <rtems_rfs_rtems_file_write+0x1b0>
4001ee10: fa 22 00 00 st %i5, [ %o0 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
4001ee14: 80 a6 a0 00 cmp %i2, 0
4001ee18: 32 bf ff e0 bne,a 4001ed98 <rtems_rfs_rtems_file_write+0x10c>
4001ee1c: f4 27 bf f4 st %i2, [ %fp + -12 ]
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
4001ee20: 80 a6 20 00 cmp %i0, 0
4001ee24: 06 80 00 06 bl 4001ee3c <rtems_rfs_rtems_file_write+0x1b0><== NEVER TAKEN
4001ee28: f8 1f bf f8 ldd [ %fp + -8 ], %i4
iop->offset = pos + write;
4001ee2c: 85 3e 20 1f sra %i0, 0x1f, %g2
4001ee30: b6 86 00 1d addcc %i0, %i5, %i3
4001ee34: b4 40 80 1c addx %g2, %i4, %i2
4001ee38: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001ee3c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001ee40: 7f ff ff 3d call 4001eb34 <rtems_rfs_rtems_unlock>
4001ee44: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return write;
}
4001ee48: 81 c7 e0 08 ret
4001ee4c: 81 e8 00 00 restore
400126d4 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
400126d4: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400126d8: 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);
400126dc: 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);
400126e0: 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);
400126e4: 94 07 bf d8 add %fp, -40, %o2
400126e8: 90 10 00 1d mov %i5, %o0
400126ec: 7f ff fa a0 call 4001116c <rtems_rfs_inode_open>
400126f0: 96 10 20 01 mov 1, %o3
if (rc)
400126f4: b8 92 20 00 orcc %o0, 0, %i4
400126f8: 02 80 00 07 be 40012714 <rtems_rfs_rtems_fstat+0x40> <== ALWAYS TAKEN
400126fc: c4 07 bf e4 ld [ %fp + -28 ], %g2
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
40012700: 40 00 36 91 call 40020144 <__errno> <== NOT EXECUTED
40012704: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012708: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001270c: 81 c7 e0 08 ret <== NOT EXECUTED
40012710: 81 e8 00 00 restore <== NOT EXECUTED
40012714: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
40012718: f8 08 a0 03 ldub [ %g2 + 3 ], %i4
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
4001271c: 05 3f ff ec sethi %hi(0xffffb000), %g2
40012720: 83 28 60 08 sll %g1, 8, %g1
40012724: b8 10 40 1c or %g1, %i4, %i4
40012728: 82 08 40 02 and %g1, %g2, %g1
4001272c: 05 00 00 08 sethi %hi(0x2000), %g2
40012730: 80 a0 40 02 cmp %g1, %g2
40012734: 32 80 00 0c bne,a 40012764 <rtems_rfs_rtems_fstat+0x90> <== ALWAYS TAKEN
40012738: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
4001273c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40012740: 7f ff fc c5 call 40011a54 <rtems_rfs_inode_get_block> <== NOT EXECUTED
40012744: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
40012748: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001274c: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
40012750: 7f ff fc c1 call 40011a54 <rtems_rfs_inode_get_block> <== NOT EXECUTED
40012754: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
40012758: f6 26 60 18 st %i3, [ %i1 + 0x18 ] <== NOT EXECUTED
4001275c: d0 26 60 1c st %o0, [ %i1 + 0x1c ] <== NOT EXECUTED
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
40012760: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
40012764: 91 2f 20 10 sll %i4, 0x10, %o0
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
40012768: c2 26 60 04 st %g1, [ %i1 + 4 ]
4001276c: 83 38 60 1f sra %g1, 0x1f, %g1
40012770: c2 26 40 00 st %g1, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
40012774: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_mode = rtems_rfs_rtems_mode (mode);
40012778: 91 32 20 10 srl %o0, 0x10, %o0
4001277c: 40 00 01 03 call 40012b88 <rtems_rfs_rtems_mode>
40012780: c2 26 60 08 st %g1, [ %i1 + 8 ]
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
40012784: c2 07 bf e4 ld [ %fp + -28 ], %g1
40012788: d0 26 60 0c st %o0, [ %i1 + 0xc ]
4001278c: c6 08 60 01 ldub [ %g1 + 1 ], %g3
40012790: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
40012794: 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);
40012798: 85 28 a0 08 sll %g2, 8, %g2
4001279c: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
400127a0: 87 28 a0 10 sll %g2, 0x10, %g3
400127a4: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
400127a8: 86 39 00 03 xnor %g4, %g3, %g3
400127ac: 80 a0 00 03 cmp %g0, %g3
400127b0: 86 60 20 00 subx %g0, 0, %g3
400127b4: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
400127b8: 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;
400127bc: c6 08 60 06 ldub [ %g1 + 6 ], %g3
400127c0: c4 08 60 07 ldub [ %g1 + 7 ], %g2
400127c4: 87 28 e0 08 sll %g3, 8, %g3
400127c8: 82 10 c0 02 or %g3, %g2, %g1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
400127cc: 90 07 bf d8 add %fp, -40, %o0
400127d0: 7f ff fc 99 call 40011a34 <rtems_rfs_inode_get_gid>
400127d4: c2 36 60 12 sth %g1, [ %i1 + 0x12 ]
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
400127d8: d2 07 bf e0 ld [ %fp + -32 ], %o1
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
400127dc: d0 36 60 14 sth %o0, [ %i1 + 0x14 ]
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
400127e0: 40 00 2a 07 call 4001cffc <rtems_rfs_file_get_shared>
400127e4: 90 10 00 1d mov %i5, %o0
if (shared)
400127e8: 92 92 20 00 orcc %o0, 0, %o1
400127ec: 02 80 00 17 be 40012848 <rtems_rfs_rtems_fstat+0x174>
400127f0: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
400127f4: c2 02 60 8c ld [ %o1 + 0x8c ], %g1
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
400127f8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
400127fc: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40012800: c2 02 60 90 ld [ %o1 + 0x90 ], %g1
40012804: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40012808: c2 02 60 94 ld [ %o1 + 0x94 ], %g1
4001280c: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
40012810: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
40012814: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
40012818: 03 00 00 3c sethi %hi(0xf000), %g1
4001281c: 84 08 80 01 and %g2, %g1, %g2
40012820: 03 00 00 28 sethi %hi(0xa000), %g1
40012824: 80 a0 80 01 cmp %g2, %g1
40012828: 12 80 00 04 bne 40012838 <rtems_rfs_rtems_fstat+0x164> <== ALWAYS TAKEN
4001282c: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
40012830: 10 80 00 3d b 40012924 <rtems_rfs_rtems_fstat+0x250> <== NOT EXECUTED
40012834: c2 12 60 8a lduh [ %o1 + 0x8a ], %g1 <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
40012838: 40 00 1c a9 call 40019adc <rtems_rfs_block_get_size>
4001283c: 92 02 60 84 add %o1, 0x84, %o1
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
40012840: 10 80 00 3f b 4001293c <rtems_rfs_rtems_fstat+0x268>
40012844: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
40012848: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
4001284c: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
40012850: 87 28 e0 18 sll %g3, 0x18, %g3
40012854: 85 28 a0 10 sll %g2, 0x10, %g2
40012858: 84 10 c0 02 or %g3, %g2, %g2
4001285c: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
40012860: 84 10 80 03 or %g2, %g3, %g2
40012864: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
40012868: 87 28 e0 08 sll %g3, 8, %g3
4001286c: 84 10 80 03 or %g2, %g3, %g2
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
40012870: 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);
40012874: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
40012878: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
4001287c: 87 28 e0 18 sll %g3, 0x18, %g3
40012880: 85 28 a0 10 sll %g2, 0x10, %g2
40012884: 84 10 c0 02 or %g3, %g2, %g2
40012888: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
4001288c: 84 10 80 03 or %g2, %g3, %g2
40012890: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
40012894: 87 28 e0 08 sll %g3, 8, %g3
40012898: 84 10 80 03 or %g2, %g3, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
4001289c: 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);
400128a0: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
400128a4: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
400128a8: 87 28 e0 18 sll %g3, 0x18, %g3
400128ac: 85 28 a0 10 sll %g2, 0x10, %g2
400128b0: 84 10 c0 02 or %g3, %g2, %g2
400128b4: c6 08 60 1b ldub [ %g1 + 0x1b ], %g3
400128b8: 84 10 80 03 or %g2, %g3, %g2
400128bc: c6 08 60 1a ldub [ %g1 + 0x1a ], %g3
400128c0: 87 28 e0 08 sll %g3, 8, %g3
400128c4: 84 10 80 03 or %g2, %g3, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
400128c8: 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);
400128cc: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
400128d0: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
400128d4: 87 28 e0 18 sll %g3, 0x18, %g3
400128d8: 85 28 a0 10 sll %g2, 0x10, %g2
400128dc: 84 10 c0 02 or %g3, %g2, %g2
400128e0: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
400128e4: 84 10 80 03 or %g2, %g3, %g2
400128e8: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
400128ec: 87 28 e0 08 sll %g3, 8, %g3
400128f0: 84 10 80 03 or %g2, %g3, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
400128f4: c6 06 60 0c ld [ %i1 + 0xc ], %g3
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
400128f8: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
400128fc: 05 00 00 3c sethi %hi(0xf000), %g2
40012900: 86 08 c0 02 and %g3, %g2, %g3
40012904: 05 00 00 28 sethi %hi(0xa000), %g2
40012908: 80 a0 c0 02 cmp %g3, %g2
4001290c: 12 80 00 09 bne 40012930 <rtems_rfs_rtems_fstat+0x25c>
40012910: 90 10 00 1d mov %i5, %o0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
40012914: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
40012918: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
4001291c: 85 28 a0 08 sll %g2, 8, %g2
40012920: 82 10 40 02 or %g1, %g2, %g1
40012924: c0 26 60 20 clr [ %i1 + 0x20 ]
40012928: 10 80 00 05 b 4001293c <rtems_rfs_rtems_fstat+0x268>
4001292c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
40012930: 7f ff fc 29 call 400119d4 <rtems_rfs_inode_get_size>
40012934: 92 07 bf d8 add %fp, -40, %o1
40012938: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
4001293c: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
40012940: 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);
40012944: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
40012948: 92 07 bf d8 add %fp, -40, %o1
4001294c: 7f ff fa 7a call 40011334 <rtems_rfs_inode_close>
40012950: b0 10 20 00 clr %i0
if (rc > 0)
40012954: 80 a2 20 00 cmp %o0, 0
40012958: 04 80 00 05 ble 4001296c <rtems_rfs_rtems_fstat+0x298> <== ALWAYS TAKEN
4001295c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
40012960: 40 00 35 f9 call 40020144 <__errno> <== NOT EXECUTED
40012964: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012968: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
4001296c: 81 c7 e0 08 ret
40012970: 81 e8 00 00 restore
400121cc <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
400121cc: 9d e3 bf 98 save %sp, -104, %sp
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
400121d0: 3b 10 00 cd sethi %hi(0x40033400), %i5
if (strncmp (options, "hold-bitmaps",
400121d4: 35 10 00 cd sethi %hi(0x40033400), %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
400121d8: 21 10 00 cd sethi %hi(0x40033400), %l0
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
400121dc: 23 10 00 cd sethi %hi(0x40033400), %l1
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
400121e0: b6 10 20 05 mov 5, %i3
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
400121e4: b8 10 20 00 clr %i4
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
400121e8: ba 17 63 00 or %i5, 0x300, %i5
if (strncmp (options, "hold-bitmaps",
400121ec: b4 16 a3 10 or %i2, 0x310, %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
400121f0: a0 14 23 20 or %l0, 0x320, %l0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
400121f4: 10 80 00 2f b 400122b0 <rtems_rfs_rtems_initialise+0xe4>
400121f8: a2 14 63 30 or %l1, 0x330, %l1
{
printf ("options=%s\n", options);
400121fc: 40 00 3d 2b call 400216a8 <printf> <== NOT EXECUTED
40012200: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40012204: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40012208: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001220c: 40 00 41 ec call 400229bc <strncmp> <== NOT EXECUTED
40012210: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
40012214: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012218: 12 80 00 04 bne 40012228 <rtems_rfs_rtems_initialise+0x5c><== NOT EXECUTED
4001221c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
40012220: 10 80 00 1a b 40012288 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
40012224: b8 17 20 01 or %i4, 1, %i4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
40012228: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001222c: 40 00 41 e4 call 400229bc <strncmp> <== NOT EXECUTED
40012230: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
40012234: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012238: 12 80 00 04 bne 40012248 <rtems_rfs_rtems_initialise+0x7c><== NOT EXECUTED
4001223c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
40012240: 10 80 00 12 b 40012288 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
40012244: b8 17 20 02 or %i4, 2, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40012248: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001224c: 40 00 41 dc call 400229bc <strncmp> <== NOT EXECUTED
40012250: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
40012254: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012258: 12 80 00 07 bne 40012274 <rtems_rfs_rtems_initialise+0xa8><== NOT EXECUTED
4001225c: 92 10 20 00 clr %o1 <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
40012260: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
40012264: 40 00 42 b5 call 40022d38 <strtoul> <== NOT EXECUTED
40012268: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001226c: 10 80 00 06 b 40012284 <rtems_rfs_rtems_initialise+0xb8> <== NOT EXECUTED
40012270: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
40012274: 40 00 37 b4 call 40020144 <__errno> <== NOT EXECUTED
40012278: 01 00 00 00 nop <== NOT EXECUTED
4001227c: 10 80 00 18 b 400122dc <rtems_rfs_rtems_initialise+0x110> <== NOT EXECUTED
40012280: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
options = strchr (options, ',');
40012284: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40012288: 40 00 3f 31 call 40021f4c <strchr> <== NOT EXECUTED
4001228c: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
40012290: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
40012294: 02 80 00 0a be 400122bc <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
40012298: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
4001229c: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1 <== NOT EXECUTED
400122a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400122a4: 02 80 00 06 be 400122bc <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
400122a8: 01 00 00 00 nop <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
400122ac: b2 06 60 01 inc %i1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
400122b0: 80 a6 60 00 cmp %i1, 0
400122b4: 12 bf ff d2 bne 400121fc <rtems_rfs_rtems_initialise+0x30><== NEVER TAKEN
400122b8: 92 10 00 19 mov %i1, %o1
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
400122bc: 7f ff d6 b3 call 40007d88 <malloc>
400122c0: 90 10 20 04 mov 4, %o0
if (!rtems)
400122c4: ba 92 20 00 orcc %o0, 0, %i5
400122c8: 12 80 00 08 bne 400122e8 <rtems_rfs_rtems_initialise+0x11c><== ALWAYS TAKEN
400122cc: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
400122d0: 40 00 37 9d call 40020144 <__errno> <== NOT EXECUTED
400122d4: 01 00 00 00 nop <== NOT EXECUTED
400122d8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
400122dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400122e0: 81 c7 e0 08 ret <== NOT EXECUTED
400122e4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
400122e8: 40 00 30 ad call 4001e59c <rtems_rfs_mutex_create>
400122ec: c0 27 40 00 clr [ %i5 ]
if (rc > 0)
400122f0: b4 92 20 00 orcc %o0, 0, %i2
400122f4: 14 80 00 09 bg 40012318 <rtems_rfs_rtems_initialise+0x14c><== NEVER TAKEN
400122f8: 01 00 00 00 nop
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
400122fc: 7f ff ff 96 call 40012154 <rtems_rfs_mutex_lock.isra.2>
40012300: d0 07 40 00 ld [ %i5 ], %o0
if (rc > 0)
40012304: b4 92 20 00 orcc %o0, 0, %i2
40012308: 24 80 00 0b ble,a 40012334 <rtems_rfs_rtems_initialise+0x168><== ALWAYS TAKEN
4001230c: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
{
rtems_rfs_mutex_destroy (&rtems->access);
40012310: 40 00 30 be call 4001e608 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
40012314: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free (rtems);
40012318: 7f ff d5 0b call 40007744 <free> <== NOT EXECUTED
4001231c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
40012320: 40 00 37 89 call 40020144 <__errno> <== NOT EXECUTED
40012324: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012328: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
4001232c: 81 c7 e0 08 ret <== NOT EXECUTED
40012330: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
40012334: 94 10 00 1c mov %i4, %o2
40012338: 92 10 00 1d mov %i5, %o1
4001233c: 96 10 00 1b mov %i3, %o3
40012340: 40 00 2c 11 call 4001d384 <rtems_rfs_fs_open>
40012344: 98 07 bf fc add %fp, -4, %o4
if (rc)
40012348: b8 92 20 00 orcc %o0, 0, %i4
4001234c: 02 80 00 09 be 40012370 <rtems_rfs_rtems_initialise+0x1a4><== ALWAYS TAKEN
40012350: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
40012354: 7f ff d4 fc call 40007744 <free> <== NOT EXECUTED
40012358: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
4001235c: 40 00 37 7a call 40020144 <__errno> <== NOT EXECUTED
40012360: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012364: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40012368: 81 c7 e0 08 ret <== NOT EXECUTED
4001236c: 81 e8 00 00 restore <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
40012370: 03 10 00 cd sethi %hi(0x40033400), %g1
40012374: 82 10 63 40 or %g1, 0x340, %g1 ! 40033740 <rtems_rfs_ops>
40012378: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
4001237c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
40012380: d0 26 20 08 st %o0, [ %i0 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40012384: 84 10 20 01 mov 1, %g2
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40012388: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
4001238c: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
40012390: 05 10 00 d6 sethi %hi(0x40035800), %g2
40012394: 84 10 a2 80 or %g2, 0x280, %g2 ! 40035a80 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
40012398: 40 00 22 fc call 4001af88 <rtems_rfs_buffers_release>
4001239c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
rtems_rfs_mutex_unlock (&rtems->access);
400123a0: d0 07 40 00 ld [ %i5 ], %o0
400123a4: 7f ff ff 56 call 400120fc <rtems_rfs_mutex_unlock.isra.1>
400123a8: b0 10 20 00 clr %i0
rtems_rfs_rtems_unlock (fs);
return 0;
}
400123ac: 81 c7 e0 08 ret
400123b0: 81 e8 00 00 restore
40011b78 <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)
{
40011b78: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
40011b7c: 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);
40011b80: d6 06 20 08 ld [ %i0 + 8 ], %o3
40011b84: d0 00 60 08 ld [ %g1 + 8 ], %o0
40011b88: d8 06 60 08 ld [ %i1 + 8 ], %o4
40011b8c: 92 10 00 1a mov %i2, %o1
40011b90: 94 10 00 1b mov %i3, %o2
40011b94: 9a 10 20 00 clr %o5
40011b98: 40 00 30 22 call 4001dc20 <rtems_rfs_link>
40011b9c: b0 10 20 00 clr %i0
if (rc)
40011ba0: 80 a2 20 00 cmp %o0, 0
40011ba4: 02 80 00 05 be 40011bb8 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
40011ba8: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
40011bac: 40 00 39 66 call 40020144 <__errno> <== NOT EXECUTED
40011bb0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011bb4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40011bb8: 81 c7 e0 08 ret
40011bbc: 81 e8 00 00 restore
4001eae0 <rtems_rfs_rtems_lock>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
4001eae0: 9d e3 bf a0 save %sp, -96, %sp
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
4001eae4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4001eae8: 92 10 20 00 clr %o1
4001eaec: d0 00 40 00 ld [ %g1 ], %o0
4001eaf0: 7f ff b5 74 call 4000c0c0 <rtems_semaphore_obtain>
4001eaf4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
4001eaf8: ba 92 20 00 orcc %o0, 0, %i5
4001eafc: 02 80 00 0c be 4001eb2c <rtems_rfs_rtems_lock+0x4c> <== ALWAYS TAKEN
4001eb00: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001eb04: 7f ff d0 23 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001eb08: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001eb0c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001eb10: 02 80 00 07 be 4001eb2c <rtems_rfs_rtems_lock+0x4c> <== NOT EXECUTED
4001eb14: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001eb18: 7f ff dd 64 call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001eb1c: 31 10 00 cd sethi %hi(0x40033400), %i0 <== NOT EXECUTED
4001eb20: b0 16 22 d8 or %i0, 0x2d8, %i0 ! 400336d8 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
4001eb24: 40 00 0a e1 call 400216a8 <printf> <== NOT EXECUTED
4001eb28: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
4001eb2c: 81 c7 e0 08 ret
4001eb30: 81 e8 00 00 restore
40011f08 <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)
{
40011f08: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
40011f0c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
40011f10: f0 06 20 08 ld [ %i0 + 8 ], %i0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
40011f14: 40 00 11 3c call 40016404 <geteuid>
40011f18: e0 00 60 08 ld [ %g1 + 8 ], %l0
gid = getegid ();
40011f1c: 40 00 11 36 call 400163f4 <getegid>
40011f20: a4 10 00 08 mov %o0, %l2
40011f24: a2 10 00 08 mov %o0, %l1
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
40011f28: 40 00 03 15 call 40012b7c <rtems_rfs_rtems_imode>
40011f2c: 90 10 00 1b mov %i3, %o0
40011f30: 82 07 bf d4 add %fp, -44, %g1
40011f34: 99 2a 20 10 sll %o0, 0x10, %o4
40011f38: 96 10 00 1a mov %i2, %o3
40011f3c: a5 2c a0 10 sll %l2, 0x10, %l2
40011f40: a3 2c 60 10 sll %l1, 0x10, %l1
40011f44: a5 34 a0 10 srl %l2, 0x10, %l2
40011f48: a3 34 60 10 srl %l1, 0x10, %l1
40011f4c: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
40011f50: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
40011f54: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40011f58: 90 10 00 10 mov %l0, %o0
40011f5c: 92 10 00 18 mov %i0, %o1
40011f60: 94 10 00 19 mov %i1, %o2
40011f64: 99 33 20 10 srl %o4, 0x10, %o4
40011f68: 7f ff fd c8 call 40011688 <rtems_rfs_inode_create>
40011f6c: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
40011f70: b4 92 20 00 orcc %o0, 0, %i2
40011f74: 14 80 00 09 bg 40011f98 <rtems_rfs_rtems_mknod+0x90>
40011f78: d2 07 bf d4 ld [ %fp + -44 ], %o1
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40011f7c: 90 10 00 10 mov %l0, %o0
40011f80: 94 07 bf d8 add %fp, -40, %o2
40011f84: 7f ff fc 7a call 4001116c <rtems_rfs_inode_open>
40011f88: 96 10 20 01 mov 1, %o3
if (rc > 0)
40011f8c: b4 92 20 00 orcc %o0, 0, %i2
40011f90: 04 80 00 07 ble 40011fac <rtems_rfs_rtems_mknod+0xa4> <== ALWAYS TAKEN
40011f94: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
40011f98: 40 00 38 6b call 40020144 <__errno>
40011f9c: b0 10 3f ff mov -1, %i0
40011fa0: f4 22 00 00 st %i2, [ %o0 ]
40011fa4: 81 c7 e0 08 ret
40011fa8: 81 e8 00 00 restore
}
if (S_ISDIR(mode) || S_ISREG(mode))
40011fac: 05 00 00 20 sethi %hi(0x8000), %g2
40011fb0: 82 0e c0 01 and %i3, %g1, %g1
40011fb4: 80 a0 40 02 cmp %g1, %g2
40011fb8: 02 80 00 1c be 40012028 <rtems_rfs_rtems_mknod+0x120>
40011fbc: 05 00 00 10 sethi %hi(0x4000), %g2
40011fc0: 80 a0 40 02 cmp %g1, %g2
40011fc4: 02 80 00 19 be 40012028 <rtems_rfs_rtems_mknod+0x120> <== ALWAYS TAKEN
40011fc8: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
40011fcc: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
40011fd0: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
40011fd4: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
40011fd8: 12 80 00 0b bne 40012004 <rtems_rfs_rtems_mknod+0xfc> <== NOT EXECUTED
40011fdc: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
40011fe0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40011fe4: 7f ff fe ac call 40011a94 <rtems_rfs_inode_set_block> <== NOT EXECUTED
40011fe8: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
40011fec: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
40011ff0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40011ff4: 7f ff fe a8 call 40011a94 <rtems_rfs_inode_set_block> <== NOT EXECUTED
40011ff8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
40011ffc: 10 80 00 0c b 4001202c <rtems_rfs_rtems_mknod+0x124> <== NOT EXECUTED
40012000: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
40012004: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012008: 7f ff fc cb call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001200c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
40012010: 40 00 38 4d call 40020144 <__errno> <== NOT EXECUTED
40012014: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012018: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001201c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012020: 81 c7 e0 08 ret <== NOT EXECUTED
40012024: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
40012028: 90 10 00 10 mov %l0, %o0
4001202c: 92 07 bf d8 add %fp, -40, %o1
40012030: 7f ff fc c1 call 40011334 <rtems_rfs_inode_close>
40012034: b0 10 20 00 clr %i0
if (rc > 0)
40012038: 80 a2 20 00 cmp %o0, 0
4001203c: 04 80 00 05 ble 40012050 <rtems_rfs_rtems_mknod+0x148> <== ALWAYS TAKEN
40012040: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
40012044: 40 00 38 40 call 40020144 <__errno> <== NOT EXECUTED
40012048: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001204c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012050: 81 c7 e0 08 ret
40012054: 81 e8 00 00 restore
40012438 <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)
{
40012438: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4001243c: 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);
40012440: 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);
40012444: fa 00 60 08 ld [ %g1 + 8 ], %i5
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40012448: 94 07 bf d8 add %fp, -40, %o2
4001244c: 90 10 00 1d mov %i5, %o0
40012450: 7f ff fb 47 call 4001116c <rtems_rfs_inode_open>
40012454: 96 10 20 01 mov 1, %o3
if (rc > 0)
40012458: b8 92 20 00 orcc %o0, 0, %i4
4001245c: 04 80 00 07 ble 40012478 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
40012460: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
40012464: 40 00 37 38 call 40020144 <__errno> <== NOT EXECUTED
40012468: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001246c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40012470: 81 c7 e0 08 ret <== NOT EXECUTED
40012474: 81 e8 00 00 restore <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
40012478: 7f ff ff cf call 400123b4 <rtems_rfs_rtems_node_type_by_inode>
4001247c: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
40012480: 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);
40012484: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
40012488: 7f ff fb ab call 40011334 <rtems_rfs_inode_close>
4001248c: 90 10 00 1d mov %i5, %o0
if (rc > 0)
40012490: ba 92 20 00 orcc %o0, 0, %i5
40012494: 04 80 00 05 ble 400124a8 <rtems_rfs_rtems_node_type+0x70> <== ALWAYS TAKEN
40012498: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
4001249c: 40 00 37 2a call 40020144 <__errno> <== NOT EXECUTED
400124a0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400124a4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
400124a8: 81 c7 e0 08 ret
400124ac: 81 e8 00 00 restore
40011c90 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
40011c90: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40011c94: 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);
40011c98: d2 06 20 08 ld [ %i0 + 8 ], %o1
40011c9c: d0 00 60 08 ld [ %g1 + 8 ], %o0
40011ca0: 94 10 00 19 mov %i1, %o2
40011ca4: 96 10 00 1a mov %i2, %o3
40011ca8: 40 00 31 cc call 4001e3d8 <rtems_rfs_symlink_read>
40011cac: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
40011cb0: 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)
40011cb4: 80 a2 20 00 cmp %o0, 0
40011cb8: 02 80 00 05 be 40011ccc <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
40011cbc: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
40011cc0: 40 00 39 21 call 40020144 <__errno> <== NOT EXECUTED
40011cc4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011cc8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
40011ccc: 81 c7 e0 08 ret
40011cd0: 81 e8 00 00 restore
40011bc0 <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)
{
40011bc0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
40011bc4: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
40011bc8: e0 06 20 08 ld [ %i0 + 8 ], %l0 <== NOT EXECUTED
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
40011bcc: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
40011bd0: f0 06 60 08 ld [ %i1 + 8 ], %i0 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
40011bd4: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
40011bd8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
40011bdc: f2 06 60 0c ld [ %i1 + 0xc ], %i1 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
40011be0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011be4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40011be8: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40011bec: 40 00 30 0d call 4001dc20 <rtems_rfs_link> <== NOT EXECUTED
40011bf0: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
40011bf4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40011bf8: 02 80 00 07 be 40011c14 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
40011bfc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
40011c00: 40 00 39 51 call 40020144 <__errno> <== NOT EXECUTED
40011c04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011c08: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40011c0c: 81 c7 e0 08 ret <== NOT EXECUTED
40011c10: 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,
40011c14: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40011c18: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40011c1c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
40011c20: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
40011c24: 40 00 30 68 call 4001ddc4 <rtems_rfs_unlink> <== NOT EXECUTED
40011c28: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
40011c2c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40011c30: 02 80 00 05 be 40011c44 <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
40011c34: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
40011c38: 40 00 39 43 call 40020144 <__errno> <== NOT EXECUTED
40011c3c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011c40: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40011c44: 81 c7 e0 08 ret <== NOT EXECUTED
40011c48: 81 e8 00 00 restore <== NOT EXECUTED
40012ac4 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
40012ac4: 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);
40012ac8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
40012acc: 05 00 00 10 sethi %hi(0x4000), %g2
40012ad0: d2 08 60 02 ldub [ %g1 + 2 ], %o1
40012ad4: c2 08 60 03 ldub [ %g1 + 3 ], %g1
40012ad8: 93 2a 60 08 sll %o1, 8, %o1
40012adc: 92 12 40 01 or %o1, %g1, %o1
40012ae0: 03 00 00 3c sethi %hi(0xf000), %g1
40012ae4: 82 0a 40 01 and %o1, %g1, %g1
40012ae8: 80 a0 40 02 cmp %g1, %g2
40012aec: 12 80 00 05 bne 40012b00 <rtems_rfs_rtems_set_handlers+0x3c>
40012af0: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
40012af4: 03 10 00 d6 sethi %hi(0x40035800), %g1
40012af8: 10 80 00 0a b 40012b20 <rtems_rfs_rtems_set_handlers+0x5c>
40012afc: 82 10 62 80 or %g1, 0x280, %g1 ! 40035a80 <rtems_rfs_rtems_dir_handlers>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
40012b00: 07 00 00 2c sethi %hi(0xb000), %g3
40012b04: 05 00 00 08 sethi %hi(0x2000), %g2
40012b08: 86 0a 40 03 and %o1, %g3, %g3
40012b0c: 80 a0 c0 02 cmp %g3, %g2
40012b10: 12 80 00 07 bne 40012b2c <rtems_rfs_rtems_set_handlers+0x68><== ALWAYS TAKEN
40012b14: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
40012b18: 03 10 00 d6 sethi %hi(0x40035800), %g1 <== NOT EXECUTED
40012b1c: 82 10 62 54 or %g1, 0x254, %g1 ! 40035a54 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
40012b20: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40012b24: 10 80 00 13 b 40012b70 <rtems_rfs_rtems_set_handlers+0xac>
40012b28: b0 10 20 01 mov 1, %i0
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
40012b2c: 80 a0 40 02 cmp %g1, %g2
40012b30: 12 80 00 05 bne 40012b44 <rtems_rfs_rtems_set_handlers+0x80>
40012b34: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
40012b38: 03 10 00 cd sethi %hi(0x40033400), %g1
40012b3c: 10 bf ff f9 b 40012b20 <rtems_rfs_rtems_set_handlers+0x5c>
40012b40: 82 10 63 94 or %g1, 0x394, %g1 ! 40033794 <rtems_rfs_rtems_link_handlers>
else if (RTEMS_RFS_S_ISREG (mode))
40012b44: 80 a0 40 02 cmp %g1, %g2
40012b48: 32 80 00 05 bne,a 40012b5c <rtems_rfs_rtems_set_handlers+0x98><== NEVER TAKEN
40012b4c: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
40012b50: 03 10 00 d6 sethi %hi(0x40035800), %g1
40012b54: 10 bf ff f3 b 40012b20 <rtems_rfs_rtems_set_handlers+0x5c>
40012b58: 82 10 62 ac or %g1, 0x2ac, %g1 ! 40035aac <rtems_rfs_rtems_file_handlers>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
40012b5c: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40012b60: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
40012b64: 90 12 23 c8 or %o0, 0x3c8, %o0 <== NOT EXECUTED
40012b68: 40 00 3a d0 call 400216a8 <printf> <== NOT EXECUTED
40012b6c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return false;
}
return true;
}
40012b70: b0 0e 20 01 and %i0, 1, %i0
40012b74: 81 c7 e0 08 ret
40012b78: 81 e8 00 00 restore
40011ae4 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
40011ae4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40011ae8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40011aec: 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);
40011af0: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40011af4: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
40011af8: 7f ff fd 3b call 40010fe4 <rtems_rfs_group_usage> <== NOT EXECUTED
40011afc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
40011b00: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40011b04: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40011b08: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
40011b0c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40011b10: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40011b14: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40011b18: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40011b1c: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
40011b20: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40011b24: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40011b28: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
40011b2c: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40011b30: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
40011b34: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
40011b38: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40011b3c: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
40011b40: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
40011b44: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40011b48: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
40011b4c: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
40011b50: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
40011b54: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_SIZE+0x27c92001><== NOT EXECUTED
40011b58: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
40011b5c: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
40011b60: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
40011b64: c2 26 60 30 st %g1, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
40011b68: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
40011b6c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED
return 0;
}
40011b70: 81 c7 e0 08 ret <== NOT EXECUTED
40011b74: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40011cd4 <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)
{
40011cd4: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
40011cd8: 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),
40011cdc: 90 10 00 1b mov %i3, %o0
40011ce0: 40 00 43 05 call 400228f4 <strlen>
40011ce4: 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);
40011ce8: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
40011cec: 40 00 11 c6 call 40016404 <geteuid>
40011cf0: ba 10 00 08 mov %o0, %i5
40011cf4: 40 00 11 c0 call 400163f4 <getegid>
40011cf8: a0 10 00 08 mov %o0, %l0
40011cfc: 91 2a 20 10 sll %o0, 0x10, %o0
40011d00: 91 32 20 10 srl %o0, 0x10, %o0
40011d04: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
40011d08: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
40011d0c: 98 10 00 1d mov %i5, %o4
40011d10: 9b 2c 20 10 sll %l0, 0x10, %o5
40011d14: 90 10 00 1c mov %i4, %o0
40011d18: 92 10 00 19 mov %i1, %o1
40011d1c: 94 10 00 1a mov %i2, %o2
40011d20: 96 10 00 1b mov %i3, %o3
40011d24: 9b 33 60 10 srl %o5, 0x10, %o5
40011d28: 40 00 31 13 call 4001e174 <rtems_rfs_symlink>
40011d2c: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
40011d30: 80 a2 20 00 cmp %o0, 0
40011d34: 02 80 00 05 be 40011d48 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
40011d38: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
40011d3c: 40 00 39 02 call 40020144 <__errno> <== NOT EXECUTED
40011d40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011d44: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40011d48: 81 c7 e0 08 ret
40011d4c: 81 e8 00 00 restore
4001e6f8 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
4001e6f8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
4001e6fc: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rtems_rfs_buffers_release (fs);
4001e700: 7f ff f2 22 call 4001af88 <rtems_rfs_buffers_release>
4001e704: 90 10 00 18 mov %i0, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4001e708: 7f ff b6 b7 call 4000c1e4 <rtems_semaphore_release>
4001e70c: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4001e710: ba 92 20 00 orcc %o0, 0, %i5
4001e714: 02 80 00 0c be 4001e744 <rtems_rfs_rtems_unlock+0x4c> <== ALWAYS TAKEN
4001e718: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001e71c: 7f ff d1 1d call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e720: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001e724: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e728: 02 80 00 07 be 4001e744 <rtems_rfs_rtems_unlock+0x4c> <== NOT EXECUTED
4001e72c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
4001e730: 7f ff de 5e call 400160a8 <rtems_status_text> <== NOT EXECUTED
4001e734: 31 10 00 cd sethi %hi(0x40033400), %i0 <== NOT EXECUTED
4001e738: b0 16 22 b0 or %i0, 0x2b0, %i0 ! 400336b0 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
4001e73c: 40 00 0b db call 400216a8 <printf> <== NOT EXECUTED
4001e740: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
4001e744: 81 c7 e0 08 ret
4001e748: 81 e8 00 00 restore
40011d50 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
40011d50: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40011d54: 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);
40011d58: 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);
40011d5c: 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);
40011d60: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40011d64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011d68: 7f ff fd 01 call 4001116c <rtems_rfs_inode_open> <== NOT EXECUTED
40011d6c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40011d70: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40011d74: 02 80 00 07 be 40011d90 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
40011d78: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
40011d7c: 40 00 38 f2 call 40020144 <__errno> <== NOT EXECUTED
40011d80: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011d84: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40011d88: 81 c7 e0 08 ret <== NOT EXECUTED
40011d8c: 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);
40011d90: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
40011d94: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
40011d98: 85 36 60 10 srl %i1, 0x10, %g2 <== NOT EXECUTED
40011d9c: c4 28 60 11 stb %g2, [ %g1 + 0x11 ] <== NOT EXECUTED
40011da0: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
40011da4: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011da8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
40011dac: c4 2f bf e8 stb %g2, [ %fp + -24 ] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
40011db0: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
40011db4: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
40011db8: 85 36 a0 10 srl %i2, 0x10, %g2 <== NOT EXECUTED
40011dbc: c4 28 60 15 stb %g2, [ %g1 + 0x15 ] <== NOT EXECUTED
40011dc0: 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);
40011dc4: 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);
40011dc8: 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);
40011dcc: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
40011dd0: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
40011dd4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40011dd8: 7f ff fd 57 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
40011ddc: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
40011de0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40011de4: 02 80 00 05 be 40011df8 <rtems_rfs_rtems_utime+0xa8> <== NOT EXECUTED
40011de8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
40011dec: 40 00 38 d6 call 40020144 <__errno> <== NOT EXECUTED
40011df0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011df4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40011df8: 81 c7 e0 08 ret <== NOT EXECUTED
40011dfc: 81 e8 00 00 restore <== NOT EXECUTED
4001a82c <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
4001a82c: 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))
4001a830: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
4001a834: fa 06 20 08 ld [ %i0 + 8 ], %i5
4001a838: 7f ff e0 d6 call 40012b90 <rtems_rfs_trace>
4001a83c: 92 10 20 80 mov 0x80, %o1
4001a840: 80 8a 20 ff btst 0xff, %o0
4001a844: 22 80 00 29 be,a 4001a8e8 <rtems_rfs_scan_chain+0xbc> <== ALWAYS TAKEN
4001a848: 39 10 00 d1 sethi %hi(0x40034400), %i4
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
4001a84c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001a850: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001a854: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001a858: 40 00 1b 94 call 400216a8 <printf> <== NOT EXECUTED
4001a85c: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001a860: 10 80 00 22 b 4001a8e8 <rtems_rfs_scan_chain+0xbc> <== NOT EXECUTED
4001a864: 39 10 00 d1 sethi %hi(0x40034400), %i4 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001a868: 7f ff e0 ca call 40012b90 <rtems_rfs_trace>
4001a86c: 01 00 00 00 nop
4001a870: 80 8a 20 ff btst 0xff, %o0
4001a874: 22 80 00 06 be,a 4001a88c <rtems_rfs_scan_chain+0x60> <== ALWAYS TAKEN
4001a878: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001a87c: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001a880: 40 00 1b 8a call 400216a8 <printf> <== NOT EXECUTED
4001a884: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001a888: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
4001a88c: 80 a0 40 1a cmp %g1, %i2
4001a890: 32 80 00 17 bne,a 4001a8ec <rtems_rfs_scan_chain+0xc0>
4001a894: fa 07 60 04 ld [ %i5 + 4 ], %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001a898: 90 10 20 00 clr %o0
4001a89c: 7f ff e0 bd call 40012b90 <rtems_rfs_trace>
4001a8a0: 92 10 20 80 mov 0x80, %o1
4001a8a4: 80 8a 20 ff btst 0xff, %o0
4001a8a8: 22 80 00 07 be,a 4001a8c4 <rtems_rfs_scan_chain+0x98> <== ALWAYS TAKEN
4001a8ac: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
4001a8b0: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001a8b4: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001a8b8: 40 00 1b 7c call 400216a8 <printf> <== NOT EXECUTED
4001a8bc: 90 12 21 18 or %o0, 0x118, %o0 ! 40034518 <CSWTCH.2+0x168><== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
4001a8c0: 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 );
4001a8c4: 90 10 00 1d mov %i5, %o0
4001a8c8: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
4001a8cc: b0 10 00 1d mov %i5, %i0
4001a8d0: 7f ff f4 1b call 4001793c <_Chain_Extract>
4001a8d4: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4001a8d8: c0 27 60 04 clr [ %i5 + 4 ]
4001a8dc: c0 27 40 00 clr [ %i5 ]
4001a8e0: 81 c7 e0 08 ret
4001a8e4: 81 e8 00 00 restore
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001a8e8: b8 17 21 10 or %i4, 0x110, %i4
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001a8ec: 90 10 20 00 clr %o0
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
4001a8f0: 80 a7 40 18 cmp %i5, %i0
4001a8f4: 12 bf ff dd bne 4001a868 <rtems_rfs_scan_chain+0x3c>
4001a8f8: 92 10 20 80 mov 0x80, %o1
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001a8fc: 7f ff e0 a5 call 40012b90 <rtems_rfs_trace>
4001a900: b0 10 20 00 clr %i0
4001a904: 80 8a 20 ff btst 0xff, %o0
4001a908: 02 bf ff f6 be 4001a8e0 <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
4001a90c: 11 10 00 d1 sethi %hi(0x40034400), %o0
printf (": not found\n");
4001a910: 40 00 1b fe call 40021908 <puts> <== NOT EXECUTED
4001a914: 90 12 21 30 or %o0, 0x130, %o0 ! 40034530 <CSWTCH.2+0x180><== NOT EXECUTED
return NULL;
}
4001a918: 81 c7 e0 08 ret <== NOT EXECUTED
4001a91c: 81 e8 00 00 restore <== NOT EXECUTED
40018f7c <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,
40018f7c: 9d e3 bf 88 save %sp, -120, %sp
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
40018f80: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
40018f84: 90 10 00 18 mov %i0, %o0
40018f88: 7f ff ff e8 call 40018f28 <rtems_rfs_bitmap_load_map>
40018f8c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
40018f90: 80 a2 20 00 cmp %o0, 0
40018f94: 14 80 00 98 bg 400191f4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NEVER TAKEN
40018f98: a1 2e e0 0b sll %i3, 0xb, %l0
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
40018f9c: fa 06 40 00 ld [ %i1 ], %i5
end_bit = test_bit + (window * direction);
if (end_bit < 0)
40018fa0: a0 84 00 1d addcc %l0, %i5, %l0
40018fa4: 2c 80 00 08 bneg,a 40018fc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
40018fa8: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
40018fac: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40018fb0: 80 a4 00 01 cmp %l0, %g1
40018fb4: 3a 80 00 04 bcc,a 40018fc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
40018fb8: 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];
40018fbc: 10 80 00 03 b 40018fc8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
40018fc0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
40018fc4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
map_bits = &map[map_index];
40018fc8: e2 07 bf fc ld [ %fp + -4 ], %l1
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
40018fcc: b9 3f 60 05 sra %i5, 5, %i4
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
40018fd0: a7 3f 60 0a sra %i5, 0xa, %l3
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
40018fd4: a4 0f 60 1f and %i5, 0x1f, %l2
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
40018fd8: a7 2c e0 02 sll %l3, 2, %l3
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
40018fdc: 82 0f 20 1f and %i4, 0x1f, %g1
search_bits = &control->search_bits[search_index];
40018fe0: a6 00 80 13 add %g2, %l3, %l3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
40018fe4: ad 2e e0 02 sll %i3, 2, %l6
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
40018fe8: 85 2f 20 02 sll %i4, 2, %g2
40018fec: a8 10 20 1f mov 0x1f, %l4
40018ff0: 80 a6 e0 00 cmp %i3, 0
40018ff4: 04 80 00 03 ble 40019000 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x84>
40018ff8: a2 04 40 02 add %l1, %g2, %l1
40018ffc: a8 10 20 00 clr %l4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
40019000: ab 3e e0 1f sra %i3, 0x1f, %l5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
40019004: 89 2e e0 05 sll %i3, 5, %g4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
40019008: aa 25 40 1b sub %l5, %i3, %l5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001900c: ae 10 20 01 mov 1, %l7
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
40019010: 87 36 e0 1f srl %i3, 0x1f, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
40019014: ab 35 60 1f srl %l5, 0x1f, %l5
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
40019018: 9a 10 20 20 mov 0x20, %o5
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4001901c: d8 04 c0 00 ld [ %l3 ], %o4
40019020: 80 a3 20 00 cmp %o4, 0
40019024: 02 80 00 44 be 40019134 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8>
40019028: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001902c: 96 07 00 1b add %i4, %i3, %o3
40019030: 84 10 20 00 clr %g2
40019034: 97 2a e0 05 sll %o3, 5, %o3
40019038: 82 20 40 1c sub %g1, %i4, %g1
4001903c: 10 80 00 38 b 4001911c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
40019040: 96 02 c0 14 add %o3, %l4, %o3
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
40019044: 80 8b c0 0c btst %o7, %o4
40019048: 12 80 00 1a bne 400190b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x134>
4001904c: a4 24 80 1d sub %l2, %i5, %l2
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
40019050: 10 80 00 1d b 400190c4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
40019054: ba 00 80 0b add %g2, %o3, %i5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
40019058: 95 2d c0 0a sll %l7, %o2, %o2
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
4001905c: 80 8a 80 09 btst %o2, %o1
40019060: 02 80 00 12 be 400190a8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
40019064: 80 a7 40 10 cmp %i5, %l0
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
40019068: 94 2a 40 0a andn %o1, %o2, %o2
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
4001906c: 80 a2 a0 00 cmp %o2, 0
40019070: 12 80 00 05 bne 40019084 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108>
40019074: d4 24 40 00 st %o2, [ %l1 ]
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
40019078: c2 04 c0 00 ld [ %l3 ], %g1
4001907c: 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,
40019080: de 24 c0 00 st %o7, [ %l3 ]
1 << search_offset);
control->free--;
40019084: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
40019088: c4 06 00 00 ld [ %i0 ], %g2
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
4001908c: 82 00 7f ff add %g1, -1, %g1
40019090: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
*bit = test_bit;
40019094: fa 26 40 00 st %i5, [ %i1 ]
*found = true;
40019098: 82 10 20 01 mov 1, %g1
4001909c: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
400190a0: 10 80 00 54 b 400191f0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
400190a4: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
}
if (test_bit == end_bit)
400190a8: 02 80 00 06 be 400190c0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
400190ac: ba 07 40 1b add %i5, %i3, %i5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
400190b0: 94 04 80 1d add %l2, %i5, %o2
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
400190b4: 80 a2 a0 1f cmp %o2, 0x1f
400190b8: 28 bf ff e8 bleu,a 40019058 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xdc><== ALWAYS TAKEN
400190bc: d2 04 40 00 ld [ %l1 ], %o1
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
400190c0: ba 00 80 0b add %g2, %o3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
400190c4: a2 04 40 16 add %l1, %l6, %l1
map_index += direction;
400190c8: b8 07 00 1b add %i4, %i3, %i4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
400190cc: 80 a7 40 10 cmp %i5, %l0
400190d0: 04 80 00 03 ble 400190dc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x160>
400190d4: 9e 10 20 01 mov 1, %o7
400190d8: 9e 10 20 00 clr %o7
400190dc: 80 8b e0 ff btst 0xff, %o7
400190e0: 02 80 00 05 be 400190f4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178>
400190e4: 84 00 80 04 add %g2, %g4, %g2
400190e8: 80 a0 e0 00 cmp %g3, 0
400190ec: 32 80 00 29 bne,a 40019190 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x214>
400190f0: a4 10 00 14 mov %l4, %l2
|| ((direction > 0) && (test_bit >= end_bit)))
400190f4: 80 a7 40 10 cmp %i5, %l0
400190f8: 16 80 00 03 bge 40019104 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188>
400190fc: 9e 10 20 01 mov 1, %o7
40019100: 9e 10 20 00 clr %o7
40019104: 80 8b e0 ff btst 0xff, %o7
40019108: 02 80 00 05 be 4001911c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
4001910c: a4 10 00 14 mov %l4, %l2
40019110: 80 a5 60 00 cmp %l5, 0
40019114: 32 80 00 20 bne,a 40019194 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
40019118: a6 04 c0 16 add %l3, %l6, %l3
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001911c: 9e 00 40 1c add %g1, %i4, %o7
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
40019120: 80 a3 e0 1f cmp %o7, 0x1f
40019124: 28 bf ff c8 bleu,a 40019044 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc8>
40019128: 9f 2d c0 0f sll %l7, %o7, %o7
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
4001912c: 10 80 00 1a b 40019194 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
40019130: a6 04 c0 16 add %l3, %l6, %l3
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
40019134: 04 80 00 07 ble 40019150 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4>
40019138: ba 0f 7f e0 and %i5, -32, %i5
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001913c: 92 23 40 01 sub %o5, %g1, %o1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
40019140: a4 10 20 00 clr %l2
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
40019144: 83 2a 60 05 sll %o1, 5, %g1
40019148: 10 80 00 07 b 40019164 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8>
4001914c: ba 00 40 1d add %g1, %i5, %i5
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
40019150: 92 00 60 01 add %g1, 1, %o1
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
40019154: a4 10 20 1f mov 0x1f, %l2
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
40019158: 83 28 60 05 sll %g1, 5, %g1
4001915c: 82 38 00 01 xnor %g0, %g1, %g1
40019160: ba 00 40 1d add %g1, %i5, %i5
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
40019164: c6 27 bf f4 st %g3, [ %fp + -12 ]
40019168: c8 27 bf f0 st %g4, [ %fp + -16 ]
4001916c: da 27 bf ec st %o5, [ %fp + -20 ]
40019170: 7f ff a5 09 call 40002594 <.umul>
40019174: 90 10 00 1b mov %i3, %o0
40019178: c6 07 bf f4 ld [ %fp + -12 ], %g3
4001917c: 83 2a 20 02 sll %o0, 2, %g1
map_index += direction * bits_skipped;
40019180: b8 07 00 08 add %i4, %o0, %i4
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
40019184: a2 04 40 01 add %l1, %g1, %l1
40019188: c8 07 bf f0 ld [ %fp + -16 ], %g4
4001918c: da 07 bf ec ld [ %fp + -20 ], %o5
map_index += direction * bits_skipped;
}
search_bits += direction;
40019190: a6 04 c0 16 add %l3, %l6, %l3
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
40019194: 80 a6 e0 00 cmp %i3, 0
40019198: 04 80 00 03 ble 400191a4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x228>
4001919c: 82 10 20 1f mov 0x1f, %g1
400191a0: 82 10 20 00 clr %g1
}
while (((direction < 0) && (test_bit >= end_bit))
400191a4: 80 a7 40 10 cmp %i5, %l0
400191a8: 16 80 00 03 bge 400191b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x238>
400191ac: 84 10 20 01 mov 1, %g2
400191b0: 84 10 20 00 clr %g2
|| ((direction > 0) && (test_bit <= end_bit)));
400191b4: 80 88 a0 ff btst 0xff, %g2
400191b8: 02 80 00 06 be 400191d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x254>
400191bc: 80 a7 40 10 cmp %i5, %l0
400191c0: 80 a0 e0 00 cmp %g3, 0
400191c4: 32 bf ff 97 bne,a 40019020 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
400191c8: d8 04 c0 00 ld [ %l3 ], %o4
400191cc: 80 a7 40 10 cmp %i5, %l0
400191d0: 04 80 00 03 ble 400191dc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x260>
400191d4: 84 10 20 01 mov 1, %g2
400191d8: 84 10 20 00 clr %g2
400191dc: 80 88 a0 ff btst 0xff, %g2
400191e0: 02 80 00 04 be 400191f0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
400191e4: 80 a5 60 00 cmp %l5, 0
400191e8: 32 bf ff 8e bne,a 40019020 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
400191ec: d8 04 c0 00 ld [ %l3 ], %o4
return 0;
400191f0: 90 10 20 00 clr %o0
}
400191f4: 81 c7 e0 08 ret
400191f8: 91 e8 00 08 restore %g0, %o0, %o0
4001e174 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001e174: 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))
4001e178: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001e17c: e2 07 a0 60 ld [ %fp + 0x60 ], %l1
4001e180: 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))
4001e184: 7f ff d2 83 call 40012b90 <rtems_rfs_trace>
4001e188: 92 10 20 00 clr %o1
4001e18c: 80 8a 20 ff btst 0xff, %o0
4001e190: 12 80 00 07 bne 4001e1ac <rtems_rfs_symlink+0x38> <== NEVER TAKEN
4001e194: 11 10 00 d6 sethi %hi(0x40035800), %o0
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
4001e198: c2 06 20 08 ld [ %i0 + 8 ], %g1
4001e19c: 80 a7 00 01 cmp %i4, %g1
4001e1a0: 1a 80 00 8b bcc 4001e3cc <rtems_rfs_symlink+0x258> <== NEVER TAKEN
4001e1a4: b4 10 20 5b mov 0x5b, %i2
4001e1a8: 30 80 00 19 b,a 4001e20c <rtems_rfs_symlink+0x98>
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
4001e1ac: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001e1b0: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED
4001e1b4: 40 00 0d 3d call 400216a8 <printf> <== NOT EXECUTED
4001e1b8: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
4001e1bc: 10 80 00 05 b 4001e1d0 <rtems_rfs_symlink+0x5c> <== NOT EXECUTED
4001e1c0: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
4001e1c4: 40 00 0d a3 call 40021850 <putchar> <== NOT EXECUTED
4001e1c8: 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++)
4001e1cc: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
4001e1d0: 26 bf ff fd bl,a 4001e1c4 <rtems_rfs_symlink+0x50> <== NOT EXECUTED
4001e1d4: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
4001e1d8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001e1dc: b4 10 20 00 clr %i2 <== NOT EXECUTED
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
4001e1e0: 40 00 0d 32 call 400216a8 <printf> <== NOT EXECUTED
4001e1e4: 90 12 21 d8 or %o0, 0x1d8, %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001e1e8: 10 80 00 05 b 4001e1fc <rtems_rfs_symlink+0x88> <== NOT EXECUTED
4001e1ec: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
printf ("%c", link[c]);
4001e1f0: 40 00 0d 98 call 40021850 <putchar> <== NOT EXECUTED
4001e1f4: 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++)
4001e1f8: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
4001e1fc: 26 bf ff fd bl,a 4001e1f0 <rtems_rfs_symlink+0x7c> <== NOT EXECUTED
4001e200: d0 4e c0 1a ldsb [ %i3 + %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
4001e204: 10 bf ff e6 b 4001e19c <rtems_rfs_symlink+0x28> <== NOT EXECUTED
4001e208: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4001e20c: 40 00 11 ba call 400228f4 <strlen>
4001e210: 90 10 00 19 mov %i1, %o0
4001e214: 82 07 bf 74 add %fp, -140, %g1
4001e218: 96 10 00 08 mov %o0, %o3
4001e21c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4001e220: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
4001e224: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4001e228: 90 10 00 18 mov %i0, %o0
4001e22c: 92 10 00 11 mov %l1, %o1
4001e230: 94 10 00 19 mov %i1, %o2
4001e234: 19 00 00 28 sethi %hi(0xa000), %o4
4001e238: 9a 10 20 01 mov 1, %o5
4001e23c: 7f ff cd 13 call 40011688 <rtems_rfs_inode_create>
4001e240: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
4001e244: b4 92 20 00 orcc %o0, 0, %i2
4001e248: 34 80 00 62 bg,a 4001e3d0 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
4001e24c: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001e250: d2 07 bf 74 ld [ %fp + -140 ], %o1
4001e254: 90 10 00 18 mov %i0, %o0
4001e258: 94 07 bf 88 add %fp, -120, %o2
4001e25c: 7f ff cb c4 call 4001116c <rtems_rfs_inode_open>
4001e260: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001e264: b4 92 20 00 orcc %o0, 0, %i2
4001e268: 34 80 00 5a bg,a 4001e3d0 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
4001e26c: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
/*
* If the link length is less than the length of data union in the inode
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
4001e270: 80 a7 20 13 cmp %i4, 0x13
4001e274: 38 80 00 15 bgu,a 4001e2c8 <rtems_rfs_symlink+0x154> <== NEVER TAKEN
4001e278: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
4001e27c: d0 07 bf 94 ld [ %fp + -108 ], %o0
4001e280: 92 10 20 00 clr %o1
4001e284: 94 10 20 14 mov 0x14, %o2
4001e288: 40 00 0c 8a call 400214b0 <memset>
4001e28c: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
4001e290: d0 07 bf 94 ld [ %fp + -108 ], %o0
4001e294: 92 10 00 1b mov %i3, %o1
4001e298: 90 02 20 1c add %o0, 0x1c, %o0
4001e29c: 40 00 0b f6 call 40021274 <memcpy>
4001e2a0: 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);
4001e2a4: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001e2a8: c0 28 60 0c clrb [ %g1 + 0xc ]
4001e2ac: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001e2b0: c0 28 60 0d clrb [ %g1 + 0xd ]
4001e2b4: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001e2b8: c0 28 60 0e clrb [ %g1 + 0xe ]
4001e2bc: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001e2c0: 10 80 00 38 b 4001e3a0 <rtems_rfs_symlink+0x22c>
4001e2c4: c0 28 60 0f clrb [ %g1 + 0xf ]
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
4001e2c8: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001e2cc: 7f ff ee 1c call 40019b3c <rtems_rfs_block_map_open> <== NOT EXECUTED
4001e2d0: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
4001e2d4: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
4001e2d8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001e2dc: 14 80 00 2d bg 4001e390 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
4001e2e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001e2e4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001e2e8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001e2ec: 7f ff ef 6f call 4001a0a8 <rtems_rfs_block_map_grow> <== NOT EXECUTED
4001e2f0: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
4001e2f4: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001e2f8: 14 80 00 0c bg 4001e328 <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
4001e2fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4001e300: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001e304: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001e308: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e30c: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001e310: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001e314: 7f ff f1 f7 call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001e318: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
4001e31c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001e320: 04 80 00 06 ble 4001e338 <rtems_rfs_symlink+0x1c4> <== NOT EXECUTED
4001e324: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
4001e328: 7f ff ee 66 call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e32c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
4001e330: 10 80 00 18 b 4001e390 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
4001e334: 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);
4001e338: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
4001e33c: 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);
4001e340: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
4001e344: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
4001e348: 40 00 0c 5a call 400214b0 <memset> <== NOT EXECUTED
4001e34c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
4001e350: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001e354: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001e358: 40 00 0b c7 call 40021274 <memcpy> <== NOT EXECUTED
4001e35c: 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);
4001e360: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001e364: 7f ff f1 6f call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e368: 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);
4001e36c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e370: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001e374: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e378: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001e37c: 7f ff ee 51 call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e380: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
4001e384: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001e388: 04 80 00 06 ble 4001e3a0 <rtems_rfs_symlink+0x22c> <== NOT EXECUTED
4001e38c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4001e390: 7f ff cb e9 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001e394: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
4001e398: 81 c7 e0 08 ret <== NOT EXECUTED
4001e39c: 91 e8 00 1a restore %g0, %i2, %o0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001e3a0: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001e3a4: 85 37 20 08 srl %i4, 8, %g2
4001e3a8: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
4001e3ac: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
4001e3b0: 90 10 00 18 mov %i0, %o0
4001e3b4: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001e3b8: 82 10 20 01 mov 1, %g1
4001e3bc: 92 07 bf 88 add %fp, -120, %o1
4001e3c0: 7f ff cb dd call 40011334 <rtems_rfs_inode_close>
4001e3c4: c2 2f bf 98 stb %g1, [ %fp + -104 ]
4001e3c8: b4 10 00 08 mov %o0, %i2
return rc;
}
4001e3cc: b0 10 00 1a mov %i2, %i0
4001e3d0: 81 c7 e0 08 ret
4001e3d4: 81 e8 00 00 restore
4001e3d8 <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)
{
4001e3d8: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
4001e3dc: 90 10 20 04 mov 4, %o0
4001e3e0: 92 10 20 00 clr %o1
4001e3e4: 7f ff d1 eb call 40012b90 <rtems_rfs_trace>
4001e3e8: ba 10 00 18 mov %i0, %i5
4001e3ec: 80 8a 20 ff btst 0xff, %o0
4001e3f0: 22 80 00 07 be,a 4001e40c <rtems_rfs_symlink_read+0x34> <== ALWAYS TAKEN
4001e3f4: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
4001e3f8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e3fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001e400: 40 00 0c aa call 400216a8 <printf> <== NOT EXECUTED
4001e404: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001e408: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e40c: 92 10 00 19 mov %i1, %o1
4001e410: 94 07 bf 88 add %fp, -120, %o2
4001e414: 7f ff cb 56 call 4001116c <rtems_rfs_inode_open>
4001e418: 96 10 20 01 mov 1, %o3
if (rc)
4001e41c: b0 92 20 00 orcc %o0, 0, %i0
4001e420: 12 80 00 0d bne 4001e454 <rtems_rfs_symlink_read+0x7c> <== NEVER TAKEN
4001e424: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
4001e428: 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);
4001e42c: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
4001e430: 85 28 a0 08 sll %g2, 8, %g2
4001e434: 84 08 80 01 and %g2, %g1, %g2
4001e438: 03 00 00 28 sethi %hi(0xa000), %g1
4001e43c: 80 a0 80 01 cmp %g2, %g1
4001e440: 02 80 00 07 be 4001e45c <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
4001e444: 90 10 00 1d mov %i5, %o0
{
rtems_rfs_inode_close (fs, &inode);
4001e448: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001e44c: 7f ff cb ba call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001e450: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
4001e454: 81 c7 e0 08 ret <== NOT EXECUTED
4001e458: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001e45c: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4001e460: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
4001e464: 95 2a a0 08 sll %o2, 8, %o2
4001e468: 94 10 40 0a or %g1, %o2, %o2
4001e46c: 80 a2 80 1b cmp %o2, %i3
4001e470: 38 80 00 02 bgu,a 4001e478 <rtems_rfs_symlink_read+0xa0>
4001e474: 94 10 00 1b mov %i3, %o2
4001e478: 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);
4001e47c: c2 0a 60 0d ldub [ %o1 + 0xd ], %g1
4001e480: c4 0a 60 0c ldub [ %o1 + 0xc ], %g2
4001e484: 83 28 60 10 sll %g1, 0x10, %g1
4001e488: 85 28 a0 18 sll %g2, 0x18, %g2
4001e48c: 84 10 80 01 or %g2, %g1, %g2
4001e490: c2 0a 60 0f ldub [ %o1 + 0xf ], %g1
4001e494: 84 10 80 01 or %g2, %g1, %g2
4001e498: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
4001e49c: 83 28 60 08 sll %g1, 8, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001e4a0: 80 90 80 01 orcc %g2, %g1, %g0
4001e4a4: 32 80 00 07 bne,a 4001e4c0 <rtems_rfs_symlink_read+0xe8> <== NEVER TAKEN
4001e4a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
4001e4ac: 90 10 00 1a mov %i2, %o0
4001e4b0: 40 00 0b 71 call 40021274 <memcpy>
4001e4b4: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
4001e4b8: 10 80 00 34 b 4001e588 <rtems_rfs_symlink_read+0x1b0>
4001e4bc: 90 10 00 1d mov %i5, %o0
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
4001e4c0: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001e4c4: 7f ff ed 9e call 40019b3c <rtems_rfs_block_map_open> <== NOT EXECUTED
4001e4c8: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
4001e4cc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if (rc > 0)
4001e4d0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001e4d4: 14 80 00 29 bg 4001e578 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
4001e4d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001e4dc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001e4e0: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001e4e4: 96 10 20 00 clr %o3 <== NOT EXECUTED
4001e4e8: 7f ff ee c6 call 4001a000 <rtems_rfs_block_map_seek> <== NOT EXECUTED
4001e4ec: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
4001e4f0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001e4f4: 14 80 00 0c bg 4001e524 <rtems_rfs_symlink_read+0x14c> <== NOT EXECUTED
4001e4f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4001e4fc: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001e500: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001e504: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e508: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001e50c: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001e510: 7f ff f1 78 call 4001aaf0 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001e514: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
4001e518: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001e51c: 04 80 00 06 ble 4001e534 <rtems_rfs_symlink_read+0x15c> <== NOT EXECUTED
4001e520: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
4001e524: 7f ff ed e7 call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e528: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
4001e52c: 10 80 00 13 b 4001e578 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
4001e530: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
4001e534: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
4001e538: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4001e53c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4001e540: 40 00 0b 4d call 40021274 <memcpy> <== NOT EXECUTED
4001e544: 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);
4001e548: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001e54c: 7f ff f0 f5 call 4001a920 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e550: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
4001e554: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e558: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001e55c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e560: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001e564: 7f ff ed d7 call 40019cc0 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e568: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
4001e56c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001e570: 04 80 00 06 ble 4001e588 <rtems_rfs_symlink_read+0x1b0> <== NOT EXECUTED
4001e574: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4001e578: 7f ff cb 6f call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001e57c: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001e580: 81 c7 e0 08 ret <== NOT EXECUTED
4001e584: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
4001e588: 7f ff cb 6b call 40011334 <rtems_rfs_inode_close>
4001e58c: 92 07 bf 88 add %fp, -120, %o1
4001e590: b0 10 00 08 mov %o0, %i0
return rc;
}
4001e594: 81 c7 e0 08 ret
4001e598: 81 e8 00 00 restore
40012bd0 <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;
40012bd0: 03 10 01 1c sethi %hi(0x40047000), %g1 <== NOT EXECUTED
40012bd4: c4 18 61 b8 ldd [ %g1 + 0x1b8 ], %g2 ! 400471b8 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
40012bd8: 90 28 80 08 andn %g2, %o0, %o0 <== NOT EXECUTED
40012bdc: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
40012be0: d0 38 61 b8 std %o0, [ %g1 + 0x1b8 ] <== NOT EXECUTED
return state;
}
40012be4: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
40012be8: 81 c3 e0 08 retl <== NOT EXECUTED
40012bec: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40012bb0 <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;
40012bb0: 03 10 01 1c sethi %hi(0x40047000), %g1 <== NOT EXECUTED
40012bb4: c4 18 61 b8 ldd [ %g1 + 0x1b8 ], %g2 ! 400471b8 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
40012bb8: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
40012bbc: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
40012bc0: d0 38 61 b8 std %o0, [ %g1 + 0x1b8 ] <== NOT EXECUTED
return state;
}
40012bc4: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
40012bc8: 81 c3 e0 08 retl <== NOT EXECUTED
40012bcc: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40012bf0 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
40012bf0: 9d e3 be f8 save %sp, -264, %sp <== NOT EXECUTED
const char* table[] =
40012bf4: 13 10 00 ce sethi %hi(0x40033800), %o1 <== NOT EXECUTED
40012bf8: 90 07 bf 64 add %fp, -156, %o0 <== NOT EXECUTED
40012bfc: 92 12 62 cc or %o1, 0x2cc, %o1 <== NOT EXECUTED
40012c00: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40012c04: 27 10 00 c6 sethi %hi(0x40031800), %l3 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40012c08: 29 10 00 ce sethi %hi(0x40033800), %l4 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
40012c0c: 40 00 39 9a call 40021274 <memcpy> <== NOT EXECUTED
40012c10: 2b 10 00 ce sethi %hi(0x40033800), %l5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40012c14: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
40012c18: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
40012c1c: b4 10 20 00 clr %i2 <== NOT EXECUTED
40012c20: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
40012c24: b8 10 20 00 clr %i4 <== NOT EXECUTED
40012c28: ba 10 20 00 clr %i5 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40012c2c: a6 14 e3 00 or %l3, 0x300, %l3 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40012c30: a8 15 20 60 or %l4, 0x60, %l4 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
40012c34: aa 15 60 68 or %l5, 0x68, %l5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40012c38: 10 80 00 68 b 40012dd8 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
40012c3c: 25 10 01 1c sethi %hi(0x40047000), %l2 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
40012c40: ec 06 40 01 ld [ %i1 + %g1 ], %l6 <== NOT EXECUTED
40012c44: c2 4d 80 00 ldsb [ %l6 ], %g1 <== NOT EXECUTED
40012c48: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40012c4c: 12 80 00 25 bne 40012ce0 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
40012c50: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
switch (argv[arg][1])
40012c54: c2 4d a0 01 ldsb [ %l6 + 1 ], %g1 <== NOT EXECUTED
40012c58: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
40012c5c: 02 80 00 06 be 40012c74 <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
40012c60: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
40012c64: 32 80 00 1a bne,a 40012ccc <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
40012c68: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
40012c6c: 10 80 00 08 b 40012c8c <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
40012c70: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
40012c74: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40012c78: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40012c7c: 40 00 3a 8b call 400216a8 <printf> <== NOT EXECUTED
40012c80: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 400337f0 <rtems_rfs_rtems_eval_config+0x30><== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
40012c84: 81 c7 e0 08 ret <== NOT EXECUTED
40012c88: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
40012c8c: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
40012c90: 39 10 00 ce sethi %hi(0x40033800), %i4 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
40012c94: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
40012c98: 40 00 3a 84 call 400216a8 <printf> <== NOT EXECUTED
40012c9c: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
40012ca0: b8 17 20 40 or %i4, 0x40, %i4 <== NOT EXECUTED
40012ca4: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
40012ca8: d2 00 40 1d ld [ %g1 + %i5 ], %o1 <== NOT EXECUTED
40012cac: 40 00 3a 7f call 400216a8 <printf> <== NOT EXECUTED
40012cb0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40012cb4: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
40012cb8: 80 a7 60 9c cmp %i5, 0x9c <== NOT EXECUTED
40012cbc: 12 bf ff fb bne 40012ca8 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
40012cc0: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
40012cc4: 81 c7 e0 08 ret <== NOT EXECUTED
40012cc8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
default:
printf ("error: unknown option\n");
return 1;
40012ccc: 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");
40012cd0: 40 00 3b 0e call 40021908 <puts> <== NOT EXECUTED
40012cd4: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
40012cd8: 81 c7 e0 08 ret <== NOT EXECUTED
40012cdc: 81 e8 00 00 restore <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40012ce0: 40 00 3c f9 call 400220c4 <strcmp> <== NOT EXECUTED
40012ce4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40012ce8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012cec: 22 80 00 02 be,a 40012cf4 <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
40012cf0: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40012cf4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40012cf8: 40 00 3c f3 call 400220c4 <strcmp> <== NOT EXECUTED
40012cfc: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40012d00: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012d04: 22 80 00 2e be,a 40012dbc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40012d08: a2 10 20 00 clr %l1 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
40012d0c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40012d10: 40 00 3c ed call 400220c4 <strcmp> <== NOT EXECUTED
40012d14: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
40012d18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012d1c: 12 80 00 09 bne 40012d40 <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
40012d20: 94 10 20 00 clr %o2 <== NOT EXECUTED
{
if (set)
40012d24: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
40012d28: 22 80 00 23 be,a 40012db4 <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
40012d2c: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
40012d30: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
40012d34: b8 17 23 ff or %i4, 0x3ff, %i4 ! ffffffff <LEON_REG+0x7fffffff><== NOT EXECUTED
40012d38: 10 80 00 21 b 40012dbc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40012d3c: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
40012d40: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
40012d44: 84 07 bf 64 add %fp, -156, %g2 <== NOT EXECUTED
40012d48: d2 00 80 01 ld [ %g2 + %g1 ], %o1 <== NOT EXECUTED
40012d4c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40012d50: 40 00 3c dd call 400220c4 <strcmp> <== NOT EXECUTED
40012d54: d4 27 bf 5c st %o2, [ %fp + -164 ] <== NOT EXECUTED
40012d58: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012d5c: 12 80 00 10 bne 40012d9c <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
40012d60: d4 07 bf 5c ld [ %fp + -164 ], %o2 <== NOT EXECUTED
{
if (set)
set_value = 1ULL << t;
40012d64: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
40012d68: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
40012d6c: 02 80 00 07 be 40012d88 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
40012d70: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
set_value = 1ULL << t;
40012d74: 40 00 6c e3 call 4002e100 <__ashldi3> <== NOT EXECUTED
40012d78: 01 00 00 00 nop <== NOT EXECUTED
40012d7c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
40012d80: 10 80 00 0f b 40012dbc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40012d84: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
else
clear_value = 1ULL << t;
40012d88: 40 00 6c de call 4002e100 <__ashldi3> <== NOT EXECUTED
40012d8c: 01 00 00 00 nop <== NOT EXECUTED
40012d90: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
40012d94: 10 80 00 0a b 40012dbc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40012d98: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
40012d9c: 94 02 a0 01 inc %o2 <== NOT EXECUTED
40012da0: 80 a2 a0 27 cmp %o2, 0x27 <== NOT EXECUTED
40012da4: 12 bf ff e8 bne 40012d44 <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
40012da8: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
40012dac: 10 80 00 05 b 40012dc0 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
40012db0: c4 1c a1 b8 ldd [ %l2 + 0x1b8 ], %g2 <== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
40012db4: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
40012db8: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
40012dbc: c4 1c a1 b8 ldd [ %l2 + 0x1b8 ], %g2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40012dc0: a0 04 20 01 inc %l0 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
40012dc4: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
40012dc8: 86 17 40 03 or %i5, %g3, %g3 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
40012dcc: 84 28 80 1a andn %g2, %i2, %g2 <== NOT EXECUTED
40012dd0: 86 28 c0 1b andn %g3, %i3, %g3 <== NOT EXECUTED
40012dd4: c4 3c a1 b8 std %g2, [ %l2 + 0x1b8 ] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40012dd8: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED
40012ddc: 06 bf ff 99 bl 40012c40 <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
40012de0: 83 2c 20 02 sll %l0, 2, %g1 <== NOT EXECUTED
40012de4: 30 bf ff b8 b,a 40012cc4 <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
40012de8: 40 01 3c cc call 40062118 <__end+0x1a008> <== NOT EXECUTED
40012dec: 40 01 3c 6c call 40061f9c <__end+0x19e8c> <== NOT EXECUTED
40012df0: 40 01 3c 80 call 40061ff0 <__end+0x19ee0> <== NOT EXECUTED
40012df4: 40 01 3c 80 call 40061ff4 <__end+0x19ee4> <== NOT EXECUTED
40012df8: 40 01 3c 80 call 40061ff8 <__end+0x19ee8> <== NOT EXECUTED
40012dfc: 40 01 3c 80 call 40061ffc <__end+0x19eec> <== NOT EXECUTED
40012e00: 40 01 3c 64 call 40061f90 <__end+0x19e80> <== NOT EXECUTED
40012e04: 40 01 3c 8c call 40062034 <__end+0x19f24> <== NOT EXECUTED
40012e08: 40 01 3c 8c call 40062038 <__end+0x19f28> <== NOT EXECUTED
40012e0c: 40 01 3c 8c call 4006203c <__end+0x19f2c> <== NOT EXECUTED
40012e10: 40 01 3c ac call 400620c0 <__end+0x19fb0> <== NOT EXECUTED
40012e14: 40 01 3b b8 call 40061cf4 <__end+0x19be4> <== NOT EXECUTED
40012e18: 40 01 3b b8 call 40061cf8 <__end+0x19be8> <== NOT EXECUTED
40012e1c: 40 01 3b d8 call 40061d7c <__end+0x19c6c> <== NOT EXECUTED
40012e20: 40 01 3b d8 call 40061d80 <__end+0x19c70> <== NOT EXECUTED
40012e24: 40 01 3b d8 call 40061d84 <__end+0x19c74> <== NOT EXECUTED
40012e28: 40 01 3b d8 call 40061d88 <__end+0x19c78> <== NOT EXECUTED
40012e2c: 40 01 3b 84 call 40061c3c <__end+0x19b2c> <== NOT EXECUTED
40012e30: 40 01 3b e4 call 40061dc0 <__end+0x19cb0> <== NOT EXECUTED
40012e34: 40 01 3b e4 call 40061dc4 <__end+0x19cb4> <== NOT EXECUTED
40012e38: 40 01 3b e4 call 40061dc8 <__end+0x19cb8> <== NOT EXECUTED
40012e3c: 40 01 52 58 call 4006779c <__end+0x1f68c> <== NOT EXECUTED
40012e40: 40 01 52 58 call 400677a0 <__end+0x1f690> <== NOT EXECUTED
40012e44: 40 01 52 18 call 400676a4 <__end+0x1f594> <== NOT EXECUTED
40012e48: 40 01 52 48 call 40067768 <__end+0x1f658> <== NOT EXECUTED
40012e4c: 40 01 52 48 call 4006776c <__end+0x1f65c> <== NOT EXECUTED
40012e50: 40 01 52 48 call 40067770 <__end+0x1f660> <== NOT EXECUTED
40012e54: 40 01 52 58 call 400677b4 <__end+0x1f6a4> <== NOT EXECUTED
40012e58: 40 01 52 10 call 40067698 <__end+0x1f588> <== NOT EXECUTED
40012e5c: 40 01 52 08 call 4006767c <__end+0x1f56c> <== NOT EXECUTED
40012e60: 40 01 52 40 call 40067760 <__end+0x1f650> <== NOT EXECUTED
40012e64: 40 01 52 58 call 400677c4 <__end+0x1f6b4> <== NOT EXECUTED
4001ddc4 <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)
{
4001ddc4: 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))
4001ddc8: 90 10 20 00 clr %o0
4001ddcc: 7f ff d3 71 call 40012b90 <rtems_rfs_trace>
4001ddd0: 13 00 80 00 sethi %hi(0x2000000), %o1
4001ddd4: 80 8a 20 ff btst 0xff, %o0
4001ddd8: 02 80 00 08 be 4001ddf8 <rtems_rfs_unlink+0x34> <== ALWAYS TAKEN
4001dddc: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
4001dde0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001dde4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001dde8: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED
4001ddec: 40 00 0e 2f call 400216a8 <printf> <== NOT EXECUTED
4001ddf0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001ddf4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ddf8: 92 10 00 1a mov %i2, %o1
4001ddfc: 94 07 bf d8 add %fp, -40, %o2
4001de00: 7f ff cc db call 4001116c <rtems_rfs_inode_open>
4001de04: 96 10 20 01 mov 1, %o3
if (rc)
4001de08: ba 92 20 00 orcc %o0, 0, %i5
4001de0c: 12 80 00 d7 bne 4001e168 <rtems_rfs_unlink+0x3a4> <== NEVER TAKEN
4001de10: 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));
4001de14: 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);
4001de18: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001de1c: 83 28 60 08 sll %g1, 8, %g1
4001de20: 82 08 40 02 and %g1, %g2, %g1
4001de24: 05 00 00 10 sethi %hi(0x4000), %g2
4001de28: 82 18 40 02 xor %g1, %g2, %g1
4001de2c: 80 a0 00 01 cmp %g0, %g1
4001de30: a0 60 3f ff subx %g0, -1, %l0
if (dir)
4001de34: 80 8c 20 ff btst 0xff, %l0
4001de38: 02 80 00 26 be 4001ded0 <rtems_rfs_unlink+0x10c>
4001de3c: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
4001de40: 22 80 00 06 be,a 4001de58 <rtems_rfs_unlink+0x94> <== NEVER TAKEN
4001de44: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001de48: 80 a7 20 01 cmp %i4, 1
4001de4c: 12 80 00 22 bne 4001ded4 <rtems_rfs_unlink+0x110> <== NEVER TAKEN
4001de50: 90 10 00 18 mov %i0, %o0
4001de54: 30 80 00 0f b,a 4001de90 <rtems_rfs_unlink+0xcc>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001de58: 7f ff d3 4e call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001de5c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001de60: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001de64: 22 80 00 06 be,a 4001de7c <rtems_rfs_unlink+0xb8> <== NOT EXECUTED
4001de68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
4001de6c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001de70: 40 00 0e a6 call 40021908 <puts> <== NOT EXECUTED
4001de74: 90 12 20 10 or %o0, 0x10, %o0 ! 40035810 <CSWTCH.2+0x1460><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001de78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001de7c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001de80: 7f ff cd 2d call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001de84: 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;
}
4001de88: 81 c7 e0 08 ret <== NOT EXECUTED
4001de8c: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
4001de90: 7f ff f8 dc call 4001c200 <rtems_rfs_dir_empty>
4001de94: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001de98: ba 92 20 00 orcc %o0, 0, %i5
4001de9c: 04 80 00 0d ble 4001ded0 <rtems_rfs_unlink+0x10c>
4001dea0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001dea4: 7f ff d3 3b call 40012b90 <rtems_rfs_trace>
4001dea8: 13 00 80 00 sethi %hi(0x2000000), %o1
4001deac: 80 8a 20 ff btst 0xff, %o0
4001deb0: 22 80 00 97 be,a 4001e10c <rtems_rfs_unlink+0x348> <== ALWAYS TAKEN
4001deb4: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4001deb8: 40 00 12 68 call 40022858 <strerror> <== NOT EXECUTED
4001debc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001dec0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001dec4: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001dec8: 10 80 00 8e b 4001e100 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
4001decc: 90 12 20 30 or %o0, 0x30, %o0 ! 40035830 <CSWTCH.2+0x1480><== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001ded0: 90 10 00 18 mov %i0, %o0
4001ded4: 92 10 00 19 mov %i1, %o1
4001ded8: 94 07 bf b0 add %fp, -80, %o2
4001dedc: 7f ff cc a4 call 4001116c <rtems_rfs_inode_open>
4001dee0: 96 10 20 01 mov 1, %o3
if (rc)
4001dee4: ba 92 20 00 orcc %o0, 0, %i5
4001dee8: 02 80 00 0e be 4001df20 <rtems_rfs_unlink+0x15c> <== ALWAYS TAKEN
4001deec: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001def0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001def4: 7f ff d3 27 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001def8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001defc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001df00: 22 80 00 83 be,a 4001e10c <rtems_rfs_unlink+0x348> <== NOT EXECUTED
4001df04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
4001df08: 40 00 12 54 call 40022858 <strerror> <== NOT EXECUTED
4001df0c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001df10: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001df14: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001df18: 10 80 00 7a b 4001e100 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
4001df1c: 90 12 20 50 or %o0, 0x50, %o0 ! 40035850 <CSWTCH.2+0x14a0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
4001df20: 92 07 bf b0 add %fp, -80, %o1
4001df24: 94 10 00 1a mov %i2, %o2
4001df28: 7f ff f6 d4 call 4001ba78 <rtems_rfs_dir_del_entry>
4001df2c: 96 10 00 1b mov %i3, %o3
if (rc > 0)
4001df30: ba 92 20 00 orcc %o0, 0, %i5
4001df34: 04 80 00 0e ble 4001df6c <rtems_rfs_unlink+0x1a8> <== ALWAYS TAKEN
4001df38: 01 00 00 00 nop
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001df3c: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
4001df40: 7f ff d3 14 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001df44: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001df48: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001df4c: 22 80 00 59 be,a 4001e0b0 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
4001df50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
4001df54: 40 00 12 41 call 40022858 <strerror> <== NOT EXECUTED
4001df58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001df5c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001df60: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001df64: 10 80 00 50 b 4001e0a4 <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
4001df68: 90 12 20 80 or %o0, 0x80, %o0 ! 40035880 <CSWTCH.2+0x14d0><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
4001df6c: 7f ff ff 1e call 4001dbe4 <rtems_rfs_inode_get_links>
4001df70: 90 07 bf d8 add %fp, -40, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001df74: 13 00 80 00 sethi %hi(0x2000000), %o1
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
4001df78: ba 10 00 08 mov %o0, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001df7c: 7f ff d3 05 call 40012b90 <rtems_rfs_trace>
4001df80: 90 10 20 00 clr %o0
4001df84: 80 8a 20 ff btst 0xff, %o0
4001df88: 02 80 00 09 be 4001dfac <rtems_rfs_unlink+0x1e8> <== ALWAYS TAKEN
4001df8c: 83 2f 60 10 sll %i5, 0x10, %g1
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001df90: 95 2f 60 10 sll %i5, 0x10, %o2 <== NOT EXECUTED
4001df94: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001df98: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001df9c: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
4001dfa0: 40 00 0d c2 call 400216a8 <printf> <== NOT EXECUTED
4001dfa4: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
if (links > 1)
4001dfa8: 83 2f 60 10 sll %i5, 0x10, %g1 <== NOT EXECUTED
4001dfac: 83 30 60 10 srl %g1, 0x10, %g1
4001dfb0: 80 a0 60 01 cmp %g1, 1
4001dfb4: 08 80 00 0a bleu 4001dfdc <rtems_rfs_unlink+0x218>
4001dfb8: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
4001dfbc: 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);
4001dfc0: 85 37 60 08 srl %i5, 8, %g2
4001dfc4: c4 28 40 00 stb %g2, [ %g1 ]
4001dfc8: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001dfcc: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001dfd0: 82 10 20 01 mov 1, %g1
4001dfd4: 10 80 00 23 b 4001e060 <rtems_rfs_unlink+0x29c>
4001dfd8: c2 2f bf e8 stb %g1, [ %fp + -24 ]
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
4001dfdc: 90 10 00 18 mov %i0, %o0
4001dfe0: 7f ff cc f8 call 400113c0 <rtems_rfs_inode_delete>
4001dfe4: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001dfe8: ba 92 20 00 orcc %o0, 0, %i5
4001dfec: 04 80 00 0d ble 4001e020 <rtems_rfs_unlink+0x25c> <== ALWAYS TAKEN
4001dff0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001dff4: 7f ff d2 e7 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001dff8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001dffc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e000: 22 80 00 2c be,a 4001e0b0 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
4001e004: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
4001e008: 40 00 12 14 call 40022858 <strerror> <== NOT EXECUTED
4001e00c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e010: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e014: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e018: 10 80 00 23 b 4001e0a4 <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
4001e01c: 90 12 20 d8 or %o0, 0xd8, %o0 ! 400358d8 <CSWTCH.2+0x1528><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
4001e020: 80 8c 20 ff btst 0xff, %l0
4001e024: 02 80 00 10 be 4001e064 <rtems_rfs_unlink+0x2a0>
4001e028: 90 07 bf b0 add %fp, -80, %o0
{
links = rtems_rfs_inode_get_links (&parent_inode);
4001e02c: 7f ff fe ee call 4001dbe4 <rtems_rfs_inode_get_links>
4001e030: 90 07 bf b0 add %fp, -80, %o0
if (links > 1)
4001e034: 80 a2 20 01 cmp %o0, 1
4001e038: 08 80 00 03 bleu 4001e044 <rtems_rfs_unlink+0x280>
4001e03c: 82 10 00 08 mov %o0, %g1
links--;
4001e040: 82 02 3f ff add %o0, -1, %g1
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
4001e044: c4 07 bf bc ld [ %fp + -68 ], %g2
4001e048: 87 30 60 08 srl %g1, 8, %g3
4001e04c: c6 28 80 00 stb %g3, [ %g2 ]
4001e050: c4 07 bf bc ld [ %fp + -68 ], %g2
4001e054: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001e058: 82 10 20 01 mov 1, %g1
4001e05c: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001e060: 90 07 bf b0 add %fp, -80, %o0
4001e064: 92 10 20 01 mov 1, %o1
4001e068: 7f ff cd 0b call 40011494 <rtems_rfs_inode_time_stamp_now>
4001e06c: 94 10 20 01 mov 1, %o2
if (rc > 0)
4001e070: ba 92 20 00 orcc %o0, 0, %i5
4001e074: 04 80 00 13 ble 4001e0c0 <rtems_rfs_unlink+0x2fc> <== ALWAYS TAKEN
4001e078: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001e07c: 7f ff d2 c5 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e080: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001e084: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e088: 22 80 00 0a be,a 4001e0b0 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
4001e08c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
4001e090: 40 00 11 f2 call 40022858 <strerror> <== NOT EXECUTED
4001e094: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e098: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e09c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e0a0: 90 12 21 08 or %o0, 0x108, %o0 ! 40035908 <CSWTCH.2+0x1558><== NOT EXECUTED
4001e0a4: 40 00 0d 81 call 400216a8 <printf> <== NOT EXECUTED
4001e0a8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
4001e0ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e0b0: 7f ff cc a1 call 40011334 <rtems_rfs_inode_close> <== NOT EXECUTED
4001e0b4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
4001e0b8: 10 80 00 15 b 4001e10c <rtems_rfs_unlink+0x348> <== NOT EXECUTED
4001e0bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001e0c0: 90 10 00 18 mov %i0, %o0
4001e0c4: 7f ff cc 9c call 40011334 <rtems_rfs_inode_close>
4001e0c8: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
4001e0cc: ba 92 20 00 orcc %o0, 0, %i5
4001e0d0: 04 80 00 13 ble 4001e11c <rtems_rfs_unlink+0x358> <== ALWAYS TAKEN
4001e0d4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001e0d8: 7f ff d2 ae call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e0dc: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001e0e0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e0e4: 02 80 00 0a be 4001e10c <rtems_rfs_unlink+0x348> <== NOT EXECUTED
4001e0e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
4001e0ec: 40 00 11 db call 40022858 <strerror> <== NOT EXECUTED
4001e0f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e0f4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e0f8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e0fc: 90 12 21 40 or %o0, 0x140, %o0 ! 40035940 <CSWTCH.2+0x1590><== NOT EXECUTED
4001e100: 40 00 0d 6a call 400216a8 <printf> <== NOT EXECUTED
4001e104: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
4001e108: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e10c: 7f ff cc 8a call 40011334 <rtems_rfs_inode_close>
4001e110: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
4001e114: 81 c7 e0 08 ret
4001e118: 91 e8 00 1d restore %g0, %i5, %o0
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
4001e11c: 90 10 00 18 mov %i0, %o0
4001e120: 7f ff cc 85 call 40011334 <rtems_rfs_inode_close>
4001e124: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001e128: ba 92 20 00 orcc %o0, 0, %i5
4001e12c: 04 80 00 10 ble 4001e16c <rtems_rfs_unlink+0x3a8> <== ALWAYS TAKEN
4001e130: b0 10 00 1d mov %i5, %i0
4001e134: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e138: 7f ff d2 96 call 40012b90 <rtems_rfs_trace> <== NOT EXECUTED
4001e13c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001e140: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e144: 22 80 00 0a be,a 4001e16c <rtems_rfs_unlink+0x3a8> <== NOT EXECUTED
4001e148: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
4001e14c: 40 00 11 c3 call 40022858 <strerror> <== NOT EXECUTED
4001e150: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e154: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001e158: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e15c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001e160: 40 00 0d 52 call 400216a8 <printf> <== NOT EXECUTED
4001e164: 90 12 21 78 or %o0, 0x178, %o0 ! 40035978 <CSWTCH.2+0x15c8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
4001e168: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001e16c: 81 c7 e0 08 ret
4001e170: 81 e8 00 00 restore
400200a4 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
400200a4: 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));
400200a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400200ac: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
400200b0: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
400200b4: 40 00 66 39 call 40039998 <memset> <== NOT EXECUTED
400200b8: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
int
rtems_shell_rfs_format (int argc, char* argv[])
{
rtems_rfs_format_config config;
const char* driver = NULL;
400200bc: b8 10 20 00 clr %i4 <== NOT EXECUTED
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
400200c0: 10 80 00 5b b 4002022c <rtems_shell_rfs_format+0x188> <== NOT EXECUTED
400200c4: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
400200c8: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
400200cc: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
400200d0: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
400200d4: 12 80 00 4e bne 4002020c <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
400200d8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
400200dc: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
400200e0: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
400200e4: 22 80 00 2e be,a 4002019c <rtems_shell_rfs_format+0xf8> <== NOT EXECUTED
400200e8: ba 07 60 01 inc %i5 <== NOT EXECUTED
400200ec: 14 80 00 09 bg 40020110 <rtems_shell_rfs_format+0x6c> <== NOT EXECUTED
400200f0: 80 a0 60 73 cmp %g1, 0x73 <== NOT EXECUTED
400200f4: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED
400200f8: 02 80 00 35 be 400201cc <rtems_shell_rfs_format+0x128> <== NOT EXECUTED
400200fc: 80 a0 60 62 cmp %g1, 0x62 <== NOT EXECUTED
40020100: 12 80 00 41 bne 40020204 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
40020104: 11 10 01 5b sethi %hi(0x40056c00), %o0 <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
40020108: 10 80 00 19 b 4002016c <rtems_shell_rfs_format+0xc8> <== NOT EXECUTED
4002010c: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
40020110: 02 80 00 0a be 40020138 <rtems_shell_rfs_format+0x94> <== NOT EXECUTED
40020114: 80 a0 60 76 cmp %g1, 0x76 <== NOT EXECUTED
40020118: 02 80 00 06 be 40020130 <rtems_shell_rfs_format+0x8c> <== NOT EXECUTED
4002011c: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
40020120: 12 80 00 39 bne 40020204 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
40020124: 11 10 01 5b sethi %hi(0x40056c00), %o0 <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
40020128: 10 80 00 2b b 400201d4 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED
4002012c: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
break;
40020130: 10 80 00 3e b 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40020134: f6 2f bf fd stb %i3, [ %fp + -3 ] <== NOT EXECUTED
case 's':
arg++;
40020138: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
4002013c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
40020140: 06 80 00 05 bl 40020154 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
40020144: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
40020148: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
4002014c: 10 80 00 40 b 4002024c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
40020150: 90 12 22 38 or %o0, 0x238, %o0 ! 40058e38 <rtems_rtc_shell_usage+0x17a0><== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
40020154: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40020158: 92 10 20 00 clr %o1 <== NOT EXECUTED
4002015c: 40 00 7a 7b call 4003eb48 <strtoul> <== NOT EXECUTED
40020160: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
40020164: 10 80 00 31 b 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40020168: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
4002016c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
40020170: 06 80 00 05 bl 40020184 <rtems_shell_rfs_format+0xe0> <== NOT EXECUTED
40020174: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
40020178: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
4002017c: 10 80 00 34 b 4002024c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
40020180: 90 12 22 60 or %o0, 0x260, %o0 ! 40058e60 <rtems_rtc_shell_usage+0x17c8><== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
40020184: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40020188: 92 10 20 00 clr %o1 <== NOT EXECUTED
4002018c: 40 00 7a 6f call 4003eb48 <strtoul> <== NOT EXECUTED
40020190: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
40020194: 10 80 00 25 b 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40020198: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
4002019c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
400201a0: 06 80 00 05 bl 400201b4 <rtems_shell_rfs_format+0x110> <== NOT EXECUTED
400201a4: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
400201a8: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
400201ac: 10 80 00 28 b 4002024c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
400201b0: 90 12 22 90 or %o0, 0x290, %o0 ! 40058e90 <rtems_rtc_shell_usage+0x17f8><== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
400201b4: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400201b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400201bc: 40 00 7a 63 call 4003eb48 <strtoul> <== NOT EXECUTED
400201c0: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400201c4: 10 80 00 19 b 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
400201c8: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
400201cc: 10 80 00 17 b 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
400201d0: f6 2f bf fc stb %i3, [ %fp + -4 ] <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
400201d4: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
400201d8: 06 80 00 05 bl 400201ec <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
400201dc: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
400201e0: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
400201e4: 10 80 00 1a b 4002024c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
400201e8: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 40058ec0 <rtems_rtc_shell_usage+0x1828><== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
400201ec: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400201f0: 92 10 20 00 clr %o1 <== NOT EXECUTED
400201f4: 40 00 7a 55 call 4003eb48 <strtoul> <== NOT EXECUTED
400201f8: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400201fc: 10 80 00 0b b 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40020200: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
40020204: 10 80 00 06 b 4002021c <rtems_shell_rfs_format+0x178> <== NOT EXECUTED
40020208: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
4002020c: 22 80 00 07 be,a 40020228 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40020210: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
40020214: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
40020218: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 40058ef8 <rtems_rtc_shell_usage+0x1860><== NOT EXECUTED
4002021c: 40 00 6a 50 call 4003ab5c <printf> <== NOT EXECUTED
40020220: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40020224: 30 80 00 1c b,a 40020294 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
40020228: ba 07 60 01 inc %i5 <== NOT EXECUTED
4002022c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
40020230: 06 bf ff a6 bl 400200c8 <rtems_shell_rfs_format+0x24> <== NOT EXECUTED
40020234: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
40020238: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4002023c: 12 80 00 07 bne 40020258 <rtems_shell_rfs_format+0x1b4> <== NOT EXECUTED
40020240: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
printf ("error: no driver name provided\n");
40020244: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
40020248: 90 12 23 28 or %o0, 0x328, %o0 ! 40058f28 <rtems_rtc_shell_usage+0x1890><== NOT EXECUTED
4002024c: 40 00 6a dc call 4003adbc <puts> <== NOT EXECUTED
40020250: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40020254: 30 80 00 10 b,a 40020294 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
40020258: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
4002025c: 40 00 35 8e call 4002d894 <rtems_rfs_format> <== NOT EXECUTED
40020260: b0 10 20 00 clr %i0 <== NOT EXECUTED
40020264: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40020268: 16 80 00 0b bge 40020294 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
4002026c: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
40020270: 40 00 57 ec call 40036220 <__errno> <== NOT EXECUTED
40020274: b0 10 20 01 mov 1, %i0 ! 1 <PROM_START+0x1> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
40020278: 40 00 73 b7 call 4003d154 <strerror> <== NOT EXECUTED
4002027c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40020280: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40020284: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020288: 11 10 01 63 sethi %hi(0x40058c00), %o0 <== NOT EXECUTED
4002028c: 40 00 6a 34 call 4003ab5c <printf> <== NOT EXECUTED
40020290: 90 12 23 48 or %o0, 0x348, %o0 ! 40058f48 <rtems_rtc_shell_usage+0x18b0><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
40020294: 81 c7 e0 08 ret <== NOT EXECUTED
40020298: 81 e8 00 00 restore <== NOT EXECUTED
40017148 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
40017148: 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 )
4001714c: 80 a6 60 00 cmp %i1, 0
40017150: 02 80 00 35 be 40017224 <rtems_signal_send+0xdc>
40017154: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
40017158: 90 10 00 18 mov %i0, %o0
4001715c: 40 00 12 93 call 4001bba8 <_Thread_Get>
40017160: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40017164: c2 07 bf fc ld [ %fp + -4 ], %g1
40017168: 80 a0 60 00 cmp %g1, 0
4001716c: 12 80 00 2d bne 40017220 <rtems_signal_send+0xd8>
40017170: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
40017174: fa 02 21 4c ld [ %o0 + 0x14c ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
40017178: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001717c: 80 a0 60 00 cmp %g1, 0
40017180: 02 80 00 24 be 40017210 <rtems_signal_send+0xc8>
40017184: 01 00 00 00 nop
if ( asr->is_enabled ) {
40017188: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
4001718c: 80 a0 60 00 cmp %g1, 0
40017190: 02 80 00 15 be 400171e4 <rtems_signal_send+0x9c>
40017194: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
40017198: 7f ff e4 1f call 40010214 <sparc_disable_interrupts>
4001719c: 01 00 00 00 nop
*signal_set |= signals;
400171a0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400171a4: b2 10 40 19 or %g1, %i1, %i1
400171a8: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
400171ac: 7f ff e4 1e call 40010224 <sparc_enable_interrupts>
400171b0: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
400171b4: 03 10 00 f6 sethi %hi(0x4003d800), %g1
400171b8: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 4003dab0 <_Per_CPU_Information>
400171bc: c4 00 60 08 ld [ %g1 + 8 ], %g2
400171c0: 80 a0 a0 00 cmp %g2, 0
400171c4: 02 80 00 0f be 40017200 <rtems_signal_send+0xb8>
400171c8: 01 00 00 00 nop
400171cc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
400171d0: 80 a7 00 02 cmp %i4, %g2
400171d4: 12 80 00 0b bne 40017200 <rtems_signal_send+0xb8> <== NEVER TAKEN
400171d8: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
400171dc: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
400171e0: 30 80 00 08 b,a 40017200 <rtems_signal_send+0xb8>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
400171e4: 7f ff e4 0c call 40010214 <sparc_disable_interrupts>
400171e8: 01 00 00 00 nop
*signal_set |= signals;
400171ec: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
400171f0: b2 10 40 19 or %g1, %i1, %i1
400171f4: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
400171f8: 7f ff e4 0b call 40010224 <sparc_enable_interrupts>
400171fc: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
40017200: 40 00 12 5e call 4001bb78 <_Thread_Enable_dispatch>
40017204: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
40017208: 10 80 00 07 b 40017224 <rtems_signal_send+0xdc>
4001720c: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
_Thread_Enable_dispatch();
40017210: 40 00 12 5a call 4001bb78 <_Thread_Enable_dispatch>
40017214: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
40017218: 10 80 00 03 b 40017224 <rtems_signal_send+0xdc>
4001721c: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40017220: 82 10 20 04 mov 4, %g1
}
40017224: 81 c7 e0 08 ret
40017228: 91 e8 00 01 restore %g0, %g1, %o0
4000e400 <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 )
{
4000e400: 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 )
4000e404: 92 10 00 1a mov %i2, %o1
4000e408: 7f ff d0 92 call 40002650 <.umul>
4000e40c: 90 06 60 08 add %i1, 8, %o0
+ key_table_size + data_size;
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
4000e410: 7f ff db 06 call 40005028 <malloc>
4000e414: 90 02 20 1c add %o0, 0x1c, %o0
4000e418: 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 ) {
4000e41c: 80 a2 60 00 cmp %o1, 0
4000e420: 02 80 00 0b be 4000e44c <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
4000e424: 90 10 20 1a mov 0x1a, %o0
sc = rtems_sparse_disk_register(
4000e428: 03 10 00 38 sethi %hi(0x4000e000), %g1
4000e42c: 82 10 60 88 or %g1, 0x88, %g1 ! 4000e088 <rtems_sparse_disk_free>
4000e430: 90 10 00 18 mov %i0, %o0
4000e434: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000e438: 94 10 00 19 mov %i1, %o2
4000e43c: 96 10 00 1a mov %i2, %o3
4000e440: 98 10 00 1b mov %i3, %o4
4000e444: 7f ff ff b7 call 4000e320 <rtems_sparse_disk_register>
4000e448: 9a 10 00 1c mov %i4, %o5
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
4000e44c: 81 c7 e0 08 ret
4000e450: 91 e8 00 08 restore %g0, %o0, %o0
4000e454: 40 00 f3 38 call 4004b134 <__end+0x1dad4> <== NOT EXECUTED
4000e458: 40 00 f2 d8 call 4004afb8 <__end+0x1d958> <== NOT EXECUTED
4000e45c: 40 00 f2 ec call 4004b00c <__end+0x1d9ac> <== NOT EXECUTED
4000e460: 40 00 f2 ec call 4004b010 <__end+0x1d9b0> <== NOT EXECUTED
4000e464: 40 00 f2 ec call 4004b014 <__end+0x1d9b4> <== NOT EXECUTED
4000e468: 40 00 f2 ec call 4004b018 <__end+0x1d9b8> <== NOT EXECUTED
4000e46c: 40 00 f2 d0 call 4004afac <__end+0x1d94c> <== NOT EXECUTED
4000e470: 40 00 f2 f8 call 4004b050 <__end+0x1d9f0> <== NOT EXECUTED
4000e474: 40 00 f2 f8 call 4004b054 <__end+0x1d9f4> <== NOT EXECUTED
4000e478: 40 00 f2 f8 call 4004b058 <__end+0x1d9f8> <== NOT EXECUTED
4000e47c: 40 00 f3 18 call 4004b0dc <__end+0x1da7c> <== NOT EXECUTED
4000e480: 40 00 f2 24 call 4004ad10 <__end+0x1d6b0> <== NOT EXECUTED
4000e484: 40 00 f2 24 call 4004ad14 <__end+0x1d6b4> <== NOT EXECUTED
4000e488: 40 00 f2 44 call 4004ad98 <__end+0x1d738> <== NOT EXECUTED
4000e48c: 40 00 f2 44 call 4004ad9c <__end+0x1d73c> <== NOT EXECUTED
4000e490: 40 00 f2 44 call 4004ada0 <__end+0x1d740> <== NOT EXECUTED
4000e494: 40 00 f2 44 call 4004ada4 <__end+0x1d744> <== NOT EXECUTED
4000e498: 40 00 f1 f0 call 4004ac58 <__end+0x1d5f8> <== NOT EXECUTED
4000e49c: 40 00 f2 50 call 4004addc <__end+0x1d77c> <== NOT EXECUTED
4000e4a0: 40 00 f2 50 call 4004ade0 <__end+0x1d780> <== NOT EXECUTED
4000e4a4: 40 00 f2 50 call 4004ade4 <__end+0x1d784> <== NOT EXECUTED
4000e4a8: 40 01 08 c4 call 400507b8 <__end+0x23158> <== NOT EXECUTED
4000e4ac: 40 01 08 c4 call 400507bc <__end+0x2315c> <== NOT EXECUTED
4000e4b0: 40 01 08 84 call 400506c0 <__end+0x23060> <== NOT EXECUTED
4000e4b4: 40 01 08 b4 call 40050784 <__end+0x23124> <== NOT EXECUTED
4000e4b8: 40 01 08 b4 call 40050788 <__end+0x23128> <== NOT EXECUTED
4000e4bc: 40 01 08 b4 call 4005078c <__end+0x2312c> <== NOT EXECUTED
4000e4c0: 40 01 08 c4 call 400507d0 <__end+0x23170> <== NOT EXECUTED
4000e4c4: 40 01 08 7c call 400506b4 <__end+0x23054> <== NOT EXECUTED
4000e4c8: 40 01 08 74 call 40050698 <__end+0x23038> <== NOT EXECUTED
4000e4cc: 40 01 08 ac call 4005077c <__end+0x2311c> <== NOT EXECUTED
4000e4d0: 40 01 08 c4 call 400507e0 <__end+0x23180> <== NOT EXECUTED
4000e320 <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 )
{
4000e320: 9d e3 bf a0 save %sp, -96, %sp
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
4000e324: 90 10 20 0a mov 0xa, %o0
uint32_t media_block_size,
rtems_blkdev_bnum blocks_with_buffer,
rtems_blkdev_bnum media_block_count,
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
4000e328: a0 10 00 19 mov %i1, %l0
4000e32c: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
4000e330: 80 a6 c0 1c cmp %i3, %i4
4000e334: 18 80 00 31 bgu 4000e3f8 <rtems_sparse_disk_register+0xd8><== NEVER TAKEN
4000e338: b2 10 00 1a mov %i2, %i1
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
4000e33c: 80 a4 20 00 cmp %l0, 0
4000e340: 02 80 00 2d be 4000e3f4 <rtems_sparse_disk_register+0xd4> <== NEVER TAKEN
4000e344: 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
4000e348: b5 2e e0 03 sll %i3, 3, %i2
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
4000e34c: 90 10 00 10 mov %l0, %o0
4000e350: a2 06 a0 1c add %i2, 0x1c, %l1
4000e354: 40 00 34 40 call 4001b454 <memset>
4000e358: 94 10 00 11 mov %l1, %o2
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
4000e35c: 92 10 00 19 mov %i1, %o1
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
4000e360: 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;
4000e364: 7f ff d0 bb call 40002650 <.umul>
4000e368: 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 ),
4000e36c: 92 10 00 1d mov %i5, %o1
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
4000e370: 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 ),
4000e374: a2 04 00 11 add %l0, %l1, %l1
4000e378: 40 00 34 37 call 4001b454 <memset>
4000e37c: 90 10 00 11 mov %l1, %o0
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
sc = rtems_semaphore_create(
4000e380: 11 14 d4 10 sethi %hi(0x53504000), %o0
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
4000e384: e4 24 20 10 st %l2, [ %l0 + 0x10 ]
sc = rtems_semaphore_create(
4000e388: 90 12 21 52 or %o0, 0x152, %o0
4000e38c: 92 10 20 01 mov 1, %o1
4000e390: 94 10 20 54 mov 0x54, %o2
4000e394: 96 10 20 00 clr %o3
4000e398: 7f ff ea 56 call 40008cf0 <rtems_semaphore_create>
4000e39c: 98 10 00 10 mov %l0, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
4000e3a0: 80 a2 20 00 cmp %o0, 0
4000e3a4: 12 80 00 15 bne 4000e3f8 <rtems_sparse_disk_register+0xd8><== NEVER TAKEN
4000e3a8: 84 04 20 1c add %l0, 0x1c, %g2
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
4000e3ac: f6 24 20 04 st %i3, [ %l0 + 4 ]
sd->key_table = (rtems_sparse_disk_key *) data;
4000e3b0: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000e3b4: 82 10 20 00 clr %g1
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
4000e3b8: 10 80 00 06 b 4000e3d0 <rtems_sparse_disk_register+0xb0>
4000e3bc: 84 00 80 1a add %g2, %i2, %g2
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000e3c0: 82 00 60 01 inc %g1
}
return sc;
}
rtems_status_code rtems_sparse_disk_register(
4000e3c4: 86 04 00 03 add %l0, %g3, %g3
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
4000e3c8: c4 20 e0 20 st %g2, [ %g3 + 0x20 ]
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000e3cc: 84 00 80 19 add %g2, %i1, %g2
4000e3d0: 80 a0 40 1b cmp %g1, %i3
4000e3d4: 12 bf ff fb bne 4000e3c0 <rtems_sparse_disk_register+0xa0>
4000e3d8: 87 28 60 03 sll %g1, 3, %g3
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
4000e3dc: b4 10 00 1c mov %i4, %i2
4000e3e0: 37 10 00 38 sethi %hi(0x4000e000), %i3
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
}
sd->media_block_size = media_block_size;
4000e3e4: f2 24 20 0c st %i1, [ %l0 + 0xc ]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
4000e3e8: b6 16 e0 94 or %i3, 0x94, %i3
4000e3ec: 40 00 0a 93 call 40010e38 <rtems_blkdev_create>
4000e3f0: 99 e8 00 10 restore %g0, %l0, %o4
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
return RTEMS_INVALID_ADDRESS;
4000e3f4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
4000e3f8: 81 c7 e0 08 ret <== NOT EXECUTED
4000e3fc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400219fc <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
400219fc: 9d e3 bf a0 save %sp, -96, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
40021a00: c2 06 20 08 ld [ %i0 + 8 ], %g1
40021a04: 80 a0 60 00 cmp %g1, 0
40021a08: 02 80 00 07 be 40021a24 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
40021a0c: 13 10 01 8e sethi %hi(0x40063800), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
40021a10: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
40021a14: 90 02 20 08 add %o0, 8, %o0
40021a18: 92 12 63 fc or %o1, 0x3fc, %o1
40021a1c: 40 00 5f 50 call 4003975c <memcpy>
40021a20: 94 10 20 10 mov 0x10, %o2
40021a24: 81 c7 e0 08 ret
40021a28: 81 e8 00 00 restore
40021944 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
40021944: 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 )
40021948: 03 10 01 8a sethi %hi(0x40062800), %g1
4002194c: c2 00 62 18 ld [ %g1 + 0x218 ], %g1 ! 40062a18 <Stack_check_Initialized>
40021950: 80 a0 60 00 cmp %g1, 0
40021954: 12 80 00 21 bne 400219d8 <rtems_stack_checker_create_extension+0x94>
40021958: 05 10 01 8e sethi %hi(0x40063800), %g2
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
4002195c: 07 3f bb 7c sethi %hi(0xfeedf000), %g3
40021960: 82 10 a3 fc or %g2, 0x3fc, %g1
40021964: 86 10 e0 0d or %g3, 0xd, %g3
40021968: c6 20 a3 fc st %g3, [ %g2 + 0x3fc ]
4002196c: 05 02 eb 43 sethi %hi(0xbad0c00), %g2
40021970: 84 10 a1 06 or %g2, 0x106, %g2 ! bad0d06 <RAM_SIZE+0xb6d0d06>
40021974: c4 20 60 04 st %g2, [ %g1 + 4 ]
40021978: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
4002197c: 84 10 a0 0d or %g2, 0xd, %g2 ! deadf00d <LEON_REG+0x5eadf00d>
40021980: c4 20 60 08 st %g2, [ %g1 + 8 ]
40021984: 05 18 03 43 sethi %hi(0x600d0c00), %g2
40021988: 84 10 a1 06 or %g2, 0x106, %g2 ! 600d0d06 <RAM_END+0x1fcd0d06>
4002198c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
40021990: 03 10 01 8d sethi %hi(0x40063400), %g1
40021994: d0 00 62 d0 ld [ %g1 + 0x2d0 ], %o0 ! 400636d0 <_Per_CPU_Information>
40021998: 80 a2 20 00 cmp %o0, 0
4002199c: 02 80 00 0c be 400219cc <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
400219a0: 84 10 62 d0 or %g1, 0x2d0, %g2
400219a4: d4 00 a0 04 ld [ %g2 + 4 ], %o2
400219a8: 80 a2 a0 00 cmp %o2, 0
400219ac: 02 80 00 08 be 400219cc <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
400219b0: 03 10 01 8f sethi %hi(0x40063c00), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
400219b4: 84 10 60 0c or %g1, 0xc, %g2 ! 40063c0c <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
400219b8: 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;
400219bc: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
400219c0: d4 20 60 0c st %o2, [ %g1 + 0xc ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
400219c4: 40 00 5f f5 call 40039998 <memset>
400219c8: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
400219cc: 84 10 20 01 mov 1, %g2
400219d0: 03 10 01 8a sethi %hi(0x40062800), %g1
400219d4: c4 20 62 18 st %g2, [ %g1 + 0x218 ] ! 40062a18 <Stack_check_Initialized>
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
400219d8: 80 a6 60 00 cmp %i1, 0
400219dc: 02 80 00 06 be 400219f4 <rtems_stack_checker_create_extension+0xb0><== NEVER TAKEN
400219e0: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
400219e4: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
400219e8: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
400219ec: 40 00 5f eb call 40039998 <memset>
400219f0: 92 10 20 a5 mov 0xa5, %o1
return true;
}
400219f4: 81 c7 e0 08 ret
400219f8: 91 e8 20 01 restore %g0, 1, %o0
40021b4c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
40021b4c: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
40021b50: 03 10 01 8d sethi %hi(0x40063400), %g1
40021b54: fa 00 62 e0 ld [ %g1 + 0x2e0 ], %i5 ! 400636e0 <_Per_CPU_Information+0x10>
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40021b58: d0 07 60 b8 ld [ %i5 + 0xb8 ], %o0
40021b5c: 80 a7 80 08 cmp %fp, %o0
40021b60: 0a 80 00 06 bcs 40021b78 <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
40021b64: b8 10 20 00 clr %i4
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
40021b68: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40021b6c: 82 02 00 01 add %o0, %g1, %g1
40021b70: 80 a0 40 1e cmp %g1, %fp
40021b74: b8 60 3f ff subx %g0, -1, %i4
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
40021b78: 03 10 01 8a sethi %hi(0x40062800), %g1
40021b7c: c2 00 62 18 ld [ %g1 + 0x218 ], %g1 ! 40062a18 <Stack_check_Initialized>
40021b80: 80 a0 60 00 cmp %g1, 0
40021b84: 02 80 00 09 be 40021ba8 <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
40021b88: 92 10 20 01 mov 1, %o1
pattern_ok = (!memcmp(
40021b8c: 90 02 20 08 add %o0, 8, %o0
40021b90: 13 10 01 8e sethi %hi(0x40063800), %o1
40021b94: 94 10 20 10 mov 0x10, %o2
40021b98: 40 00 5e c7 call 400396b4 <memcmp>
40021b9c: 92 12 63 fc or %o1, 0x3fc, %o1
40021ba0: 80 a0 00 08 cmp %g0, %o0
40021ba4: 92 60 3f ff subx %g0, -1, %o1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
40021ba8: 82 1a 60 01 xor %o1, 1, %g1
40021bac: 80 88 60 ff btst 0xff, %g1
40021bb0: 12 80 00 05 bne 40021bc4 <rtems_stack_checker_is_blown+0x78><== NEVER TAKEN
40021bb4: b8 1f 20 01 xor %i4, 1, %i4
40021bb8: 80 8f 20 ff btst 0xff, %i4
40021bbc: 02 80 00 05 be 40021bd0 <rtems_stack_checker_is_blown+0x84><== ALWAYS TAKEN
40021bc0: 01 00 00 00 nop
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
40021bc4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021bc8: 7f ff ff 99 call 40021a2c <Stack_check_report_blown_task> <== NOT EXECUTED
40021bcc: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
40021bd0: 81 c7 e0 08 ret
40021bd4: 91 e8 20 00 restore %g0, 0, %o0
40021c38 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
40021c38: 13 10 00 90 sethi %hi(0x40024000), %o1 <== NOT EXECUTED
40021c3c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40021c40: 92 12 61 9c or %o1, 0x19c, %o1 <== NOT EXECUTED
40021c44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40021c48: 7f ff ff e4 call 40021bd8 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
40021c4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40021bd8 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40021bd8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( !print )
40021bdc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40021be0: 02 80 00 14 be 40021c30 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
40021be4: 39 10 01 8a sethi %hi(0x40062800), %i4 <== NOT EXECUTED
return;
print_context = context;
print_handler = print;
40021be8: 3b 10 01 8a sethi %hi(0x40062800), %i5 <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
40021bec: f0 27 22 1c st %i0, [ %i4 + 0x21c ] <== NOT EXECUTED
print_handler = print;
40021bf0: f2 27 62 20 st %i1, [ %i5 + 0x220 ] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
40021bf4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021bf8: 13 10 01 66 sethi %hi(0x40059800), %o1 <== NOT EXECUTED
40021bfc: 9f c6 40 00 call %i1 <== NOT EXECUTED
40021c00: 92 12 60 c8 or %o1, 0xc8, %o1 ! 400598c8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8><== NOT EXECUTED
(*print)( context,
40021c04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021c08: 13 10 01 66 sethi %hi(0x40059800), %o1 <== NOT EXECUTED
40021c0c: 9f c6 40 00 call %i1 <== NOT EXECUTED
40021c10: 92 12 60 e0 or %o1, 0xe0, %o1 ! 400598e0 <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 );
40021c14: 11 10 00 85 sethi %hi(0x40021400), %o0 <== NOT EXECUTED
40021c18: 40 00 11 cc call 40026348 <rtems_iterate_over_all_threads><== NOT EXECUTED
40021c1c: 90 12 23 d4 or %o0, 0x3d4, %o0 ! 400217d4 <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);
40021c20: 7f ff fe ed call 400217d4 <Stack_check_Dump_threads_usage><== NOT EXECUTED
40021c24: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
#endif
print_context = NULL;
40021c28: c0 27 22 1c clr [ %i4 + 0x21c ] <== NOT EXECUTED
print_handler = NULL;
40021c2c: c0 27 62 20 clr [ %i5 + 0x220 ] <== NOT EXECUTED
40021c30: 81 c7 e0 08 ret <== NOT EXECUTED
40021c34: 81 e8 00 00 restore <== NOT EXECUTED
40021adc <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
40021adc: 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);
40021ae0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
40021ae4: ba 10 20 00 clr %i5
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40021ae8: 80 a7 80 01 cmp %fp, %g1
40021aec: 0a 80 00 06 bcs 40021b04 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
40021af0: 90 00 60 08 add %g1, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
40021af4: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
40021af8: 82 00 40 02 add %g1, %g2, %g1
40021afc: 80 a0 40 1e cmp %g1, %fp
40021b00: ba 60 3f ff subx %g0, -1, %i5
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
40021b04: 13 10 01 8e sethi %hi(0x40063800), %o1
40021b08: 94 10 20 10 mov 0x10, %o2
40021b0c: 40 00 5e ea call 400396b4 <memcmp>
40021b10: 92 12 63 fc or %o1, 0x3fc, %o1
40021b14: 80 a0 00 08 cmp %g0, %o0
40021b18: 82 60 3f ff subx %g0, -1, %g1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
40021b1c: 80 a0 60 00 cmp %g1, 0
40021b20: 02 80 00 06 be 40021b38 <rtems_stack_checker_switch_extension+0x5c><== NEVER TAKEN
40021b24: 92 10 00 01 mov %g1, %o1
40021b28: ba 1f 60 01 xor %i5, 1, %i5
40021b2c: 80 8f 60 ff btst 0xff, %i5
40021b30: 02 80 00 05 be 40021b44 <rtems_stack_checker_switch_extension+0x68><== ALWAYS TAKEN
40021b34: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
40021b38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021b3c: 7f ff ff bc call 40021a2c <Stack_check_report_blown_task> <== NOT EXECUTED
40021b40: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
40021b44: 81 c7 e0 08 ret
40021b48: 81 e8 00 00 restore
4000d220 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4000d220: 9d e3 bf 98 save %sp, -104, %sp
double result;
char *end;
if ( !n )
4000d224: 80 a6 60 00 cmp %i1, 0
4000d228: 02 80 00 34 be 4000d2f8 <rtems_string_to_double+0xd8>
4000d22c: b6 10 20 09 mov 9, %i3
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d230: 40 00 0b 93 call 4001007c <__errno>
4000d234: 01 00 00 00 nop
4000d238: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d23c: c0 26 40 00 clr [ %i1 ]
4000d240: c0 26 60 04 clr [ %i1 + 4 ]
result = strtod( s, &end );
4000d244: 90 10 00 18 mov %i0, %o0
4000d248: 40 00 16 ee call 40012e00 <strtod>
4000d24c: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
4000d250: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4000d254: b8 10 00 08 mov %o0, %i4
4000d258: ba 10 00 09 mov %o1, %i5
if ( endptr )
4000d25c: 02 80 00 03 be 4000d268 <rtems_string_to_double+0x48>
4000d260: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
4000d264: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000d268: 80 a0 40 18 cmp %g1, %i0
4000d26c: 02 80 00 23 be 4000d2f8 <rtems_string_to_double+0xd8>
4000d270: b6 10 20 0b mov 0xb, %i3
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d274: 40 00 0b 82 call 4001007c <__errno>
4000d278: 01 00 00 00 nop
4000d27c: c2 02 00 00 ld [ %o0 ], %g1
4000d280: 80 a0 60 22 cmp %g1, 0x22
4000d284: 32 80 00 1c bne,a 4000d2f4 <rtems_string_to_double+0xd4>
4000d288: f8 3e 40 00 std %i4, [ %i1 ]
4000d28c: 90 10 00 1c mov %i4, %o0
4000d290: 92 10 00 1d mov %i5, %o1
4000d294: 94 10 20 00 clr %o2
4000d298: 96 10 20 00 clr %o3
4000d29c: 40 00 41 2a call 4001d744 <__eqdf2>
4000d2a0: b6 10 20 0a mov 0xa, %i3
4000d2a4: 80 a2 20 00 cmp %o0, 0
4000d2a8: 02 80 00 14 be 4000d2f8 <rtems_string_to_double+0xd8> <== NEVER TAKEN
4000d2ac: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000d2b0: 92 10 00 1d mov %i5, %o1
4000d2b4: 15 1f fb ff sethi %hi(0x7feffc00), %o2
4000d2b8: 96 10 3f ff mov -1, %o3
4000d2bc: 40 00 41 38 call 4001d79c <__gtdf2>
4000d2c0: 94 12 a3 ff or %o2, 0x3ff, %o2
4000d2c4: 80 a2 20 00 cmp %o0, 0
4000d2c8: 14 80 00 0c bg 4000d2f8 <rtems_string_to_double+0xd8>
4000d2cc: 90 10 00 1c mov %i4, %o0
4000d2d0: 92 10 00 1d mov %i5, %o1
4000d2d4: 15 3f fb ff sethi %hi(0xffeffc00), %o2
4000d2d8: 96 10 3f ff mov -1, %o3
4000d2dc: 40 00 41 5c call 4001d84c <__ltdf2>
4000d2e0: 94 12 a3 ff or %o2, 0x3ff, %o2
4000d2e4: 80 a2 20 00 cmp %o0, 0
4000d2e8: 06 80 00 04 bl 4000d2f8 <rtems_string_to_double+0xd8> <== ALWAYS TAKEN
4000d2ec: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000d2f0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000d2f4: b6 10 20 00 clr %i3
}
4000d2f8: 81 c7 e0 08 ret
4000d2fc: 91 e8 00 1b restore %g0, %i3, %o0
4000d300 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4000d300: 9d e3 bf 98 save %sp, -104, %sp
float result;
char *end;
if ( !n )
4000d304: 80 a6 60 00 cmp %i1, 0
4000d308: 02 80 00 2c be 4000d3b8 <rtems_string_to_float+0xb8>
4000d30c: b8 10 20 09 mov 9, %i4
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d310: 40 00 0b 5b call 4001007c <__errno>
4000d314: 01 00 00 00 nop
4000d318: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d31c: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
4000d320: 90 10 00 18 mov %i0, %o0
4000d324: 40 00 16 be call 40012e1c <strtof>
4000d328: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
4000d32c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
4000d330: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000d334: 02 80 00 03 be 4000d340 <rtems_string_to_float+0x40>
4000d338: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
4000d33c: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000d340: 80 a0 40 18 cmp %g1, %i0
4000d344: 02 80 00 1d be 4000d3b8 <rtems_string_to_float+0xb8>
4000d348: b8 10 20 0b mov 0xb, %i4
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d34c: 40 00 0b 4c call 4001007c <__errno>
4000d350: 01 00 00 00 nop
4000d354: c2 02 00 00 ld [ %o0 ], %g1
4000d358: 80 a0 60 22 cmp %g1, 0x22
4000d35c: 32 80 00 16 bne,a 4000d3b4 <rtems_string_to_float+0xb4>
4000d360: fa 26 40 00 st %i5, [ %i1 ]
4000d364: 90 10 00 1d mov %i5, %o0
4000d368: 92 10 20 00 clr %o1
4000d36c: 40 00 3e 51 call 4001ccb0 <__eqsf2>
4000d370: b8 10 20 0a mov 0xa, %i4
4000d374: 80 a2 20 00 cmp %o0, 0
4000d378: 02 80 00 10 be 4000d3b8 <rtems_string_to_float+0xb8> <== NEVER TAKEN
4000d37c: 90 10 00 1d mov %i5, %o0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000d380: 13 1f df ff sethi %hi(0x7f7ffc00), %o1
4000d384: 40 00 3e 60 call 4001cd04 <__gtsf2>
4000d388: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7f7fffff <RAM_END+0x3f3fffff>
4000d38c: 80 a2 20 00 cmp %o0, 0
4000d390: 14 80 00 0a bg 4000d3b8 <rtems_string_to_float+0xb8>
4000d394: 90 10 00 1d mov %i5, %o0
4000d398: 13 3f df ff sethi %hi(0xff7ffc00), %o1
4000d39c: 40 00 3e 6f call 4001cd58 <__ltsf2>
4000d3a0: 92 12 63 ff or %o1, 0x3ff, %o1 ! ff7fffff <LEON_REG+0x7f7fffff>
4000d3a4: 80 a2 20 00 cmp %o0, 0
4000d3a8: 06 80 00 04 bl 4000d3b8 <rtems_string_to_float+0xb8> <== ALWAYS TAKEN
4000d3ac: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000d3b0: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000d3b4: b8 10 20 00 clr %i4
}
4000d3b8: 81 c7 e0 08 ret
4000d3bc: 91 e8 00 1c restore %g0, %i4, %o0
4001c988 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4001c988: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4001c98c: 80 a6 60 00 cmp %i1, 0
4001c990: 02 80 00 25 be 4001ca24 <rtems_string_to_int+0x9c>
4001c994: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4001c998: 40 00 66 22 call 40036220 <__errno>
4001c99c: 01 00 00 00 nop
4001c9a0: c0 22 00 00 clr [ %o0 ]
*n = 0;
4001c9a4: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4001c9a8: 90 10 00 18 mov %i0, %o0
4001c9ac: 92 07 bf fc add %fp, -4, %o1
4001c9b0: 40 00 87 18 call 4003e610 <strtol>
4001c9b4: 94 10 00 1b mov %i3, %o2
if ( endptr )
4001c9b8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4001c9bc: ba 10 00 08 mov %o0, %i5
if ( endptr )
4001c9c0: 02 80 00 03 be 4001c9cc <rtems_string_to_int+0x44>
4001c9c4: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4001c9c8: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4001c9cc: 80 a0 80 18 cmp %g2, %i0
4001c9d0: 02 80 00 15 be 4001ca24 <rtems_string_to_int+0x9c>
4001c9d4: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001c9d8: 40 00 66 12 call 40036220 <__errno>
4001c9dc: 01 00 00 00 nop
4001c9e0: c2 02 00 00 ld [ %o0 ], %g1
4001c9e4: 80 a0 60 22 cmp %g1, 0x22
4001c9e8: 32 80 00 0e bne,a 4001ca20 <rtems_string_to_int+0x98>
4001c9ec: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001c9f0: 03 20 00 00 sethi %hi(0x80000000), %g1
4001c9f4: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001c9f8: 80 a0 60 00 cmp %g1, 0
4001c9fc: 02 80 00 0a be 4001ca24 <rtems_string_to_int+0x9c>
4001ca00: 82 10 20 0a mov 0xa, %g1
4001ca04: 80 a7 60 00 cmp %i5, 0
4001ca08: 02 80 00 07 be 4001ca24 <rtems_string_to_int+0x9c> <== NEVER TAKEN
4001ca0c: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001ca10: 80 a7 40 02 cmp %i5, %g2
4001ca14: 02 80 00 04 be 4001ca24 <rtems_string_to_int+0x9c> <== ALWAYS TAKEN
4001ca18: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4001ca1c: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4001ca20: 82 10 20 00 clr %g1
}
4001ca24: 81 c7 e0 08 ret
4001ca28: 91 e8 00 01 restore %g0, %g1, %o0
4000d530 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4000d530: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4000d534: 80 a6 60 00 cmp %i1, 0
4000d538: 02 80 00 25 be 4000d5cc <rtems_string_to_long+0x9c>
4000d53c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d540: 40 00 0a cf call 4001007c <__errno>
4000d544: 01 00 00 00 nop
4000d548: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d54c: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000d550: 90 10 00 18 mov %i0, %o0
4000d554: 92 07 bf fc add %fp, -4, %o1
4000d558: 40 00 16 d2 call 400130a0 <strtol>
4000d55c: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000d560: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4000d564: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000d568: 02 80 00 03 be 4000d574 <rtems_string_to_long+0x44>
4000d56c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000d570: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000d574: 80 a0 80 18 cmp %g2, %i0
4000d578: 02 80 00 15 be 4000d5cc <rtems_string_to_long+0x9c>
4000d57c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d580: 40 00 0a bf call 4001007c <__errno>
4000d584: 01 00 00 00 nop
4000d588: c2 02 00 00 ld [ %o0 ], %g1
4000d58c: 80 a0 60 22 cmp %g1, 0x22
4000d590: 32 80 00 0e bne,a 4000d5c8 <rtems_string_to_long+0x98>
4000d594: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000d598: 03 20 00 00 sethi %hi(0x80000000), %g1
4000d59c: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d5a0: 80 a0 60 00 cmp %g1, 0
4000d5a4: 02 80 00 0a be 4000d5cc <rtems_string_to_long+0x9c>
4000d5a8: 82 10 20 0a mov 0xa, %g1
4000d5ac: 80 a7 60 00 cmp %i5, 0
4000d5b0: 02 80 00 07 be 4000d5cc <rtems_string_to_long+0x9c> <== NEVER TAKEN
4000d5b4: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000d5b8: 80 a7 40 02 cmp %i5, %g2
4000d5bc: 02 80 00 04 be 4000d5cc <rtems_string_to_long+0x9c> <== ALWAYS TAKEN
4000d5c0: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000d5c4: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000d5c8: 82 10 20 00 clr %g1
}
4000d5cc: 81 c7 e0 08 ret
4000d5d0: 91 e8 00 01 restore %g0, %g1, %o0
4000d464 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4000d464: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
4000d468: 80 a6 60 00 cmp %i1, 0
4000d46c: 02 80 00 2f be 4000d528 <rtems_string_to_long_long+0xc4>
4000d470: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d474: 40 00 0b 02 call 4001007c <__errno>
4000d478: 01 00 00 00 nop
4000d47c: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d480: c0 26 40 00 clr [ %i1 ]
4000d484: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
4000d488: 90 10 00 18 mov %i0, %o0
4000d48c: 92 07 bf fc add %fp, -4, %o1
4000d490: 40 00 17 0d call 400130c4 <strtoll>
4000d494: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000d498: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4000d49c: b8 10 00 08 mov %o0, %i4
4000d4a0: ba 10 00 09 mov %o1, %i5
if ( endptr )
4000d4a4: 02 80 00 03 be 4000d4b0 <rtems_string_to_long_long+0x4c>
4000d4a8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000d4ac: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000d4b0: 80 a0 80 18 cmp %g2, %i0
4000d4b4: 02 80 00 1d be 4000d528 <rtems_string_to_long_long+0xc4>
4000d4b8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d4bc: 40 00 0a f0 call 4001007c <__errno>
4000d4c0: 01 00 00 00 nop
4000d4c4: c2 02 00 00 ld [ %o0 ], %g1
4000d4c8: 80 a0 60 22 cmp %g1, 0x22
4000d4cc: 32 80 00 16 bne,a 4000d524 <rtems_string_to_long_long+0xc0>
4000d4d0: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000d4d4: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
4000d4d8: 07 3f ff ff sethi %hi(0xfffffc00), %g3
4000d4dc: 84 10 a3 ff or %g2, 0x3ff, %g2
4000d4e0: 86 10 e3 ff or %g3, 0x3ff, %g3
4000d4e4: 84 1f 00 02 xor %i4, %g2, %g2
4000d4e8: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d4ec: 80 90 80 03 orcc %g2, %g3, %g0
4000d4f0: 02 80 00 0e be 4000d528 <rtems_string_to_long_long+0xc4>
4000d4f4: 82 10 20 0a mov 0xa, %g1
4000d4f8: 80 97 00 1d orcc %i4, %i5, %g0
4000d4fc: 02 80 00 0b be 4000d528 <rtems_string_to_long_long+0xc4> <== NEVER TAKEN
4000d500: 01 00 00 00 nop
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000d504: 03 20 00 00 sethi %hi(0x80000000), %g1
4000d508: 80 a7 00 01 cmp %i4, %g1
4000d50c: 32 80 00 06 bne,a 4000d524 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
4000d510: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000d514: 80 a7 60 00 cmp %i5, 0
4000d518: 22 80 00 04 be,a 4000d528 <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
4000d51c: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
4000d520: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000d524: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
}
4000d528: 81 c7 e0 08 ret
4000d52c: 91 e8 00 01 restore %g0, %g1, %o0
4001ca3c <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4001ca3c: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4001ca40: 80 a6 60 00 cmp %i1, 0
4001ca44: 02 80 00 26 be 4001cadc <rtems_string_to_unsigned_char+0xa0>
4001ca48: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4001ca4c: 40 00 65 f5 call 40036220 <__errno>
4001ca50: 01 00 00 00 nop
4001ca54: c0 22 00 00 clr [ %o0 ]
*n = 0;
4001ca58: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
4001ca5c: 90 10 00 18 mov %i0, %o0
4001ca60: 92 07 bf fc add %fp, -4, %o1
4001ca64: 40 00 88 39 call 4003eb48 <strtoul>
4001ca68: 94 10 00 1b mov %i3, %o2
if ( endptr )
4001ca6c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4001ca70: ba 10 00 08 mov %o0, %i5
if ( endptr )
4001ca74: 02 80 00 03 be 4001ca80 <rtems_string_to_unsigned_char+0x44>
4001ca78: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4001ca7c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4001ca80: 80 a0 80 18 cmp %g2, %i0
4001ca84: 02 80 00 16 be 4001cadc <rtems_string_to_unsigned_char+0xa0>
4001ca88: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001ca8c: 40 00 65 e5 call 40036220 <__errno>
4001ca90: 01 00 00 00 nop
4001ca94: c2 02 00 00 ld [ %o0 ], %g1
4001ca98: 80 a0 60 22 cmp %g1, 0x22
4001ca9c: 12 80 00 07 bne 4001cab8 <rtems_string_to_unsigned_char+0x7c>
4001caa0: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
4001caa4: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001caa8: 80 a0 bf fd cmp %g2, -3
4001caac: 18 80 00 0c bgu 4001cadc <rtems_string_to_unsigned_char+0xa0><== ALWAYS TAKEN
4001cab0: 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 ) {
4001cab4: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
4001cab8: 28 80 00 08 bleu,a 4001cad8 <rtems_string_to_unsigned_char+0x9c>
4001cabc: fa 2e 40 00 stb %i5, [ %i1 ]
errno = ERANGE;
4001cac0: 40 00 65 d8 call 40036220 <__errno>
4001cac4: 01 00 00 00 nop
4001cac8: 82 10 20 22 mov 0x22, %g1 ! 22 <PROM_START+0x22>
4001cacc: c2 22 00 00 st %g1, [ %o0 ]
return RTEMS_INVALID_NUMBER;
4001cad0: 10 80 00 03 b 4001cadc <rtems_string_to_unsigned_char+0xa0>
4001cad4: 82 10 20 0a mov 0xa, %g1
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
4001cad8: 82 10 20 00 clr %g1
}
4001cadc: 81 c7 e0 08 ret
4001cae0: 91 e8 00 01 restore %g0, %g1, %o0
4000d68c <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4000d68c: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000d690: 80 a6 60 00 cmp %i1, 0
4000d694: 02 80 00 1e be 4000d70c <rtems_string_to_unsigned_int+0x80>
4000d698: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d69c: 40 00 0a 78 call 4001007c <__errno>
4000d6a0: 01 00 00 00 nop
4000d6a4: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d6a8: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000d6ac: 90 10 00 18 mov %i0, %o0
4000d6b0: 92 07 bf fc add %fp, -4, %o1
4000d6b4: 40 00 17 c9 call 400135d8 <strtoul>
4000d6b8: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000d6bc: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4000d6c0: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000d6c4: 02 80 00 03 be 4000d6d0 <rtems_string_to_unsigned_int+0x44>
4000d6c8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000d6cc: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000d6d0: 80 a0 80 18 cmp %g2, %i0
4000d6d4: 02 80 00 0e be 4000d70c <rtems_string_to_unsigned_int+0x80>
4000d6d8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d6dc: 40 00 0a 68 call 4001007c <__errno>
4000d6e0: 01 00 00 00 nop
4000d6e4: c2 02 00 00 ld [ %o0 ], %g1
4000d6e8: 80 a0 60 22 cmp %g1, 0x22
4000d6ec: 32 80 00 07 bne,a 4000d708 <rtems_string_to_unsigned_int+0x7c>
4000d6f0: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
4000d6f4: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d6f8: 80 a0 bf fd cmp %g2, -3
4000d6fc: 18 80 00 04 bgu 4000d70c <rtems_string_to_unsigned_int+0x80><== ALWAYS TAKEN
4000d700: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000d704: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000d708: 82 10 20 00 clr %g1
}
4000d70c: 81 c7 e0 08 ret
4000d710: 91 e8 00 01 restore %g0, %g1, %o0
4000ad64 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4000ad64: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000ad68: 80 a6 60 00 cmp %i1, 0
4000ad6c: 02 80 00 1e be 4000ade4 <rtems_string_to_unsigned_long+0x80>
4000ad70: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000ad74: 40 00 ad 2b call 40036220 <__errno>
4000ad78: 01 00 00 00 nop
4000ad7c: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000ad80: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000ad84: 90 10 00 18 mov %i0, %o0
4000ad88: 92 07 bf fc add %fp, -4, %o1
4000ad8c: 40 00 cf 6f call 4003eb48 <strtoul>
4000ad90: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000ad94: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4000ad98: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000ad9c: 02 80 00 03 be 4000ada8 <rtems_string_to_unsigned_long+0x44>
4000ada0: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000ada4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000ada8: 80 a0 80 18 cmp %g2, %i0
4000adac: 02 80 00 0e be 4000ade4 <rtems_string_to_unsigned_long+0x80>
4000adb0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000adb4: 40 00 ad 1b call 40036220 <__errno>
4000adb8: 01 00 00 00 nop
4000adbc: c2 02 00 00 ld [ %o0 ], %g1
4000adc0: 80 a0 60 22 cmp %g1, 0x22
4000adc4: 32 80 00 07 bne,a 4000ade0 <rtems_string_to_unsigned_long+0x7c>
4000adc8: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
4000adcc: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000add0: 80 a0 bf fd cmp %g2, -3
4000add4: 18 80 00 04 bgu 4000ade4 <rtems_string_to_unsigned_long+0x80><== ALWAYS TAKEN
4000add8: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000addc: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000ade0: 82 10 20 00 clr %g1
}
4000ade4: 81 c7 e0 08 ret
4000ade8: 91 e8 00 01 restore %g0, %g1, %o0
4000d714 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4000d714: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
4000d718: 80 a6 60 00 cmp %i1, 0
4000d71c: 02 80 00 23 be 4000d7a8 <rtems_string_to_unsigned_long_long+0x94>
4000d720: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d724: 40 00 0a 56 call 4001007c <__errno>
4000d728: 01 00 00 00 nop
4000d72c: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d730: c0 26 40 00 clr [ %i1 ]
4000d734: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
4000d738: 90 10 00 18 mov %i0, %o0
4000d73c: 92 07 bf fc add %fp, -4, %o1
4000d740: 40 00 17 af call 400135fc <strtoull>
4000d744: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000d748: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4000d74c: b8 10 00 08 mov %o0, %i4
4000d750: ba 10 00 09 mov %o1, %i5
if ( endptr )
4000d754: 02 80 00 03 be 4000d760 <rtems_string_to_unsigned_long_long+0x4c>
4000d758: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000d75c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000d760: 80 a0 80 18 cmp %g2, %i0
4000d764: 02 80 00 11 be 4000d7a8 <rtems_string_to_unsigned_long_long+0x94>
4000d768: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d76c: 40 00 0a 44 call 4001007c <__errno>
4000d770: 01 00 00 00 nop
4000d774: c2 02 00 00 ld [ %o0 ], %g1
4000d778: 80 a0 60 22 cmp %g1, 0x22
4000d77c: 32 80 00 0a bne,a 4000d7a4 <rtems_string_to_unsigned_long_long+0x90>
4000d780: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4000d784: 86 87 7f ff addcc %i5, -1, %g3
4000d788: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d78c: 80 a0 bf ff cmp %g2, -1
4000d790: 12 80 00 04 bne 4000d7a0 <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
4000d794: 80 a0 ff fd cmp %g3, -3
4000d798: 18 80 00 04 bgu 4000d7a8 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
4000d79c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000d7a0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000d7a4: 82 10 20 00 clr %g1
}
4000d7a8: 81 c7 e0 08 ret
4000d7ac: 91 e8 00 01 restore %g0, %g1, %o0
40002934 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
40002934: 9d e3 bd e8 save %sp, -536, %sp
IMFS_jnode_t *node;
int rv = 0;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_eval_path_context_t ctx;
rtems_filesystem_location_info_t rootloc;
rtems_filesystem_location_info_t *currentloc =
40002938: 94 10 20 18 mov 0x18, %o2
4000293c: 92 10 00 18 mov %i0, %o1
40002940: 40 00 07 b4 call 40004810 <rtems_filesystem_eval_path_start>
40002944: 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(
40002948: 92 07 be 78 add %fp, -392, %o1
4000294c: b6 10 00 08 mov %o0, %i3
40002950: 40 00 08 aa call 40004bf8 <rtems_filesystem_location_copy_and_detach>
40002954: 90 07 be 48 add %fp, -440, %o0
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
40002958: 82 10 20 60 mov 0x60, %g1
4000295c: c2 27 be 70 st %g1, [ %fp + -400 ]
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
40002960: c2 07 be 5c ld [ %fp + -420 ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40002964: 05 10 00 81 sethi %hi(0x40020400), %g2
rootloc.mt_entry->ops != &IMFS_ops
40002968: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
4000296c: 84 10 a1 40 or %g2, 0x140, %g2
40002970: 80 a0 40 02 cmp %g1, %g2
40002974: 02 80 00 06 be 4000298c <rtems_tarfs_load+0x58>
40002978: 05 10 00 83 sethi %hi(0x40020c00), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
4000297c: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 40020ee0 <fifoIMFS_ops>
40002980: 80 a0 40 02 cmp %g1, %g2
40002984: 32 80 00 66 bne,a 40002b1c <rtems_tarfs_load+0x1e8> <== ALWAYS TAKEN
40002988: b0 10 3f ff mov -1, %i0
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
4000298c: 25 10 00 81 sethi %hi(0x40020400), %l2
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40002990: 27 10 00 83 sethi %hi(0x40020c00), %l3
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
if (full_filename[strlen(full_filename)-1] != '/')
strcat(full_filename, "/");
40002994: 29 10 00 75 sethi %hi(0x4001d400), %l4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40002998: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
4000299c: a4 14 a1 c8 or %l2, 0x1c8, %l2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
400029a0: a0 07 be 98 add %fp, -360, %l0
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
400029a4: a6 14 e0 3c or %l3, 0x3c, %l3
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
if (full_filename[strlen(full_filename)-1] != '/')
strcat(full_filename, "/");
400029a8: a8 15 22 50 or %l4, 0x250, %l4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
400029ac: b8 07 62 00 add %i5, 0x200, %i4
400029b0: 80 a7 00 1a cmp %i4, %i2
400029b4: 18 80 00 59 bgu 40002b18 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
400029b8: ba 06 40 1d add %i1, %i5, %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
400029bc: 92 10 00 12 mov %l2, %o1
400029c0: 90 07 61 01 add %i5, 0x101, %o0
400029c4: 40 00 42 17 call 40013220 <strncmp>
400029c8: 94 10 20 05 mov 5, %o2
400029cc: 80 a2 20 00 cmp %o0, 0
400029d0: 12 80 00 52 bne 40002b18 <rtems_tarfs_load+0x1e4>
400029d4: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
400029d8: 92 10 00 1d mov %i5, %o1
400029dc: 40 00 42 67 call 40013378 <strncpy>
400029e0: 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);
400029e4: 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';
400029e8: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
400029ec: ec 0f 60 9c ldub [ %i5 + 0x9c ], %l6
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
400029f0: 40 00 20 fd call 4000ade4 <_rtems_octal2ulong>
400029f4: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
400029f8: 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);
400029fc: aa 10 00 08 mov %o0, %l5
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40002a00: 40 00 20 f9 call 4000ade4 <_rtems_octal2ulong>
40002a04: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40002a08: 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);
40002a0c: a2 10 00 08 mov %o0, %l1
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40002a10: 40 00 20 f5 call 4000ade4 <_rtems_octal2ulong>
40002a14: 90 07 60 94 add %i5, 0x94, %o0
40002a18: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
40002a1c: 40 00 21 05 call 4000ae30 <_rtems_tar_header_checksum>
40002a20: 90 10 00 1d mov %i5, %o0
40002a24: 80 a2 00 17 cmp %o0, %l7
40002a28: 12 80 00 3c bne 40002b18 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
40002a2c: 82 0d a0 ff and %l6, 0xff, %g1
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
40002a30: 80 a0 60 35 cmp %g1, 0x35
40002a34: 12 80 00 16 bne 40002a8c <rtems_tarfs_load+0x158>
40002a38: 80 a0 60 30 cmp %g1, 0x30
strcpy(full_filename, mountpoint);
40002a3c: 92 10 00 18 mov %i0, %o1
40002a40: 40 00 40 04 call 40012a50 <strcpy>
40002a44: 90 07 bf 00 add %fp, -256, %o0
if (full_filename[strlen(full_filename)-1] != '/')
40002a48: 40 00 41 c4 call 40013158 <strlen>
40002a4c: 90 07 bf 00 add %fp, -256, %o0
40002a50: 90 07 80 08 add %fp, %o0, %o0
40002a54: c2 4a 3e ff ldsb [ %o0 + -257 ], %g1
40002a58: 80 a0 60 2f cmp %g1, 0x2f
40002a5c: 02 80 00 04 be 40002a6c <rtems_tarfs_load+0x138> <== ALWAYS TAKEN
40002a60: 90 07 bf 00 add %fp, -256, %o0
strcat(full_filename, "/");
40002a64: 40 00 3f aa call 4001290c <strcat> <== NOT EXECUTED
40002a68: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
strcat(full_filename, filename);
40002a6c: 92 10 00 10 mov %l0, %o1
40002a70: 40 00 3f a7 call 4001290c <strcat>
40002a74: 90 07 bf 00 add %fp, -256, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
40002a78: 90 07 bf 00 add %fp, -256, %o0
40002a7c: 40 00 03 f0 call 40003a3c <mkdir>
40002a80: 92 10 21 ff mov 0x1ff, %o1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40002a84: 10 bf ff ca b 400029ac <rtems_tarfs_load+0x78>
40002a88: ba 10 00 1c mov %i4, %i5
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
40002a8c: 12 bf ff c8 bne 400029ac <rtems_tarfs_load+0x78>
40002a90: ba 10 00 1c mov %i4, %i5
rtems_filesystem_location_free( currentloc );
40002a94: 40 00 02 53 call 400033e0 <rtems_filesystem_location_free>
40002a98: 90 10 00 1b mov %i3, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
40002a9c: 92 07 be 48 add %fp, -440, %o1
40002aa0: 40 00 01 81 call 400030a4 <rtems_filesystem_location_clone>
40002aa4: 90 10 00 1b mov %i3, %o0
rtems_filesystem_eval_path_set_path(
40002aa8: 40 00 41 ac call 40013158 <strlen>
40002aac: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
40002ab0: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
40002ab4: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
40002ab8: 40 00 06 f8 call 40004698 <rtems_filesystem_eval_path_continue>
40002abc: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40002ac0: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
40002ac4: 80 a0 40 13 cmp %g1, %l3
40002ac8: 02 80 00 0f be 40002b04 <rtems_tarfs_load+0x1d0> <== NEVER TAKEN
40002acc: d4 1f be 68 ldd [ %fp + -408 ], %o2
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
40002ad0: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40002ad4: c2 00 60 08 ld [ %g1 + 8 ], %g1
node = IMFS_create_node(
currentloc,
IMFS_LINEAR_FILE,
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
40002ad8: 98 0d 61 ff and %l5, 0x1ff, %o4
40002adc: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
40002ae0: 03 00 00 20 sethi %hi(0x8000), %g1
40002ae4: 90 10 00 1b mov %i3, %o0
40002ae8: 98 13 00 01 or %o4, %g1, %o4
40002aec: 40 00 22 6a call 4000b494 <IMFS_create_node_with_control>
40002af0: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
40002af4: 84 06 40 1c add %i1, %i4, %g2
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
40002af8: c0 22 20 50 clr [ %o0 + 0x50 ]
40002afc: e2 22 20 54 st %l1, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
40002b00: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
40002b04: a2 04 61 ff add %l1, 0x1ff, %l1
offset += 512 * nblocks;
40002b08: a2 0c 7e 00 and %l1, -512, %l1
40002b0c: b8 04 40 1c add %l1, %i4, %i4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40002b10: 10 bf ff a7 b 400029ac <rtems_tarfs_load+0x78>
40002b14: ba 10 00 1c mov %i4, %i5
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
40002b18: b0 10 20 00 clr %i0
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
40002b1c: 40 00 02 31 call 400033e0 <rtems_filesystem_location_free>
40002b20: 90 07 be 48 add %fp, -440, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40002b24: 40 00 07 77 call 40004900 <rtems_filesystem_eval_path_cleanup>
40002b28: 90 07 be 60 add %fp, -416, %o0
return rv;
}
40002b2c: 81 c7 e0 08 ret
40002b30: 81 e8 00 00 restore
400105e8 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
400105e8: 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 )
400105ec: 80 a6 a0 00 cmp %i2, 0
400105f0: 02 80 00 5a be 40010758 <rtems_task_mode+0x170>
400105f4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
400105f8: 03 10 00 6a sethi %hi(0x4001a800), %g1
400105fc: f8 00 60 30 ld [ %g1 + 0x30 ], %i4 ! 4001a830 <_Per_CPU_Information+0x10>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40010600: c2 0f 20 70 ldub [ %i4 + 0x70 ], %g1
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
40010604: fa 07 21 4c ld [ %i4 + 0x14c ], %i5
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40010608: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4001060c: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40010610: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
40010614: 80 a0 60 00 cmp %g1, 0
40010618: 02 80 00 03 be 40010624 <rtems_task_mode+0x3c>
4001061c: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
40010620: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40010624: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
40010628: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
4001062c: 7f ff ed 50 call 4000bb6c <_CPU_ISR_Get_level>
40010630: a0 60 3f ff subx %g0, -1, %l0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40010634: a1 2c 20 0a sll %l0, 0xa, %l0
40010638: 90 14 00 08 or %l0, %o0, %o0
old_mode |= _ISR_Get_level();
4001063c: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
40010640: 80 8e 61 00 btst 0x100, %i1
40010644: 02 80 00 06 be 4001065c <rtems_task_mode+0x74>
40010648: 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;
4001064c: 83 36 20 08 srl %i0, 8, %g1
40010650: 82 18 60 01 xor %g1, 1, %g1
40010654: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
40010658: c2 2f 20 70 stb %g1, [ %i4 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
4001065c: 80 8e 62 00 btst 0x200, %i1
40010660: 02 80 00 0b be 4001068c <rtems_task_mode+0xa4>
40010664: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
40010668: 80 8e 22 00 btst 0x200, %i0
4001066c: 22 80 00 07 be,a 40010688 <rtems_task_mode+0xa0>
40010670: c0 27 20 78 clr [ %i4 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
40010674: 82 10 20 01 mov 1, %g1
40010678: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4001067c: 03 10 00 68 sethi %hi(0x4001a000), %g1
40010680: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 4001a270 <_Thread_Ticks_per_timeslice>
40010684: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40010688: 80 8e 60 0f btst 0xf, %i1
4001068c: 02 80 00 06 be 400106a4 <rtems_task_mode+0xbc>
40010690: 80 8e 64 00 btst 0x400, %i1
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
40010694: 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 ) );
40010698: 7f ff c8 bb call 40002984 <sparc_enable_interrupts>
4001069c: 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 ) {
400106a0: 80 8e 64 00 btst 0x400, %i1
400106a4: 02 80 00 14 be 400106f4 <rtems_task_mode+0x10c>
400106a8: 88 10 20 00 clr %g4
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
400106ac: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
400106b0: b1 36 20 0a srl %i0, 0xa, %i0
400106b4: b0 1e 20 01 xor %i0, 1, %i0
400106b8: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
400106bc: 80 a6 00 01 cmp %i0, %g1
400106c0: 22 80 00 0e be,a 400106f8 <rtems_task_mode+0x110>
400106c4: 03 10 00 6a sethi %hi(0x4001a800), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
400106c8: 7f ff c8 ab call 40002974 <sparc_disable_interrupts>
400106cc: f0 2f 60 08 stb %i0, [ %i5 + 8 ]
_signals = information->signals_pending;
400106d0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
400106d4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
information->signals_posted = _signals;
400106d8: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
400106dc: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
400106e0: 7f ff c8 a9 call 40002984 <sparc_enable_interrupts>
400106e4: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
400106e8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400106ec: 80 a0 00 01 cmp %g0, %g1
400106f0: 88 40 20 00 addx %g0, 0, %g4
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
400106f4: 03 10 00 6a sethi %hi(0x4001a800), %g1
400106f8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 ! 4001a818 <_System_state_Current>
400106fc: 80 a0 a0 03 cmp %g2, 3
40010700: 12 80 00 16 bne 40010758 <rtems_task_mode+0x170>
40010704: 82 10 20 00 clr %g1
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40010708: 07 10 00 6a sethi %hi(0x4001a800), %g3
if ( are_signals_pending ||
4001070c: 80 89 20 ff btst 0xff, %g4
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40010710: 86 10 e0 20 or %g3, 0x20, %g3
if ( are_signals_pending ||
40010714: 12 80 00 0a bne 4001073c <rtems_task_mode+0x154>
40010718: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
4001071c: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3
40010720: 80 a0 80 03 cmp %g2, %g3
40010724: 02 80 00 0d be 40010758 <rtems_task_mode+0x170>
40010728: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4001072c: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
40010730: 80 a0 a0 00 cmp %g2, 0
40010734: 02 80 00 09 be 40010758 <rtems_task_mode+0x170> <== NEVER TAKEN
40010738: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
4001073c: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
40010740: 03 10 00 6a sethi %hi(0x4001a800), %g1
40010744: 82 10 60 20 or %g1, 0x20, %g1 ! 4001a820 <_Per_CPU_Information>
40010748: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
4001074c: 40 00 02 6b call 400110f8 <_Thread_Dispatch>
40010750: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
40010754: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
40010758: 81 c7 e0 08 ret
4001075c: 91 e8 00 01 restore %g0, %g1, %o0
4000b4d0 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
4000b4d0: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
4000b4d4: 80 a6 60 00 cmp %i1, 0
4000b4d8: 02 80 00 08 be 4000b4f8 <rtems_task_set_priority+0x28>
4000b4dc: 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 ) );
4000b4e0: 03 10 00 66 sethi %hi(0x40019800), %g1
4000b4e4: c4 08 61 1c ldub [ %g1 + 0x11c ], %g2 ! 4001991c <rtems_maximum_priority>
4000b4e8: 80 a6 40 02 cmp %i1, %g2
4000b4ec: 18 80 00 1e bgu 4000b564 <rtems_task_set_priority+0x94>
4000b4f0: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4000b4f4: 80 a6 a0 00 cmp %i2, 0
4000b4f8: 02 80 00 1b be 4000b564 <rtems_task_set_priority+0x94>
4000b4fc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4000b500: 90 10 00 18 mov %i0, %o0
4000b504: 40 00 09 7c call 4000daf4 <_Thread_Get>
4000b508: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000b50c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000b510: 80 a0 60 00 cmp %g1, 0
4000b514: 12 80 00 14 bne 4000b564 <rtems_task_set_priority+0x94>
4000b518: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4000b51c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4000b520: 80 a6 60 00 cmp %i1, 0
4000b524: 02 80 00 0d be 4000b558 <rtems_task_set_priority+0x88>
4000b528: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
4000b52c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000b530: 80 a0 60 00 cmp %g1, 0
4000b534: 02 80 00 06 be 4000b54c <rtems_task_set_priority+0x7c>
4000b538: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
4000b53c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000b540: 80 a0 40 19 cmp %g1, %i1
4000b544: 08 80 00 05 bleu 4000b558 <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
4000b548: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
4000b54c: 92 10 00 19 mov %i1, %o1
4000b550: 40 00 08 43 call 4000d65c <_Thread_Change_priority>
4000b554: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
4000b558: 40 00 09 5b call 4000dac4 <_Thread_Enable_dispatch>
4000b55c: 01 00 00 00 nop
4000b560: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000b564: 81 c7 e0 08 ret
4000b568: 91 e8 00 01 restore %g0, %g1, %o0
40005b40 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
40005b40: 82 10 00 08 mov %o0, %g1
int baud_index;
switch (termios_baud) {
40005b44: 80 a0 60 09 cmp %g1, 9
40005b48: 02 80 00 17 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005b4c: 90 10 20 09 mov 9, %o0
40005b50: 80 a0 60 09 cmp %g1, 9
40005b54: 18 80 00 23 bgu 40005be0 <rtems_termios_baud_to_index+0xa0>
40005b58: 80 a0 60 0e cmp %g1, 0xe
40005b5c: 80 a0 60 04 cmp %g1, 4
40005b60: 02 80 00 11 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005b64: 90 10 20 04 mov 4, %o0
40005b68: 80 a0 60 04 cmp %g1, 4
40005b6c: 18 80 00 10 bgu 40005bac <rtems_termios_baud_to_index+0x6c>
40005b70: 80 a0 60 06 cmp %g1, 6
40005b74: 80 a0 60 01 cmp %g1, 1
40005b78: 02 80 00 0b be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005b7c: 90 10 20 01 mov 1, %o0
40005b80: 80 a0 60 01 cmp %g1, 1
40005b84: 0a 80 00 08 bcs 40005ba4 <rtems_termios_baud_to_index+0x64>
40005b88: 90 10 20 00 clr %o0
40005b8c: 80 a0 60 02 cmp %g1, 2
40005b90: 02 80 00 05 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005b94: 90 10 20 02 mov 2, %o0
40005b98: 80 a0 60 03 cmp %g1, 3
40005b9c: 12 80 00 3b bne 40005c88 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40005ba0: 90 10 20 03 mov 3, %o0
40005ba4: 81 c3 e0 08 retl
40005ba8: 01 00 00 00 nop
40005bac: 02 bf ff fe be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005bb0: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6>
40005bb4: 80 a0 60 06 cmp %g1, 6
40005bb8: 0a bf ff fb bcs 40005ba4 <rtems_termios_baud_to_index+0x64>
40005bbc: 90 10 20 05 mov 5, %o0
40005bc0: 80 a0 60 07 cmp %g1, 7
40005bc4: 02 bf ff f8 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005bc8: 90 10 20 07 mov 7, %o0
40005bcc: 80 a0 60 08 cmp %g1, 8
40005bd0: 12 80 00 2e bne 40005c88 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40005bd4: 90 10 20 08 mov 8, %o0
40005bd8: 81 c3 e0 08 retl
40005bdc: 01 00 00 00 nop
40005be0: 02 bf ff f1 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005be4: 90 10 20 0e mov 0xe, %o0 ! e <PROM_START+0xe>
40005be8: 80 a0 60 0e cmp %g1, 0xe
40005bec: 18 80 00 10 bgu 40005c2c <rtems_termios_baud_to_index+0xec>
40005bf0: 05 00 00 04 sethi %hi(0x1000), %g2
40005bf4: 80 a0 60 0b cmp %g1, 0xb
40005bf8: 02 bf ff eb be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005bfc: 90 10 20 0b mov 0xb, %o0
40005c00: 80 a0 60 0b cmp %g1, 0xb
40005c04: 0a bf ff e8 bcs 40005ba4 <rtems_termios_baud_to_index+0x64>
40005c08: 90 10 20 0a mov 0xa, %o0
40005c0c: 80 a0 60 0c cmp %g1, 0xc
40005c10: 02 bf ff e5 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005c14: 90 10 20 0c mov 0xc, %o0
40005c18: 80 a0 60 0d cmp %g1, 0xd
40005c1c: 12 80 00 1b bne 40005c88 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40005c20: 90 10 20 0d mov 0xd, %o0
40005c24: 81 c3 e0 08 retl
40005c28: 01 00 00 00 nop
40005c2c: 86 10 a0 02 or %g2, 2, %g3
40005c30: 80 a0 40 03 cmp %g1, %g3
40005c34: 02 bf ff dc be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005c38: 90 10 20 11 mov 0x11, %o0
40005c3c: 80 a0 40 03 cmp %g1, %g3
40005c40: 38 80 00 0b bgu,a 40005c6c <rtems_termios_baud_to_index+0x12c>
40005c44: 86 10 a0 03 or %g2, 3, %g3
40005c48: 80 a0 60 0f cmp %g1, 0xf
40005c4c: 02 bf ff d6 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005c50: 90 10 20 0f mov 0xf, %o0
40005c54: 84 10 a0 01 or %g2, 1, %g2
40005c58: 80 a0 40 02 cmp %g1, %g2
40005c5c: 12 80 00 0b bne 40005c88 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40005c60: 90 10 20 10 mov 0x10, %o0
40005c64: 81 c3 e0 08 retl
40005c68: 01 00 00 00 nop
40005c6c: 80 a0 40 03 cmp %g1, %g3
40005c70: 02 bf ff cd be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005c74: 90 10 20 12 mov 0x12, %o0
40005c78: 84 10 a0 04 or %g2, 4, %g2
40005c7c: 80 a0 40 02 cmp %g1, %g2
40005c80: 02 bf ff c9 be 40005ba4 <rtems_termios_baud_to_index+0x64>
40005c84: 90 10 20 13 mov 0x13, %o0
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
40005c88: 90 10 3f ff mov -1, %o0
}
return baud_index;
}
40005c8c: 81 c3 e0 08 retl
40004ebc <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
40004ebc: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40004ec0: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40004ec4: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40004ec8: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40004ecc: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004ed0: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001e0b0 <rtems_termios_ttyMutex>
40004ed4: 40 00 08 27 call 40006f70 <rtems_semaphore_obtain>
40004ed8: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40004edc: 80 a2 20 00 cmp %o0, 0
40004ee0: 22 80 00 03 be,a 40004eec <rtems_termios_close+0x30> <== ALWAYS TAKEN
40004ee4: c2 07 60 08 ld [ %i5 + 8 ], %g1
40004ee8: 30 80 00 30 b,a 40004fa8 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
40004eec: 82 00 7f ff add %g1, -1, %g1
40004ef0: 80 a0 60 00 cmp %g1, 0
40004ef4: 12 80 00 64 bne 40005084 <rtems_termios_close+0x1c8>
40004ef8: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
40004efc: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40004f00: 03 10 00 77 sethi %hi(0x4001dc00), %g1
40004f04: 85 28 a0 05 sll %g2, 5, %g2
40004f08: 82 10 61 ec or %g1, 0x1ec, %g1
40004f0c: 82 00 40 02 add %g1, %g2, %g1
40004f10: c2 00 60 04 ld [ %g1 + 4 ], %g1
40004f14: 80 a0 60 00 cmp %g1, 0
40004f18: 22 80 00 06 be,a 40004f30 <rtems_termios_close+0x74>
40004f1c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
40004f20: 9f c0 40 00 call %g1
40004f24: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004f28: 10 80 00 11 b 40004f6c <rtems_termios_close+0xb0>
40004f2c: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40004f30: 92 10 20 00 clr %o1
40004f34: 40 00 08 0f call 40006f70 <rtems_semaphore_obtain>
40004f38: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
40004f3c: 80 a2 20 00 cmp %o0, 0
40004f40: 22 80 00 03 be,a 40004f4c <rtems_termios_close+0x90> <== ALWAYS TAKEN
40004f44: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004f48: 30 80 00 18 b,a 40004fa8 <rtems_termios_close+0xec> <== NOT EXECUTED
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
40004f4c: 80 a0 60 00 cmp %g1, 0
40004f50: 02 80 00 04 be 40004f60 <rtems_termios_close+0xa4>
40004f54: 01 00 00 00 nop
40004f58: 7f ff fe ad call 40004a0c <drainOutput.part.0>
40004f5c: 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);
40004f60: 40 00 08 4d call 40007094 <rtems_semaphore_release>
40004f64: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004f68: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004f6c: 80 a0 60 02 cmp %g1, 2
40004f70: 32 80 00 10 bne,a 40004fb0 <rtems_termios_close+0xf4>
40004f74: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
40004f78: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
40004f7c: 40 00 06 d0 call 40006abc <rtems_event_send>
40004f80: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
40004f84: 80 a2 20 00 cmp %o0, 0
40004f88: 22 80 00 03 be,a 40004f94 <rtems_termios_close+0xd8> <== ALWAYS TAKEN
40004f8c: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
40004f90: 30 80 00 06 b,a 40004fa8 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
40004f94: 40 00 06 ca call 40006abc <rtems_event_send>
40004f98: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
40004f9c: 80 a2 20 00 cmp %o0, 0
40004fa0: 22 80 00 04 be,a 40004fb0 <rtems_termios_close+0xf4> <== ALWAYS TAKEN
40004fa4: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
40004fa8: 40 00 09 cf call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004fac: 01 00 00 00 nop <== NOT EXECUTED
}
if (tty->device.lastClose)
40004fb0: 80 a0 60 00 cmp %g1, 0
40004fb4: 22 80 00 07 be,a 40004fd0 <rtems_termios_close+0x114> <== ALWAYS TAKEN
40004fb8: c4 07 40 00 ld [ %i5 ], %g2
(*tty->device.lastClose)(tty->major, tty->minor, arg);
40004fbc: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
40004fc0: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
40004fc4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004fc8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
40004fcc: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
40004fd0: 80 a0 a0 00 cmp %g2, 0
40004fd4: 12 80 00 08 bne 40004ff4 <rtems_termios_close+0x138>
40004fd8: c2 07 60 04 ld [ %i5 + 4 ], %g1
rtems_termios_ttyTail = tty->back;
40004fdc: 05 10 00 78 sethi %hi(0x4001e000), %g2
if ( rtems_termios_ttyTail != NULL ) {
40004fe0: 80 a0 60 00 cmp %g1, 0
40004fe4: 02 80 00 05 be 40004ff8 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
40004fe8: c2 20 a0 b4 st %g1, [ %g2 + 0xb4 ]
rtems_termios_ttyTail->forw = NULL;
40004fec: 10 80 00 03 b 40004ff8 <rtems_termios_close+0x13c> <== NOT EXECUTED
40004ff0: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
40004ff4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
if (tty->back == NULL) {
40004ff8: c4 07 60 04 ld [ %i5 + 4 ], %g2
40004ffc: 80 a0 a0 00 cmp %g2, 0
40005000: 12 80 00 08 bne 40005020 <rtems_termios_close+0x164> <== NEVER TAKEN
40005004: c2 07 40 00 ld [ %i5 ], %g1
rtems_termios_ttyHead = tty->forw;
40005008: 05 10 00 78 sethi %hi(0x4001e000), %g2
if ( rtems_termios_ttyHead != NULL ) {
4000500c: 80 a0 60 00 cmp %g1, 0
40005010: 02 80 00 05 be 40005024 <rtems_termios_close+0x168>
40005014: c2 20 a0 b8 st %g1, [ %g2 + 0xb8 ]
rtems_termios_ttyHead->back = NULL;
40005018: 10 80 00 03 b 40005024 <rtems_termios_close+0x168>
4000501c: c0 20 60 04 clr [ %g1 + 4 ]
}
} else {
tty->back->forw = tty->forw;
40005020: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
40005024: 40 00 07 a4 call 40006eb4 <rtems_semaphore_delete>
40005028: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
4000502c: 40 00 07 a2 call 40006eb4 <rtems_semaphore_delete>
40005030: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
40005034: 40 00 07 a0 call 40006eb4 <rtems_semaphore_delete>
40005038: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
4000503c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005040: 80 a0 60 00 cmp %g1, 0
40005044: 02 80 00 06 be 4000505c <rtems_termios_close+0x1a0>
40005048: 01 00 00 00 nop
4000504c: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005050: 80 a0 60 02 cmp %g1, 2
40005054: 12 80 00 04 bne 40005064 <rtems_termios_close+0x1a8>
40005058: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
4000505c: 40 00 07 96 call 40006eb4 <rtems_semaphore_delete>
40005060: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free (tty->rawInBuf.theBuf);
40005064: 7f ff f7 da call 40002fcc <free>
40005068: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
4000506c: 7f ff f7 d8 call 40002fcc <free>
40005070: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
40005074: 7f ff f7 d6 call 40002fcc <free>
40005078: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
4000507c: 7f ff f7 d4 call 40002fcc <free>
40005080: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40005084: 03 10 00 78 sethi %hi(0x4001e000), %g1
40005088: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001e0b0 <rtems_termios_ttyMutex>
4000508c: 40 00 08 02 call 40007094 <rtems_semaphore_release>
40005090: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
40005094: 81 c7 e0 08 ret
40005098: 81 e8 00 00 restore
4000648c <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)
{
4000648c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40006490: c2 06 20 90 ld [ %i0 + 0x90 ], %g1
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
40006494: 90 10 00 18 mov %i0, %o0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40006498: b2 00 40 19 add %g1, %i1, %i1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4000649c: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
400064a0: 80 a0 60 02 cmp %g1, 2
400064a4: 12 80 00 0a bne 400064cc <rtems_termios_dequeue_characters+0x40>
400064a8: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
400064ac: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
400064b0: 40 00 01 83 call 40006abc <rtems_event_send>
400064b4: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
400064b8: 80 a2 20 00 cmp %o0, 0
400064bc: 02 80 00 11 be 40006500 <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
400064c0: b0 10 20 00 clr %i0
rtems_fatal_error_occurred (sc);
400064c4: 40 00 04 88 call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
400064c8: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
400064cc: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
400064d0: 80 a0 60 05 cmp %g1, 5
400064d4: 12 80 00 09 bne 400064f8 <rtems_termios_dequeue_characters+0x6c>
400064d8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
400064dc: c2 00 62 a0 ld [ %g1 + 0x2a0 ], %g1 ! 4001dea0 <rtems_termios_linesw+0xb4>
400064e0: 80 a0 60 00 cmp %g1, 0
400064e4: 02 80 00 07 be 40006500 <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
400064e8: b0 10 20 00 clr %i0
rtems_termios_linesw[tty->t_line].l_start(tty);
400064ec: 9f c0 40 00 call %g1
400064f0: 01 00 00 00 nop
400064f4: 30 80 00 03 b,a 40006500 <rtems_termios_dequeue_characters+0x74>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
400064f8: 7f ff f8 b0 call 400047b8 <rtems_termios_refill_transmitter>
400064fc: 81 e8 00 00 restore
}
40006500: 81 c7 e0 08 ret
40006504: 81 e8 00 00 restore
40006124 <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)
{
40006124: 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) {
40006128: c4 06 20 cc ld [ %i0 + 0xcc ], %g2
4000612c: 03 10 00 77 sethi %hi(0x4001dc00), %g1
40006130: 85 28 a0 05 sll %g2, 5, %g2
40006134: 82 10 61 ec or %g1, 0x1ec, %g1
40006138: 84 00 40 02 add %g1, %g2, %g2
4000613c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
40006140: ba 10 00 18 mov %i0, %i5
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40006144: b8 10 00 01 mov %g1, %i4
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
40006148: 80 a0 a0 00 cmp %g2, 0
4000614c: 12 80 00 10 bne 4000618c <rtems_termios_enqueue_raw_characters+0x68>
40006150: b4 06 40 1a add %i1, %i2, %i2
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40006154: b6 10 20 00 clr %i3
40006158: 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);
4000615c: a2 07 60 30 add %i5, 0x30, %l1
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
40006160: 10 80 00 a5 b 400063f4 <rtems_termios_enqueue_raw_characters+0x2d0>
40006164: a4 07 60 4a add %i5, 0x4a, %l2
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
40006168: d0 0e 40 00 ldub [ %i1 ], %o0
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
4000616c: 83 28 60 05 sll %g1, 5, %g1
40006170: 82 07 00 01 add %i4, %g1, %g1
40006174: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40006178: 91 2a 20 18 sll %o0, 0x18, %o0
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
4000617c: b2 06 60 01 inc %i1
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40006180: 91 3a 20 18 sra %o0, 0x18, %o0
40006184: 9f c0 40 00 call %g1
40006188: 92 10 00 1d mov %i5, %o1
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
4000618c: 80 a6 40 1a cmp %i1, %i2
40006190: 32 bf ff f6 bne,a 40006168 <rtems_termios_enqueue_raw_characters+0x44>
40006194: c2 07 60 cc ld [ %i5 + 0xcc ], %g1
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
40006198: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
4000619c: 80 a0 60 00 cmp %g1, 0
400061a0: 12 80 00 0b bne 400061cc <rtems_termios_enqueue_raw_characters+0xa8><== NEVER TAKEN
400061a4: b0 10 20 00 clr %i0
400061a8: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
400061ac: 80 a0 60 00 cmp %g1, 0
400061b0: 02 80 00 9b be 4000641c <rtems_termios_enqueue_raw_characters+0x2f8>
400061b4: 01 00 00 00 nop
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400061b8: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1
400061bc: 9f c0 40 00 call %g1
400061c0: 90 07 60 30 add %i5, 0x30, %o0
tty->tty_rcvwakeup = 1;
400061c4: 82 10 20 01 mov 1, %g1
400061c8: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ]
400061cc: 81 c7 e0 08 ret
400061d0: 81 e8 00 00 restore
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
400061d4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
400061d8: e0 0e 40 00 ldub [ %i1 ], %l0
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
400061dc: 80 88 62 00 btst 0x200, %g1
400061e0: 02 80 00 17 be 4000623c <rtems_termios_enqueue_raw_characters+0x118>
400061e4: 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]) {
400061e8: c4 0f 60 4a ldub [ %i5 + 0x4a ], %g2
400061ec: 83 2c 20 18 sll %l0, 0x18, %g1
400061f0: 83 38 60 18 sra %g1, 0x18, %g1
400061f4: 80 a0 40 02 cmp %g1, %g2
400061f8: c4 0f 60 49 ldub [ %i5 + 0x49 ], %g2
400061fc: 12 80 00 0a bne 40006224 <rtems_termios_enqueue_raw_characters+0x100>
40006200: 84 08 a0 ff and %g2, 0xff, %g2
if (c == tty->termios.c_cc[VSTART]) {
40006204: 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;
40006208: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
4000620c: 32 80 00 03 bne,a 40006218 <rtems_termios_enqueue_raw_characters+0xf4><== ALWAYS TAKEN
40006210: 82 10 60 10 or %g1, 0x10, %g1
40006214: 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;
40006218: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
4000621c: 10 80 00 0b b 40006248 <rtems_termios_enqueue_raw_characters+0x124>
40006220: b6 10 20 01 mov 1, %i3
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
40006224: 80 a0 40 02 cmp %g1, %g2
40006228: 12 80 00 06 bne 40006240 <rtems_termios_enqueue_raw_characters+0x11c><== ALWAYS TAKEN
4000622c: 80 8e e0 ff btst 0xff, %i3
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
40006230: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006234: 10 bf ff f9 b 40006218 <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
40006238: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
4000623c: 80 8e e0 ff btst 0xff, %i3
40006240: 02 80 00 1c be 400062b0 <rtems_termios_enqueue_raw_characters+0x18c><== ALWAYS TAKEN
40006244: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
40006248: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
4000624c: 82 08 60 30 and %g1, 0x30, %g1
40006250: 80 a0 60 20 cmp %g1, 0x20
40006254: 12 80 00 69 bne 400063f8 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
40006258: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
4000625c: 7f ff ef 93 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
40006260: 01 00 00 00 nop <== NOT EXECUTED
40006264: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
40006268: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
4000626c: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
40006270: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
40006274: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
40006278: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000627c: 02 80 00 09 be 400062a0 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
40006280: 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);
40006284: 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)(
40006288: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
4000628c: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40006290: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
40006294: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40006298: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000629c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
400062a0: 7f ff ef 86 call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
400062a4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
400062a8: 10 80 00 54 b 400063f8 <rtems_termios_enqueue_raw_characters+0x2d4><== NOT EXECUTED
400062ac: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
400062b0: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
400062b4: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
400062b8: 40 00 47 08 call 40017ed8 <.urem>
400062bc: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
400062c0: 7f ff ef 7a call 400020a8 <sparc_disable_interrupts>
400062c4: b8 10 00 08 mov %o0, %i4
400062c8: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
400062cc: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
400062d0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
400062d4: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
400062d8: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
400062dc: 40 00 46 ff call 40017ed8 <.urem>
400062e0: 90 02 00 1c add %o0, %i4, %o0
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
400062e4: c2 07 60 c0 ld [ %i5 + 0xc0 ], %g1
400062e8: 80 a2 00 01 cmp %o0, %g1
400062ec: 08 80 00 2b bleu 40006398 <rtems_termios_enqueue_raw_characters+0x274><== ALWAYS TAKEN
400062f0: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
400062f4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
400062f8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
400062fc: 12 80 00 27 bne 40006398 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
40006300: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
40006304: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006308: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
4000630c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40006310: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006314: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
40006318: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
4000631c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40006320: 32 80 00 12 bne,a 40006368 <rtems_termios_enqueue_raw_characters+0x244><== NOT EXECUTED
40006324: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
40006328: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
4000632c: 12 80 00 06 bne 40006344 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
40006330: 01 00 00 00 nop <== NOT EXECUTED
40006334: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
40006338: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000633c: 12 80 00 17 bne 40006398 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
40006340: 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;
40006344: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
40006348: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
4000634c: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
40006350: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
40006354: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40006358: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
4000635c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006360: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40006364: 30 80 00 0d b,a 40006398 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
40006368: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
4000636c: 12 80 00 0b bne 40006398 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
40006370: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
40006374: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006378: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
4000637c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
40006380: c2 07 60 ac ld [ %i5 + 0xac ], %g1 <== NOT EXECUTED
40006384: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006388: 02 80 00 04 be 40006398 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
4000638c: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
40006390: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006394: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40006398: 7f ff ef 48 call 400020b8 <sparc_enable_interrupts>
4000639c: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
400063a0: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
400063a4: 80 a7 00 01 cmp %i4, %g1
400063a8: 32 80 00 04 bne,a 400063b8 <rtems_termios_enqueue_raw_characters+0x294><== ALWAYS TAKEN
400063ac: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
dropped++;
400063b0: 10 80 00 11 b 400063f4 <rtems_termios_enqueue_raw_characters+0x2d0><== NOT EXECUTED
400063b4: b0 06 20 01 inc %i0 <== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
400063b8: e0 28 40 1c stb %l0, [ %g1 + %i4 ]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400063bc: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
400063c0: f8 27 60 60 st %i4, [ %i5 + 0x60 ]
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400063c4: 80 a0 60 00 cmp %g1, 0
400063c8: 12 80 00 0c bne 400063f8 <rtems_termios_enqueue_raw_characters+0x2d4><== NEVER TAKEN
400063cc: 80 a6 40 1a cmp %i1, %i2
400063d0: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
400063d4: 80 a0 60 00 cmp %g1, 0
400063d8: 02 80 00 08 be 400063f8 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
400063dc: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400063e0: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1 <== NOT EXECUTED
400063e4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400063e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
400063ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400063f0: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ] <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
400063f4: 80 a6 40 1a cmp %i1, %i2
400063f8: 12 bf ff 77 bne 400061d4 <rtems_termios_enqueue_raw_characters+0xb0>
400063fc: 01 00 00 00 nop
}
}
}
}
tty->rawInBufDropped += dropped;
40006400: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
40006404: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
40006408: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
4000640c: 40 00 03 22 call 40007094 <rtems_semaphore_release>
40006410: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
return dropped;
40006414: 81 c7 e0 08 ret
40006418: 81 e8 00 00 restore
}
4000641c: 81 c7 e0 08 ret
40006420: 81 e8 00 00 restore
400050bc <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
400050bc: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400050c0: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
400050c4: 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;
400050c8: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
400050cc: 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);
400050d0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
400050d4: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400050d8: 92 10 20 00 clr %o1
400050dc: 40 00 07 a5 call 40006f70 <rtems_semaphore_obtain>
400050e0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
400050e4: b0 92 20 00 orcc %o0, 0, %i0
400050e8: 12 80 01 1a bne 40005550 <rtems_termios_ioctl+0x494> <== NEVER TAKEN
400050ec: 01 00 00 00 nop
return sc;
}
switch (args->command) {
400050f0: c2 07 20 04 ld [ %i4 + 4 ], %g1
400050f4: 80 a0 60 05 cmp %g1, 5
400050f8: 22 80 00 e4 be,a 40005488 <rtems_termios_ioctl+0x3cc>
400050fc: c2 06 c0 00 ld [ %i3 ], %g1
40005100: 18 80 00 12 bgu 40005148 <rtems_termios_ioctl+0x8c>
40005104: 05 10 01 19 sethi %hi(0x40046400), %g2
40005108: 80 a0 60 02 cmp %g1, 2
4000510c: 22 80 00 34 be,a 400051dc <rtems_termios_ioctl+0x120>
40005110: d2 07 20 08 ld [ %i4 + 8 ], %o1
40005114: 18 80 00 07 bgu 40005130 <rtems_termios_ioctl+0x74>
40005118: 80 a0 60 03 cmp %g1, 3
4000511c: 80 a0 60 01 cmp %g1, 1
40005120: 32 80 00 1e bne,a 40005198 <rtems_termios_ioctl+0xdc> <== NEVER TAKEN
40005124: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
40005128: 10 80 00 29 b 400051cc <rtems_termios_ioctl+0x110>
4000512c: d0 07 20 08 ld [ %i4 + 8 ], %o0
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
40005130: 02 80 00 b3 be 400053fc <rtems_termios_ioctl+0x340>
40005134: 80 a0 60 04 cmp %g1, 4
40005138: 32 80 00 18 bne,a 40005198 <rtems_termios_ioctl+0xdc> <== NEVER TAKEN
4000513c: 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;
40005140: 10 80 00 d6 b 40005498 <rtems_termios_ioctl+0x3dc>
40005144: c2 06 c0 00 ld [ %i3 ], %g1
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
40005148: 84 10 a2 7f or %g2, 0x27f, %g2
4000514c: 80 a0 40 02 cmp %g1, %g2
40005150: 02 80 00 f1 be 40005514 <rtems_termios_ioctl+0x458> <== NEVER TAKEN
40005154: 01 00 00 00 nop
40005158: 38 80 00 07 bgu,a 40005174 <rtems_termios_ioctl+0xb8>
4000515c: 05 10 01 1d sethi %hi(0x40047400), %g2
40005160: 80 a0 60 06 cmp %g1, 6
40005164: 32 80 00 0d bne,a 40005198 <rtems_termios_ioctl+0xdc>
40005168: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
4000516c: 10 80 00 ab b 40005418 <rtems_termios_ioctl+0x35c>
40005170: c2 07 20 08 ld [ %i4 + 8 ], %g1
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
40005174: 84 10 a0 1a or %g2, 0x1a, %g2
40005178: 80 a0 40 02 cmp %g1, %g2
4000517c: 02 80 00 e3 be 40005508 <rtems_termios_ioctl+0x44c>
40005180: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40005184: 07 20 01 1d sethi %hi(0x80047400), %g3
40005188: 86 10 e0 1b or %g3, 0x1b, %g3 ! 8004741b <LEON_REG+0x4741b>
4000518c: 80 a0 40 03 cmp %g1, %g3
40005190: 02 80 00 c6 be 400054a8 <rtems_termios_ioctl+0x3ec> <== ALWAYS TAKEN
40005194: 03 10 00 77 sethi %hi(0x4001dc00), %g1
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
40005198: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000519c: 85 28 a0 05 sll %g2, 5, %g2
400051a0: 82 10 61 ec or %g1, 0x1ec, %g1
400051a4: 82 00 40 02 add %g1, %g2, %g1
400051a8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400051ac: 80 a0 60 00 cmp %g1, 0
400051b0: 02 80 00 e6 be 40005548 <rtems_termios_ioctl+0x48c>
400051b4: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
400051b8: 90 10 00 1d mov %i5, %o0
400051bc: 9f c0 40 00 call %g1
400051c0: 92 10 00 1c mov %i4, %o1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
400051c4: 10 80 00 e1 b 40005548 <rtems_termios_ioctl+0x48c>
400051c8: b0 10 00 08 mov %o0, %i0
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
400051cc: 92 07 60 30 add %i5, 0x30, %o1
400051d0: 40 00 28 78 call 4000f3b0 <memcpy>
400051d4: 94 10 20 24 mov 0x24, %o2
break;
400051d8: 30 80 00 dc b,a 40005548 <rtems_termios_ioctl+0x48c>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
400051dc: 90 07 60 30 add %i5, 0x30, %o0
400051e0: 40 00 28 74 call 4000f3b0 <memcpy>
400051e4: 94 10 20 24 mov 0x24, %o2
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
400051e8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400051ec: 80 88 62 00 btst 0x200, %g1
400051f0: 02 80 00 20 be 40005270 <rtems_termios_ioctl+0x1b4>
400051f4: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
400051f8: 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) &&
400051fc: 80 88 64 00 btst 0x400, %g1
40005200: 12 80 00 1c bne 40005270 <rtems_termios_ioctl+0x1b4>
40005204: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
40005208: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
4000520c: 82 08 7d ef and %g1, -529, %g1
40005210: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
40005214: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005218: 80 88 60 20 btst 0x20, %g1
4000521c: 02 80 00 15 be 40005270 <rtems_termios_ioctl+0x1b4> <== ALWAYS TAKEN
40005220: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
40005224: 7f ff f3 a1 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
40005228: 01 00 00 00 nop <== NOT EXECUTED
4000522c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
40005230: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40005234: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
40005238: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4000523c: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
40005240: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005244: 02 80 00 09 be 40005268 <rtems_termios_ioctl+0x1ac> <== NOT EXECUTED
40005248: 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);
4000524c: 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)(
40005250: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
40005254: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40005258: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000525c: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40005260: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005264: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40005268: 7f ff f3 94 call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
4000526c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
40005270: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005274: 80 88 64 00 btst 0x400, %g1
40005278: 02 80 00 0c be 400052a8 <rtems_termios_ioctl+0x1ec>
4000527c: 03 00 00 04 sethi %hi(0x1000), %g1
40005280: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
40005284: 80 88 80 01 btst %g2, %g1
40005288: 12 80 00 08 bne 400052a8 <rtems_termios_ioctl+0x1ec> <== NEVER TAKEN
4000528c: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
40005290: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005294: 82 08 7b ff and %g1, -1025, %g1
40005298: 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);
4000529c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400052a0: 82 08 7f fd and %g1, -3, %g1
400052a4: 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)) {
400052a8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400052ac: 80 88 61 00 btst 0x100, %g1
400052b0: 02 80 00 16 be 40005308 <rtems_termios_ioctl+0x24c> <== ALWAYS TAKEN
400052b4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
400052b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400052bc: 06 80 00 14 bl 4000530c <rtems_termios_ioctl+0x250> <== NOT EXECUTED
400052c0: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
400052c4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400052c8: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
400052cc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
400052d0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400052d4: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
400052d8: 02 80 00 08 be 400052f8 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
400052dc: 01 00 00 00 nop <== NOT EXECUTED
400052e0: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
400052e4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400052e8: 02 80 00 04 be 400052f8 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
400052ec: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
400052f0: 9f c0 40 00 call %g1 <== NOT EXECUTED
400052f4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
400052f8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400052fc: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
40005300: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
40005304: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
40005308: 80 a0 60 00 cmp %g1, 0
4000530c: 36 80 00 06 bge,a 40005324 <rtems_termios_ioctl+0x268> <== ALWAYS TAKEN
40005310: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
tty->flow_ctrl |= FL_MDRTS;
40005314: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40005318: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
4000531c: 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) {
40005320: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40005324: 05 00 00 04 sethi %hi(0x1000), %g2
40005328: 80 88 40 02 btst %g1, %g2
4000532c: 02 80 00 06 be 40005344 <rtems_termios_ioctl+0x288>
40005330: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
40005334: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
40005338: 84 10 a4 00 or %g2, 0x400, %g2
4000533c: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
40005340: 80 88 64 00 btst 0x400, %g1
40005344: 22 80 00 06 be,a 4000535c <rtems_termios_ioctl+0x2a0>
40005348: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
4000534c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005350: 82 10 62 00 or %g1, 0x200, %g1
40005354: 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) {
40005358: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
4000535c: 80 88 60 02 btst 2, %g1
40005360: 02 80 00 04 be 40005370 <rtems_termios_ioctl+0x2b4>
40005364: 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;
40005368: 10 80 00 19 b 400053cc <rtems_termios_ioctl+0x310>
4000536c: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
40005370: 40 00 05 46 call 40006888 <rtems_clock_get_ticks_per_second>
40005374: f8 0f 60 46 ldub [ %i5 + 0x46 ], %i4
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
40005378: 40 00 49 f2 call 40017b40 <.umul>
4000537c: 92 10 00 1c mov %i4, %o1
rtems_clock_get_ticks_per_second() / 10;
40005380: 40 00 4a 2a call 40017c28 <.udiv>
40005384: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
40005388: 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] *
4000538c: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
40005390: 80 a0 60 00 cmp %g1, 0
40005394: 02 80 00 0a be 400053bc <rtems_termios_ioctl+0x300>
40005398: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4000539c: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
400053a0: 80 88 60 ff btst 0xff, %g1
400053a4: 02 80 00 04 be 400053b4 <rtems_termios_ioctl+0x2f8>
400053a8: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
400053ac: 10 80 00 0c b 400053dc <rtems_termios_ioctl+0x320>
400053b0: c0 27 60 74 clr [ %i5 + 0x74 ]
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
400053b4: 10 80 00 0a b 400053dc <rtems_termios_ioctl+0x320>
400053b8: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
} else {
if (tty->termios.c_cc[VMIN]) {
400053bc: 80 88 60 ff btst 0xff, %g1
400053c0: 02 80 00 06 be 400053d8 <rtems_termios_ioctl+0x31c> <== ALWAYS TAKEN
400053c4: 82 10 20 01 mov 1, %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
400053c8: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
400053cc: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
400053d0: 10 80 00 03 b 400053dc <rtems_termios_ioctl+0x320>
400053d4: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
400053d8: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
}
}
}
if (tty->device.setAttributes)
400053dc: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
400053e0: 80 a0 60 00 cmp %g1, 0
400053e4: 02 80 00 59 be 40005548 <rtems_termios_ioctl+0x48c>
400053e8: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
400053ec: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
400053f0: 9f c0 40 00 call %g1
400053f4: 92 07 60 30 add %i5, 0x30, %o1
400053f8: 30 80 00 54 b,a 40005548 <rtems_termios_ioctl+0x48c>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
400053fc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005400: 80 a0 60 00 cmp %g1, 0
40005404: 02 80 00 51 be 40005548 <rtems_termios_ioctl+0x48c> <== ALWAYS TAKEN
40005408: 01 00 00 00 nop
4000540c: 7f ff fd 80 call 40004a0c <drainOutput.part.0> <== NOT EXECUTED
40005410: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005414: 30 80 00 4d b,a 40005548 <rtems_termios_ioctl+0x48c> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
40005418: 80 a0 60 01 cmp %g1, 1
4000541c: 02 80 00 07 be 40005438 <rtems_termios_ioctl+0x37c>
40005420: 80 a0 60 02 cmp %g1, 2
40005424: 02 80 00 0b be 40005450 <rtems_termios_ioctl+0x394>
40005428: 80 a0 60 00 cmp %g1, 0
4000542c: 32 80 00 47 bne,a 40005548 <rtems_termios_ioctl+0x48c>
40005430: b0 10 20 03 mov 3, %i0
40005434: 30 80 00 0e b,a 4000546c <rtems_termios_ioctl+0x3b0>
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
40005438: 7f ff f3 1c call 400020a8 <sparc_disable_interrupts>
4000543c: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
40005440: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
40005444: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
40005448: 10 80 00 0d b 4000547c <rtems_termios_ioctl+0x3c0>
4000544c: c0 27 60 94 clr [ %i5 + 0x94 ]
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
40005450: 7f ff f3 16 call 400020a8 <sparc_disable_interrupts>
40005454: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
40005458: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
4000545c: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
40005460: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
40005464: 7f ff f3 15 call 400020b8 <sparc_enable_interrupts>
40005468: 01 00 00 00 nop
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
4000546c: 7f ff f3 0f call 400020a8 <sparc_disable_interrupts>
40005470: 01 00 00 00 nop
tty->rawInBuf.Tail = 0;
40005474: c0 27 60 60 clr [ %i5 + 0x60 ]
tty->rawInBuf.Head = 0;
40005478: c0 27 60 5c clr [ %i5 + 0x5c ]
rtems_interrupt_enable (level);
4000547c: 7f ff f3 0f call 400020b8 <sparc_enable_interrupts>
40005480: 01 00 00 00 nop
40005484: 30 80 00 31 b,a 40005548 <rtems_termios_ioctl+0x48c>
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
40005488: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
4000548c: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
40005490: 10 80 00 2e b 40005548 <rtems_termios_ioctl+0x48c>
40005494: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
40005498: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
4000549c: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
400054a0: 10 80 00 2a b 40005548 <rtems_termios_ioctl+0x48c>
400054a4: c2 27 60 e0 st %g1, [ %i5 + 0xe0 ]
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
400054a8: 82 10 61 ec or %g1, 0x1ec, %g1
400054ac: 85 28 a0 05 sll %g2, 5, %g2
400054b0: 84 00 40 02 add %g1, %g2, %g2
400054b4: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400054b8: 80 a0 60 00 cmp %g1, 0
400054bc: 22 80 00 06 be,a 400054d4 <rtems_termios_ioctl+0x418>
400054c0: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
400054c4: 9f c0 40 00 call %g1
400054c8: 90 10 00 1d mov %i5, %o0
400054cc: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
400054d0: c2 07 20 08 ld [ %i4 + 8 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
400054d4: 05 10 00 77 sethi %hi(0x4001dc00), %g2
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
400054d8: c2 00 40 00 ld [ %g1 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
400054dc: 84 10 a1 ec or %g2, 0x1ec, %g2
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
400054e0: c2 27 60 cc st %g1, [ %i5 + 0xcc ]
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
400054e4: 83 28 60 05 sll %g1, 5, %g1
400054e8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
400054ec: 80 a0 60 00 cmp %g1, 0
400054f0: 02 80 00 16 be 40005548 <rtems_termios_ioctl+0x48c>
400054f4: c0 27 60 d0 clr [ %i5 + 0xd0 ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
400054f8: 9f c0 40 00 call %g1
400054fc: 90 10 00 1d mov %i5, %o0
40005500: 10 80 00 12 b 40005548 <rtems_termios_ioctl+0x48c>
40005504: b0 10 00 08 mov %o0, %i0
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
40005508: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
4000550c: 10 80 00 0f b 40005548 <rtems_termios_ioctl+0x48c>
40005510: c4 20 40 00 st %g2, [ %g1 ]
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
40005514: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
40005518: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
4000551c: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
40005520: 3c 80 00 05 bpos,a 40005534 <rtems_termios_ioctl+0x478> <== NOT EXECUTED
40005524: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
40005528: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
4000552c: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
40005530: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
40005534: c6 07 60 24 ld [ %i5 + 0x24 ], %g3 <== NOT EXECUTED
40005538: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
4000553c: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
40005540: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
40005544: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
40005548: 40 00 06 d3 call 40007094 <rtems_semaphore_release>
4000554c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
40005550: 81 c7 e0 08 ret
40005554: 81 e8 00 00 restore
40004a70 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
40004a70: 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(
40004a74: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004a78: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001e0b0 <rtems_termios_ttyMutex>
40004a7c: 92 10 20 00 clr %o1
40004a80: 40 00 09 3c call 40006f70 <rtems_semaphore_obtain>
40004a84: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40004a88: b8 92 20 00 orcc %o0, 0, %i4
40004a8c: 12 80 01 09 bne 40004eb0 <rtems_termios_open+0x440> <== NEVER TAKEN
40004a90: 03 10 00 78 sethi %hi(0x4001e000), %g1
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40004a94: e0 00 60 b8 ld [ %g1 + 0xb8 ], %l0 ! 4001e0b8 <rtems_termios_ttyHead>
40004a98: 10 80 00 0a b 40004ac0 <rtems_termios_open+0x50>
40004a9c: ba 10 00 10 mov %l0, %i5
if ((tty->major == major) && (tty->minor == minor))
40004aa0: 80 a0 40 18 cmp %g1, %i0
40004aa4: 32 80 00 07 bne,a 40004ac0 <rtems_termios_open+0x50>
40004aa8: fa 07 40 00 ld [ %i5 ], %i5
40004aac: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40004ab0: 80 a0 40 19 cmp %g1, %i1
40004ab4: 22 80 00 d0 be,a 40004df4 <rtems_termios_open+0x384> <== ALWAYS TAKEN
40004ab8: c2 06 80 00 ld [ %i2 ], %g1
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40004abc: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
40004ac0: 80 a7 60 00 cmp %i5, 0
40004ac4: 32 bf ff f7 bne,a 40004aa0 <rtems_termios_open+0x30>
40004ac8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40004acc: 10 80 00 f2 b 40004e94 <rtems_termios_open+0x424>
40004ad0: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
40004ad4: c2 00 63 1c ld [ %g1 + 0x31c ], %g1
40004ad8: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
40004adc: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
40004ae0: 7f ff fa 0f call 4000331c <malloc>
40004ae4: 01 00 00 00 nop
40004ae8: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
40004aec: 80 a2 20 00 cmp %o0, 0
40004af0: 02 80 00 16 be 40004b48 <rtems_termios_open+0xd8>
40004af4: a2 10 00 08 mov %o0, %l1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
40004af8: 03 10 00 75 sethi %hi(0x4001d400), %g1
40004afc: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 4001d720 <rtems_termios_raw_output_size>
40004b00: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
40004b04: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
40004b08: 7f ff fa 05 call 4000331c <malloc>
40004b0c: 01 00 00 00 nop
40004b10: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
40004b14: 80 a2 20 00 cmp %o0, 0
40004b18: 02 80 00 0a be 40004b40 <rtems_termios_open+0xd0>
40004b1c: a4 10 00 08 mov %o0, %l2
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
40004b20: 03 10 00 75 sethi %hi(0x4001d400), %g1
40004b24: 7f ff f9 fe call 4000331c <malloc>
40004b28: d0 00 63 24 ld [ %g1 + 0x324 ], %o0 ! 4001d724 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
40004b2c: 80 a2 20 00 cmp %o0, 0
40004b30: 12 80 00 0e bne 40004b68 <rtems_termios_open+0xf8>
40004b34: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
40004b38: 7f ff f9 25 call 40002fcc <free>
40004b3c: 90 10 00 12 mov %l2, %o0
free((void *)(tty->rawInBuf.theBuf));
40004b40: 7f ff f9 23 call 40002fcc <free>
40004b44: 90 10 00 11 mov %l1, %o0
free(tty);
40004b48: 7f ff f9 21 call 40002fcc <free>
40004b4c: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
40004b50: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004b54: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001e0b0 <rtems_termios_ttyMutex>
40004b58: 40 00 09 4f call 40007094 <rtems_semaphore_release>
40004b5c: b8 10 20 1a mov 0x1a, %i4
return RTEMS_NO_MEMORY;
40004b60: 81 c7 e0 08 ret
40004b64: 91 e8 00 1c restore %g0, %i4, %o0
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
40004b68: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
40004b6c: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
40004b70: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
40004b74: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
40004b78: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
40004b7c: e0 27 40 00 st %l0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
40004b80: 80 a4 20 00 cmp %l0, 0
40004b84: 02 80 00 03 be 40004b90 <rtems_termios_open+0x120>
40004b88: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
40004b8c: fa 24 20 04 st %i5, [ %l0 + 4 ]
rtems_termios_ttyHead = tty;
40004b90: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004b94: fa 20 60 b8 st %i5, [ %g1 + 0xb8 ] ! 4001e0b8 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
40004b98: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004b9c: c4 00 60 b4 ld [ %g1 + 0xb4 ], %g2 ! 4001e0b4 <rtems_termios_ttyTail>
40004ba0: 80 a0 a0 00 cmp %g2, 0
40004ba4: 22 80 00 02 be,a 40004bac <rtems_termios_open+0x13c>
40004ba8: fa 20 60 b4 st %i5, [ %g1 + 0xb4 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
40004bac: 21 10 00 75 sethi %hi(0x4001d400), %l0
40004bb0: d0 4c 23 28 ldsb [ %l0 + 0x328 ], %o0 ! 4001d728 <c.6875>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40004bb4: 03 15 14 9a sethi %hi(0x54526800), %g1
40004bb8: 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;
40004bbc: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
40004bc0: f0 27 60 0c st %i0, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40004bc4: 90 12 00 01 or %o0, %g1, %o0
40004bc8: 92 10 20 01 mov 1, %o1
40004bcc: 94 10 20 54 mov 0x54, %o2
40004bd0: 96 10 20 00 clr %o3
40004bd4: 40 00 08 4a call 40006cfc <rtems_semaphore_create>
40004bd8: 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)
40004bdc: 80 a2 20 00 cmp %o0, 0
40004be0: 22 80 00 03 be,a 40004bec <rtems_termios_open+0x17c>
40004be4: d0 4c 23 28 ldsb [ %l0 + 0x328 ], %o0
40004be8: 30 80 00 a4 b,a 40004e78 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
40004bec: 03 15 14 9b sethi %hi(0x54526c00), %g1
40004bf0: 82 10 63 00 or %g1, 0x300, %g1 ! 54526f00 <RAM_END+0x14126f00>
40004bf4: 92 10 20 01 mov 1, %o1
40004bf8: 90 12 00 01 or %o0, %g1, %o0
40004bfc: 94 10 20 54 mov 0x54, %o2
40004c00: 96 10 20 00 clr %o3
40004c04: 40 00 08 3e call 40006cfc <rtems_semaphore_create>
40004c08: 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)
40004c0c: 80 a2 20 00 cmp %o0, 0
40004c10: 22 80 00 03 be,a 40004c1c <rtems_termios_open+0x1ac>
40004c14: d0 4c 23 28 ldsb [ %l0 + 0x328 ], %o0
40004c18: 30 80 00 98 b,a 40004e78 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
40004c1c: 03 15 14 9e sethi %hi(0x54527800), %g1
40004c20: 92 10 20 00 clr %o1
40004c24: 90 12 00 01 or %o0, %g1, %o0
40004c28: 94 10 20 20 mov 0x20, %o2
40004c2c: 96 10 20 00 clr %o3
40004c30: 40 00 08 33 call 40006cfc <rtems_semaphore_create>
40004c34: 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)
40004c38: 80 a2 20 00 cmp %o0, 0
40004c3c: 22 80 00 03 be,a 40004c48 <rtems_termios_open+0x1d8>
40004c40: c0 27 60 94 clr [ %i5 + 0x94 ]
40004c44: 30 80 00 8d b,a 40004e78 <rtems_termios_open+0x408>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
40004c48: 90 07 60 98 add %i5, 0x98, %o0
40004c4c: 92 10 00 1b mov %i3, %o1
40004c50: 40 00 29 d8 call 4000f3b0 <memcpy>
40004c54: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004c58: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004c5c: 80 a0 60 02 cmp %g1, 2
40004c60: 32 80 00 1b bne,a 40004ccc <rtems_termios_open+0x25c>
40004c64: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
40004c68: d0 4c 23 28 ldsb [ %l0 + 0x328 ], %o0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
40004c6c: 03 15 1e 15 sethi %hi(0x54785400), %g1
40004c70: 92 10 20 0a mov 0xa, %o1
40004c74: 90 12 00 01 or %o0, %g1, %o0
40004c78: 94 10 24 00 mov 0x400, %o2
40004c7c: 96 10 25 00 mov 0x500, %o3
40004c80: 98 10 20 00 clr %o4
40004c84: 40 00 09 46 call 4000719c <rtems_task_create>
40004c88: 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)
40004c8c: 80 a2 20 00 cmp %o0, 0
40004c90: 22 80 00 03 be,a 40004c9c <rtems_termios_open+0x22c> <== ALWAYS TAKEN
40004c94: d0 4c 23 28 ldsb [ %l0 + 0x328 ], %o0
40004c98: 30 80 00 78 b,a 40004e78 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
40004c9c: 03 14 9e 15 sethi %hi(0x52785400), %g1
40004ca0: 92 10 20 09 mov 9, %o1
40004ca4: 90 12 00 01 or %o0, %g1, %o0
40004ca8: 94 10 24 00 mov 0x400, %o2
40004cac: 96 10 25 00 mov 0x500, %o3
40004cb0: 98 10 20 00 clr %o4
40004cb4: 40 00 09 3a call 4000719c <rtems_task_create>
40004cb8: 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)
40004cbc: 80 a2 20 00 cmp %o0, 0
40004cc0: 22 80 00 03 be,a 40004ccc <rtems_termios_open+0x25c> <== ALWAYS TAKEN
40004cc4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40004cc8: 30 80 00 6c b,a 40004e78 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
40004ccc: 80 a0 60 00 cmp %g1, 0
40004cd0: 02 80 00 07 be 40004cec <rtems_termios_open+0x27c>
40004cd4: 03 10 00 75 sethi %hi(0x4001d400), %g1
40004cd8: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004cdc: 80 a0 60 02 cmp %g1, 2
40004ce0: 12 80 00 0f bne 40004d1c <rtems_termios_open+0x2ac>
40004ce4: 03 00 00 09 sethi %hi(0x2400), %g1
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
40004ce8: 03 10 00 75 sethi %hi(0x4001d400), %g1
40004cec: d0 48 63 28 ldsb [ %g1 + 0x328 ], %o0 ! 4001d728 <c.6875>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
40004cf0: 03 15 14 9c sethi %hi(0x54527000), %g1
40004cf4: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x14127200>
40004cf8: 92 10 20 00 clr %o1
40004cfc: 90 12 00 01 or %o0, %g1, %o0
40004d00: 94 10 20 24 mov 0x24, %o2
40004d04: 96 10 20 00 clr %o3
40004d08: 40 00 07 fd call 40006cfc <rtems_semaphore_create>
40004d0c: 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)
40004d10: 80 a2 20 00 cmp %o0, 0
40004d14: 12 80 00 59 bne 40004e78 <rtems_termios_open+0x408> <== NEVER TAKEN
40004d18: 03 00 00 09 sethi %hi(0x2400), %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40004d1c: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
40004d20: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
40004d24: 03 00 00 06 sethi %hi(0x1800), %g1
40004d28: 82 10 60 05 or %g1, 5, %g1 ! 1805 <PROM_START+0x1805>
40004d2c: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
40004d30: 82 10 28 bd mov 0x8bd, %g1
40004d34: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
tty->termios.c_lflag =
40004d38: 03 00 00 20 sethi %hi(0x8000), %g1
40004d3c: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
40004d40: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
40004d44: 82 10 20 03 mov 3, %g1
40004d48: c2 2f 60 41 stb %g1, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
40004d4c: 82 10 20 1c mov 0x1c, %g1
40004d50: c2 2f 60 42 stb %g1, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
40004d54: 82 10 20 7f mov 0x7f, %g1
40004d58: c2 2f 60 43 stb %g1, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
40004d5c: 82 10 20 15 mov 0x15, %g1
40004d60: c2 2f 60 44 stb %g1, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
40004d64: 82 10 20 04 mov 4, %g1
40004d68: c2 2f 60 45 stb %g1, [ %i5 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
40004d6c: 82 10 20 11 mov 0x11, %g1
40004d70: c2 2f 60 49 stb %g1, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
40004d74: 82 10 20 13 mov 0x13, %g1
40004d78: c2 2f 60 4a stb %g1, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
40004d7c: 82 10 20 1a mov 0x1a, %g1
40004d80: c2 2f 60 4b stb %g1, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
40004d84: 82 10 20 12 mov 0x12, %g1
40004d88: c2 2f 60 4d stb %g1, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
40004d8c: 82 10 20 0f mov 0xf, %g1
40004d90: c2 2f 60 4e stb %g1, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
40004d94: 82 10 20 17 mov 0x17, %g1
40004d98: c2 2f 60 4f stb %g1, [ %i5 + 0x4f ]
tty->termios.c_cc[VLNEXT] = '\026';
40004d9c: 82 10 20 16 mov 0x16, %g1
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
40004da0: c0 27 60 b8 clr [ %i5 + 0xb8 ]
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
40004da4: c2 2f 60 50 stb %g1, [ %i5 + 0x50 ]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
40004da8: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
40004dac: c0 2f 60 4c clrb [ %i5 + 0x4c ]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
40004db0: 83 30 60 01 srl %g1, 1, %g1
40004db4: c2 27 60 bc st %g1, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
40004db8: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
40004dbc: c0 2f 60 51 clrb [ %i5 + 0x51 ]
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
40004dc0: 85 28 60 01 sll %g1, 1, %g2
40004dc4: 82 00 80 01 add %g2, %g1, %g1
40004dc8: 83 30 60 02 srl %g1, 2, %g1
40004dcc: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
40004dd0: 03 10 00 75 sethi %hi(0x4001d400), %g1
40004dd4: c4 08 63 28 ldub [ %g1 + 0x328 ], %g2 ! 4001d728 <c.6875>
40004dd8: c6 48 63 28 ldsb [ %g1 + 0x328 ], %g3
40004ddc: 80 a0 e0 7a cmp %g3, 0x7a
40004de0: 12 80 00 03 bne 40004dec <rtems_termios_open+0x37c>
40004de4: 84 00 a0 01 inc %g2
c = 'a';
40004de8: 84 10 20 61 mov 0x61, %g2
40004dec: c4 28 63 28 stb %g2, [ %g1 + 0x328 ]
}
args->iop->data1 = tty;
40004df0: c2 06 80 00 ld [ %i2 ], %g1
40004df4: fa 20 60 30 st %i5, [ %g1 + 0x30 ]
if (!tty->refcount++) {
40004df8: c2 07 60 08 ld [ %i5 + 8 ], %g1
40004dfc: 84 00 60 01 add %g1, 1, %g2
40004e00: 80 a0 60 00 cmp %g1, 0
40004e04: 12 80 00 1f bne 40004e80 <rtems_termios_open+0x410>
40004e08: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
40004e0c: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40004e10: 80 a0 60 00 cmp %g1, 0
40004e14: 02 80 00 05 be 40004e28 <rtems_termios_open+0x3b8> <== ALWAYS TAKEN
40004e18: 90 10 00 18 mov %i0, %o0
(*tty->device.firstOpen)(major, minor, arg);
40004e1c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40004e20: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004e24: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004e28: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004e2c: 80 a0 60 02 cmp %g1, 2
40004e30: 12 80 00 15 bne 40004e84 <rtems_termios_open+0x414>
40004e34: 03 10 00 78 sethi %hi(0x4001e000), %g1
sc = rtems_task_start(
40004e38: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
40004e3c: 13 10 00 19 sethi %hi(0x40006400), %o1
40004e40: 94 10 00 1d mov %i5, %o2
40004e44: 40 00 09 7b call 40007430 <rtems_task_start>
40004e48: 92 12 60 24 or %o1, 0x24, %o1
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40004e4c: 80 a2 20 00 cmp %o0, 0
40004e50: 22 80 00 03 be,a 40004e5c <rtems_termios_open+0x3ec> <== ALWAYS TAKEN
40004e54: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
40004e58: 30 80 00 08 b,a 40004e78 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
40004e5c: 13 10 00 12 sethi %hi(0x40004800), %o1
40004e60: 94 10 00 1d mov %i5, %o2
40004e64: 40 00 09 73 call 40007430 <rtems_task_start>
40004e68: 92 12 61 9c or %o1, 0x19c, %o1
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40004e6c: 80 a2 20 00 cmp %o0, 0
40004e70: 02 80 00 05 be 40004e84 <rtems_termios_open+0x414> <== ALWAYS TAKEN
40004e74: 03 10 00 78 sethi %hi(0x4001e000), %g1
rtems_fatal_error_occurred (sc);
40004e78: 40 00 0a 1b call 400076e4 <rtems_fatal_error_occurred>
40004e7c: 01 00 00 00 nop
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40004e80: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004e84: 40 00 08 84 call 40007094 <rtems_semaphore_release>
40004e88: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001e0b0 <rtems_termios_ttyMutex>
return RTEMS_SUCCESSFUL;
40004e8c: 81 c7 e0 08 ret
40004e90: 91 e8 00 1c restore %g0, %i4, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40004e94: 7f ff f7 9b call 40002d00 <calloc>
40004e98: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
40004e9c: ba 92 20 00 orcc %o0, 0, %i5
40004ea0: 32 bf ff 0d bne,a 40004ad4 <rtems_termios_open+0x64>
40004ea4: 03 10 00 75 sethi %hi(0x4001d400), %g1
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
free((void *)(tty->rawInBuf.theBuf));
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
40004ea8: 10 bf ff 2b b 40004b54 <rtems_termios_open+0xe4>
40004eac: 03 10 00 78 sethi %hi(0x4001e000), %g1
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
return RTEMS_SUCCESSFUL;
}
40004eb0: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
40004eb4: 81 c7 e0 08 ret <== NOT EXECUTED
40004eb8: 81 e8 00 00 restore <== NOT EXECUTED
40005558 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
40005558: 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) {
4000555c: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
40005560: 80 a0 60 00 cmp %g1, 0
40005564: 12 80 00 08 bne 40005584 <rtems_termios_puts+0x2c>
40005568: 92 10 00 18 mov %i0, %o1
(*tty->device.write)(tty->minor, buf, len);
4000556c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
40005570: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
40005574: 9f c0 40 00 call %g1
40005578: 94 10 00 19 mov %i1, %o2
return;
4000557c: 81 c7 e0 08 ret
40005580: 81 e8 00 00 restore
}
newHead = tty->rawOutBuf.Head;
40005584: fa 06 a0 80 ld [ %i2 + 0x80 ], %i5
/*
* Send characters to device-specific code
*/
void
rtems_termios_puts (
40005588: b2 06 00 19 add %i0, %i1, %i1
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
4000558c: 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) {
40005590: 10 80 00 36 b 40005668 <rtems_termios_puts+0x110>
40005594: a0 10 20 01 mov 1, %l0
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
40005598: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
4000559c: 40 00 4a 4f call 40017ed8 <.urem>
400055a0: 90 07 60 01 add %i5, 1, %o0
400055a4: 10 80 00 0d b 400055d8 <rtems_termios_puts+0x80>
400055a8: ba 10 00 08 mov %o0, %i5
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
400055ac: 7f ff f2 c3 call 400020b8 <sparc_enable_interrupts>
400055b0: 90 10 00 1c mov %i4, %o0
sc = rtems_semaphore_obtain(
400055b4: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
400055b8: 92 10 20 00 clr %o1
400055bc: 40 00 06 6d call 40006f70 <rtems_semaphore_obtain>
400055c0: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
400055c4: 80 a2 20 00 cmp %o0, 0
400055c8: 02 80 00 04 be 400055d8 <rtems_termios_puts+0x80> <== ALWAYS TAKEN
400055cc: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
400055d0: 40 00 08 45 call 400076e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
400055d4: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
400055d8: 7f ff f2 b4 call 400020a8 <sparc_disable_interrupts>
400055dc: 01 00 00 00 nop
400055e0: b8 10 00 08 mov %o0, %i4
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
400055e4: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
400055e8: 80 a7 40 01 cmp %i5, %g1
400055ec: 22 bf ff f0 be,a 400055ac <rtems_termios_puts+0x54>
400055f0: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
400055f4: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
400055f8: c6 0e 00 00 ldub [ %i0 ], %g3
400055fc: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
40005600: b0 06 20 01 inc %i0
40005604: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
40005608: 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;
4000560c: fa 26 a0 80 st %i5, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
40005610: 80 a0 60 00 cmp %g1, 0
40005614: 12 80 00 13 bne 40005660 <rtems_termios_puts+0x108>
40005618: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
4000561c: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
40005620: 80 88 60 10 btst 0x10, %g1
40005624: 12 80 00 0b bne 40005650 <rtems_termios_puts+0xf8> <== NEVER TAKEN
40005628: 01 00 00 00 nop
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
4000562c: 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)(
40005630: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
40005634: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
40005638: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
4000563c: 92 02 40 02 add %o1, %g2, %o1
40005640: 9f c0 40 00 call %g1
40005644: 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;
40005648: 10 80 00 06 b 40005660 <rtems_termios_puts+0x108>
4000564c: e0 26 a0 94 st %l0, [ %i2 + 0x94 ]
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
40005650: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
40005654: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
40005658: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
4000565c: e0 26 a0 94 st %l0, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
40005660: 7f ff f2 96 call 400020b8 <sparc_enable_interrupts>
40005664: 90 10 00 1c mov %i4, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
40005668: 80 a6 00 19 cmp %i0, %i1
4000566c: 12 bf ff cb bne 40005598 <rtems_termios_puts+0x40>
40005670: 01 00 00 00 nop
40005674: 81 c7 e0 08 ret
40005678: 81 e8 00 00 restore
40005d6c <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40005d6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005d70: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
40005d74: f4 1e 20 10 ldd [ %i0 + 0x10 ], %i2
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005d78: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40005d7c: b8 10 00 18 mov %i0, %i4
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005d80: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
40005d84: 92 10 20 00 clr %o1
40005d88: 40 00 04 7a call 40006f70 <rtems_semaphore_obtain>
40005d8c: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40005d90: b0 92 20 00 orcc %o0, 0, %i0
40005d94: 12 80 00 dd bne 40006108 <rtems_termios_read+0x39c> <== NEVER TAKEN
40005d98: 03 10 00 77 sethi %hi(0x4001dc00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
40005d9c: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40005da0: 85 28 a0 05 sll %g2, 5, %g2
40005da4: 82 10 61 ec or %g1, 0x1ec, %g1
40005da8: 82 00 40 02 add %g1, %g2, %g1
40005dac: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005db0: 80 a0 60 00 cmp %g1, 0
40005db4: 02 80 00 06 be 40005dcc <rtems_termios_read+0x60>
40005db8: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
40005dbc: 9f c0 40 00 call %g1
40005dc0: 92 10 00 1c mov %i4, %o1
40005dc4: 10 80 00 ce b 400060fc <rtems_termios_read+0x390>
40005dc8: b0 10 00 08 mov %o0, %i0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
40005dcc: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40005dd0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40005dd4: 80 a0 80 01 cmp %g2, %g1
40005dd8: 12 80 00 bf bne 400060d4 <rtems_termios_read+0x368> <== NEVER TAKEN
40005ddc: 80 a6 e0 00 cmp %i3, 0
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
40005de0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
40005de4: c0 27 60 20 clr [ %i5 + 0x20 ]
tty->read_start_column = tty->column;
40005de8: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
if (tty->device.pollRead != NULL &&
40005dec: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005df0: 80 a0 60 00 cmp %g1, 0
40005df4: 02 80 00 4c be 40005f24 <rtems_termios_read+0x1b8>
40005df8: c0 27 60 24 clr [ %i5 + 0x24 ]
40005dfc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005e00: 80 a0 60 00 cmp %g1, 0
40005e04: 32 80 00 49 bne,a 40005f28 <rtems_termios_read+0x1bc>
40005e08: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
40005e0c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40005e10: 80 88 60 02 btst 2, %g1
40005e14: 02 80 00 13 be 40005e60 <rtems_termios_read+0xf4>
40005e18: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40005e1c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005e20: 9f c0 40 00 call %g1
40005e24: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
40005e28: 80 a2 20 00 cmp %o0, 0
40005e2c: 16 80 00 06 bge 40005e44 <rtems_termios_read+0xd8>
40005e30: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
40005e34: 40 00 05 9b call 400074a0 <rtems_task_wake_after>
40005e38: 90 10 20 01 mov 1, %o0
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40005e3c: 10 bf ff f9 b 40005e20 <rtems_termios_read+0xb4>
40005e40: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
40005e44: 7f ff ff 88 call 40005c64 <siproc>
40005e48: 92 10 00 1d mov %i5, %o1
40005e4c: 80 a2 20 00 cmp %o0, 0
40005e50: 22 bf ff f4 be,a 40005e20 <rtems_termios_read+0xb4>
40005e54: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
40005e58: 10 80 00 9f b 400060d4 <rtems_termios_read+0x368>
40005e5c: 80 a6 e0 00 cmp %i3, 0
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
40005e60: 40 00 02 92 call 400068a8 <rtems_clock_get_ticks_since_boot>
40005e64: 01 00 00 00 nop
40005e68: b2 10 00 08 mov %o0, %i1
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40005e6c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005e70: 9f c0 40 00 call %g1
40005e74: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
40005e78: 80 a2 20 00 cmp %o0, 0
40005e7c: 36 80 00 1c bge,a 40005eec <rtems_termios_read+0x180>
40005e80: 90 0a 20 ff and %o0, 0xff, %o0
if (tty->termios.c_cc[VMIN]) {
40005e84: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
40005e88: 80 a0 60 00 cmp %g1, 0
40005e8c: 02 80 00 0d be 40005ec0 <rtems_termios_read+0x154>
40005e90: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
40005e94: 80 88 60 ff btst 0xff, %g1
40005e98: 32 80 00 06 bne,a 40005eb0 <rtems_termios_read+0x144> <== ALWAYS TAKEN
40005e9c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
40005ea0: 40 00 05 80 call 400074a0 <rtems_task_wake_after>
40005ea4: 90 10 20 01 mov 1, %o0
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40005ea8: 10 bf ff f2 b 40005e70 <rtems_termios_read+0x104>
40005eac: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
if (tty->termios.c_cc[VTIME] && tty->ccount) {
40005eb0: 80 a0 60 00 cmp %g1, 0
40005eb4: 02 bf ff fb be 40005ea0 <rtems_termios_read+0x134>
40005eb8: 01 00 00 00 nop
40005ebc: 30 80 00 04 b,a 40005ecc <rtems_termios_read+0x160>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
40005ec0: 80 88 60 ff btst 0xff, %g1
40005ec4: 02 80 00 84 be 400060d4 <rtems_termios_read+0x368> <== NEVER TAKEN
40005ec8: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
40005ecc: 40 00 02 77 call 400068a8 <rtems_clock_get_ticks_since_boot>
40005ed0: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
40005ed4: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
40005ed8: 90 22 00 19 sub %o0, %i1, %o0
40005edc: 80 a2 00 01 cmp %o0, %g1
40005ee0: 08 bf ff f0 bleu 40005ea0 <rtems_termios_read+0x134>
40005ee4: 80 a6 e0 00 cmp %i3, 0
40005ee8: 30 80 00 7b b,a 400060d4 <rtems_termios_read+0x368>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
40005eec: 7f ff ff 5e call 40005c64 <siproc>
40005ef0: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
40005ef4: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
40005ef8: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40005efc: 80 a0 80 01 cmp %g2, %g1
40005f00: 16 80 00 74 bge 400060d0 <rtems_termios_read+0x364>
40005f04: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
40005f08: 22 bf ff da be,a 40005e70 <rtems_termios_read+0x104> <== NEVER TAKEN
40005f0c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40005f10: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
40005f14: 80 a0 60 00 cmp %g1, 0
40005f18: 22 bf ff d6 be,a 40005e70 <rtems_termios_read+0x104> <== NEVER TAKEN
40005f1c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40005f20: 30 bf ff d0 b,a 40005e60 <rtems_termios_read+0xf4>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
40005f24: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
rtems_status_code sc;
int wait = 1;
40005f28: 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))) {
40005f2c: 23 10 00 75 sethi %hi(0x4001d400), %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);
40005f30: 10 80 00 4b b 4000605c <rtems_termios_read+0x2f0>
40005f34: a4 07 60 49 add %i5, 0x49, %l2
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
40005f38: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
40005f3c: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
40005f40: 40 00 47 e6 call 40017ed8 <.urem>
40005f44: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
40005f48: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
40005f4c: e0 08 40 08 ldub [ %g1 + %o0 ], %l0
tty->rawInBuf.Head = newHead;
40005f50: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
40005f54: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
40005f58: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
40005f5c: 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)
40005f60: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
40005f64: 40 00 47 dd call 40017ed8 <.urem>
40005f68: 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)
40005f6c: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
40005f70: 80 a2 00 01 cmp %o0, %g1
40005f74: 3a 80 00 27 bcc,a 40006010 <rtems_termios_read+0x2a4> <== NEVER TAKEN
40005f78: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
40005f7c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005f80: 82 08 7f fe and %g1, -2, %g1
40005f84: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
40005f88: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005f8c: 82 08 62 02 and %g1, 0x202, %g1
40005f90: 80 a0 62 02 cmp %g1, 0x202
40005f94: 12 80 00 11 bne 40005fd8 <rtems_termios_read+0x26c> <== ALWAYS TAKEN
40005f98: 01 00 00 00 nop
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
40005f9c: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
40005fa0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005fa4: 22 80 00 07 be,a 40005fc0 <rtems_termios_read+0x254> <== NOT EXECUTED
40005fa8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
40005fac: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40005fb0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40005fb4: 02 80 00 09 be 40005fd8 <rtems_termios_read+0x26c> <== NOT EXECUTED
40005fb8: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
40005fbc: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40005fc0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
40005fc4: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
40005fc8: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005fcc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40005fd0: 10 80 00 10 b 40006010 <rtems_termios_read+0x2a4> <== NOT EXECUTED
40005fd4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
40005fd8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005fdc: 80 88 61 00 btst 0x100, %g1
40005fe0: 22 80 00 0c be,a 40006010 <rtems_termios_read+0x2a4> <== ALWAYS TAKEN
40005fe4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
40005fe8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40005fec: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
40005ff0: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
40005ff4: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
40005ff8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005ffc: 22 80 00 05 be,a 40006010 <rtems_termios_read+0x2a4> <== NOT EXECUTED
40006000: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
40006004: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006008: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
4000600c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
40006010: 92 10 00 1d mov %i5, %o1
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40006014: 80 88 60 02 btst 2, %g1
40006018: 02 80 00 09 be 4000603c <rtems_termios_read+0x2d0> <== NEVER TAKEN
4000601c: 90 0c 20 ff and %l0, 0xff, %o0
if (siproc (c, tty))
40006020: 7f ff ff 11 call 40005c64 <siproc>
40006024: 01 00 00 00 nop
40006028: 80 a2 20 00 cmp %o0, 0
4000602c: 22 80 00 0c be,a 4000605c <rtems_termios_read+0x2f0>
40006030: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
wait = 0;
40006034: 10 80 00 09 b 40006058 <rtems_termios_read+0x2ec>
40006038: b2 10 20 00 clr %i1
} else {
siproc (c, tty);
4000603c: 7f ff ff 0a call 40005c64 <siproc> <== NOT EXECUTED
40006040: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
40006044: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
40006048: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
4000604c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40006050: 36 80 00 02 bge,a 40006058 <rtems_termios_read+0x2ec> <== NOT EXECUTED
40006054: b2 10 20 00 clr %i1 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
40006058: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4000605c: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
40006060: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
40006064: 80 a0 80 01 cmp %g2, %g1
40006068: 12 80 00 07 bne 40006084 <rtems_termios_read+0x318>
4000606c: c2 04 63 24 ld [ %l1 + 0x324 ], %g1
}
/*
* Wait for characters
*/
if ( wait ) {
40006070: 80 a6 60 00 cmp %i1, 0
40006074: 02 80 00 18 be 400060d4 <rtems_termios_read+0x368>
40006078: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
4000607c: 10 80 00 08 b 4000609c <rtems_termios_read+0x330>
40006080: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40006084: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
40006088: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4000608c: 80 a0 80 01 cmp %g2, %g1
40006090: 0a bf ff aa bcs 40005f38 <rtems_termios_read+0x1cc> <== ALWAYS TAKEN
40006094: 80 a6 60 00 cmp %i1, 0
40006098: 30 bf ff f7 b,a 40006074 <rtems_termios_read+0x308> <== NOT EXECUTED
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
4000609c: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
400060a0: 40 00 03 b4 call 40006f70 <rtems_semaphore_obtain>
400060a4: 94 10 00 10 mov %l0, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
400060a8: 80 a2 20 00 cmp %o0, 0
400060ac: 02 bf ff ec be 4000605c <rtems_termios_read+0x2f0> <== ALWAYS TAKEN
400060b0: 80 a6 e0 00 cmp %i3, 0
400060b4: 30 80 00 08 b,a 400060d4 <rtems_termios_read+0x368> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
400060b8: b6 06 ff ff add %i3, -1, %i3
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
400060bc: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
400060c0: 82 00 60 01 inc %g1
400060c4: c4 2e 80 00 stb %g2, [ %i2 ]
400060c8: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
400060cc: b4 06 a0 01 inc %i2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
400060d0: 80 a6 e0 00 cmp %i3, 0
400060d4: 22 80 00 08 be,a 400060f4 <rtems_termios_read+0x388>
400060d8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
400060dc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
400060e0: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
400060e4: 80 a0 40 02 cmp %g1, %g2
400060e8: 26 bf ff f4 bl,a 400060b8 <rtems_termios_read+0x34c>
400060ec: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
400060f0: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
400060f4: b6 20 40 1b sub %g1, %i3, %i3
400060f8: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
400060fc: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
40006100: 40 00 03 e5 call 40007094 <rtems_semaphore_release>
40006104: c0 27 60 e4 clr [ %i5 + 0xe4 ]
return sc;
}
40006108: 81 c7 e0 08 ret
4000610c: 81 e8 00 00 restore
400047b8 <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)
{
400047b8: 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))
400047bc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
400047c0: 82 08 64 03 and %g1, 0x403, %g1
400047c4: 80 a0 64 01 cmp %g1, 0x401
400047c8: 12 80 00 0f bne 40004804 <rtems_termios_refill_transmitter+0x4c><== ALWAYS TAKEN
400047cc: ba 10 00 18 mov %i0, %i5
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
400047d0: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
400047d4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
400047d8: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
400047dc: 9f c0 40 00 call %g1 <== NOT EXECUTED
400047e0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
400047e4: 7f ff f6 31 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
400047e8: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
400047ec: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
400047f0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400047f4: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
400047f8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400047fc: 10 80 00 12 b 40004844 <rtems_termios_refill_transmitter+0x8c><== NOT EXECUTED
40004800: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
40004804: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40004808: 82 08 60 03 and %g1, 3, %g1
4000480c: 80 a0 60 02 cmp %g1, 2
40004810: 12 80 00 12 bne 40004858 <rtems_termios_refill_transmitter+0xa0><== ALWAYS TAKEN
40004814: 92 06 20 49 add %i0, 0x49, %o1
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
40004818: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
4000481c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40004820: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004824: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
40004828: 7f ff f6 20 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
4000482c: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40004830: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
40004834: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40004838: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
4000483c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40004840: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
40004844: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40004848: 7f ff f6 1c call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
4000484c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40004850: 81 c7 e0 08 ret
40004854: 81 e8 00 00 restore
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
40004858: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
4000485c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40004860: 80 a0 80 01 cmp %g2, %g1
40004864: 12 80 00 0a bne 4000488c <rtems_termios_refill_transmitter+0xd4>
40004868: 01 00 00 00 nop
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
4000486c: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
40004870: 80 a0 60 02 cmp %g1, 2
40004874: 12 bf ff f7 bne 40004850 <rtems_termios_refill_transmitter+0x98><== ALWAYS TAKEN
40004878: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
4000487c: 40 00 0a 06 call 40007094 <rtems_semaphore_release> <== NOT EXECUTED
40004880: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
40004884: 81 c7 e0 08 ret <== NOT EXECUTED
40004888: 81 e8 00 00 restore <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
4000488c: 7f ff f6 07 call 400020a8 <sparc_disable_interrupts>
40004890: 01 00 00 00 nop
len = tty->t_dqlen;
40004894: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
40004898: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
4000489c: 7f ff f6 07 call 400020b8 <sparc_enable_interrupts>
400048a0: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
400048a4: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
400048a8: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
400048ac: 40 00 4d 8b call 40017ed8 <.urem>
400048b0: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
400048b4: 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;
400048b8: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
400048bc: 80 a0 60 02 cmp %g1, 2
400048c0: 12 80 00 04 bne 400048d0 <rtems_termios_refill_transmitter+0x118>
400048c4: b8 10 00 08 mov %o0, %i4
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
400048c8: 40 00 09 f3 call 40007094 <rtems_semaphore_release>
400048cc: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
}
if (newTail == tty->rawOutBuf.Head) {
400048d0: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
400048d4: 80 a7 00 01 cmp %i4, %g1
400048d8: 12 80 00 0b bne 40004904 <rtems_termios_refill_transmitter+0x14c>
400048dc: 01 00 00 00 nop
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
400048e0: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
400048e4: 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) {
400048e8: 80 a0 60 00 cmp %g1, 0
400048ec: 02 80 00 29 be 40004990 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
400048f0: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
400048f4: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
400048f8: 9f c0 40 00 call %g1 <== NOT EXECUTED
400048fc: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
40004900: 30 80 00 24 b,a 40004990 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
40004904: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40004908: 82 08 62 10 and %g1, 0x210, %g1
4000490c: 80 a0 62 10 cmp %g1, 0x210
40004910: 12 80 00 0c bne 40004940 <rtems_termios_refill_transmitter+0x188><== ALWAYS TAKEN
40004914: 01 00 00 00 nop
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
40004918: 7f ff f5 e4 call 400020a8 <sparc_disable_interrupts> <== NOT EXECUTED
4000491c: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
40004920: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40004924: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
40004928: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
4000492c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40004930: c2 27 60 94 st %g1, [ %i5 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40004934: 7f ff f5 e1 call 400020b8 <sparc_enable_interrupts> <== NOT EXECUTED
40004938: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000493c: 30 80 00 15 b,a 40004990 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
40004940: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40004944: 80 a7 00 01 cmp %i4, %g1
40004948: 08 80 00 04 bleu 40004958 <rtems_termios_refill_transmitter+0x1a0>
4000494c: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
40004950: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
40004954: 30 80 00 02 b,a 4000495c <rtems_termios_refill_transmitter+0x1a4>
else
nToSend = tty->rawOutBuf.Head - newTail;
40004958: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
4000495c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40004960: 80 88 66 00 btst 0x600, %g1
40004964: 02 80 00 03 be 40004970 <rtems_termios_refill_transmitter+0x1b8>
40004968: b0 26 00 1c sub %i0, %i4, %i0
nToSend = 1;
4000496c: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
40004970: 82 10 20 01 mov 1, %g1
(*tty->device.write)(
40004974: d2 07 60 7c ld [ %i5 + 0x7c ], %o1
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
40004978: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
(*tty->device.write)(
4000497c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
40004980: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
40004984: 92 02 40 1c add %o1, %i4, %o1
40004988: 9f c0 40 00 call %g1
4000498c: 94 10 00 18 mov %i0, %o2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40004990: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
40004994: 81 c7 e0 08 ret
40004998: 81 e8 00 00 restore
40006424 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
40006424: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40006428: 90 10 20 03 mov 3, %o0
4000642c: 92 10 20 02 mov 2, %o1
40006430: 94 10 20 00 clr %o2
40006434: 40 00 01 40 call 40006934 <rtems_event_receive>
40006438: 96 07 bf fc add %fp, -4, %o3
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
4000643c: c2 07 bf fc ld [ %fp + -4 ], %g1
40006440: 80 88 60 01 btst 1, %g1
40006444: 22 80 00 06 be,a 4000645c <rtems_termios_rxdaemon+0x38> <== ALWAYS TAKEN
40006448: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
4000644c: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40006450: 40 00 03 9d call 400072c4 <rtems_task_delete> <== NOT EXECUTED
40006454: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
40006458: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
4000645c: 9f c0 40 00 call %g1
40006460: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
40006464: 80 a2 3f ff cmp %o0, -1
40006468: 22 bf ff f1 be,a 4000642c <rtems_termios_rxdaemon+0x8>
4000646c: 90 10 20 03 mov 3, %o0
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
40006470: d0 2f bf fb stb %o0, [ %fp + -5 ]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
40006474: 92 07 bf fb add %fp, -5, %o1
40006478: 90 10 00 18 mov %i0, %o0
4000647c: 7f ff ff 2a call 40006124 <rtems_termios_enqueue_raw_characters>
40006480: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40006484: 10 bf ff ea b 4000642c <rtems_termios_rxdaemon+0x8>
40006488: 90 10 20 03 mov 3, %o0
4000499c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
4000499c: 9d e3 bf 98 save %sp, -104, %sp
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
400049a0: 3b 10 00 77 sethi %hi(0x4001dc00), %i5
400049a4: ba 17 61 ec or %i5, 0x1ec, %i5 ! 4001ddec <rtems_termios_linesw>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400049a8: 90 10 20 03 mov 3, %o0
400049ac: 92 10 20 02 mov 2, %o1
400049b0: 94 10 20 00 clr %o2
400049b4: 40 00 07 e0 call 40006934 <rtems_event_receive>
400049b8: 96 07 bf fc add %fp, -4, %o3
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
400049bc: c2 07 bf fc ld [ %fp + -4 ], %g1
400049c0: 80 88 60 01 btst 1, %g1
400049c4: 22 80 00 06 be,a 400049dc <rtems_termios_txdaemon+0x40> <== ALWAYS TAKEN
400049c8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
400049cc: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
400049d0: 40 00 0a 3d call 400072c4 <rtems_task_delete> <== NOT EXECUTED
400049d4: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
400049d8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
400049dc: 83 28 60 05 sll %g1, 5, %g1
400049e0: 82 07 40 01 add %i5, %g1, %g1
400049e4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400049e8: 80 a0 60 00 cmp %g1, 0
400049ec: 02 80 00 04 be 400049fc <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
400049f0: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
400049f4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400049f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
400049fc: 7f ff ff 6f call 400047b8 <rtems_termios_refill_transmitter>
40004a00: 90 10 00 18 mov %i0, %o0
}
40004a04: 10 bf ff ea b 400049ac <rtems_termios_txdaemon+0x10>
40004a08: 90 10 20 03 mov 3, %o0
40005cac <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
40005cac: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005cb0: c2 06 00 00 ld [ %i0 ], %g1
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
40005cb4: b8 10 00 18 mov %i0, %i4
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005cb8: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005cbc: 92 10 20 00 clr %o1
40005cc0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
40005cc4: 40 00 04 ab call 40006f70 <rtems_semaphore_obtain>
40005cc8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40005ccc: b0 92 20 00 orcc %o0, 0, %i0
40005cd0: 12 80 00 25 bne 40005d64 <rtems_termios_write+0xb8> <== NEVER TAKEN
40005cd4: 03 10 00 77 sethi %hi(0x4001dc00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
40005cd8: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40005cdc: 85 28 a0 05 sll %g2, 5, %g2
40005ce0: 82 10 61 ec or %g1, 0x1ec, %g1
40005ce4: 82 00 40 02 add %g1, %g2, %g1
40005ce8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005cec: 80 a0 60 00 cmp %g1, 0
40005cf0: 02 80 00 06 be 40005d08 <rtems_termios_write+0x5c>
40005cf4: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
40005cf8: 9f c0 40 00 call %g1
40005cfc: 92 10 00 1c mov %i4, %o1
40005d00: 10 80 00 17 b 40005d5c <rtems_termios_write+0xb0>
40005d04: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
40005d08: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
40005d0c: b6 10 20 00 clr %i3
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
40005d10: 80 88 60 01 btst 1, %g1
40005d14: f4 07 20 14 ld [ %i4 + 0x14 ], %i2
40005d18: 12 80 00 07 bne 40005d34 <rtems_termios_write+0x88> <== ALWAYS TAKEN
40005d1c: f2 07 20 10 ld [ %i4 + 0x10 ], %i1
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
40005d20: 10 80 00 0a b 40005d48 <rtems_termios_write+0x9c> <== NOT EXECUTED
40005d24: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
40005d28: 92 10 00 1d mov %i5, %o1
40005d2c: 7f ff fe 54 call 4000567c <oproc>
40005d30: b6 06 e0 01 inc %i3
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
40005d34: 80 a6 c0 1a cmp %i3, %i2
40005d38: 32 bf ff fc bne,a 40005d28 <rtems_termios_write+0x7c>
40005d3c: d0 0e 40 1b ldub [ %i1 + %i3 ], %o0
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
40005d40: 10 80 00 06 b 40005d58 <rtems_termios_write+0xac>
40005d44: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
40005d48: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40005d4c: 7f ff fe 03 call 40005558 <rtems_termios_puts> <== NOT EXECUTED
40005d50: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
40005d54: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
40005d58: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
40005d5c: 40 00 04 ce call 40007094 <rtems_semaphore_release>
40005d60: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
40005d64: 81 c7 e0 08 ret
40005d68: 81 e8 00 00 restore
40017bd0 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
40017bd0: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
40017bd4: 11 10 00 f7 sethi %hi(0x4003dc00), %o0
40017bd8: 92 10 00 18 mov %i0, %o1
40017bdc: 90 12 22 f8 or %o0, 0x2f8, %o0
40017be0: 40 00 0c 3b call 4001accc <_Objects_Get>
40017be4: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40017be8: c2 07 bf fc ld [ %fp + -4 ], %g1
40017bec: 80 a0 60 00 cmp %g1, 0
40017bf0: 12 80 00 0c bne 40017c20 <rtems_timer_cancel+0x50>
40017bf4: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
40017bf8: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40017bfc: 80 a0 60 04 cmp %g1, 4
40017c00: 02 80 00 04 be 40017c10 <rtems_timer_cancel+0x40> <== NEVER TAKEN
40017c04: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
40017c08: 40 00 13 b2 call 4001cad0 <_Watchdog_Remove>
40017c0c: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
40017c10: 40 00 0f da call 4001bb78 <_Thread_Enable_dispatch>
40017c14: b0 10 20 00 clr %i0
40017c18: 81 c7 e0 08 ret
40017c1c: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40017c20: 81 c7 e0 08 ret
40017c24: 91 e8 20 04 restore %g0, 4, %o0
400180e0 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
400180e0: 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;
400180e4: 03 10 00 f7 sethi %hi(0x4003dc00), %g1
400180e8: f8 00 63 38 ld [ %g1 + 0x338 ], %i4 ! 4003df38 <_Timer_server>
if ( !timer_server )
400180ec: 80 a7 20 00 cmp %i4, 0
400180f0: 02 80 00 3c be 400181e0 <rtems_timer_server_fire_when+0x100>
400180f4: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
400180f8: 21 10 00 f5 sethi %hi(0x4003d400), %l0
400180fc: 82 14 20 d8 or %l0, 0xd8, %g1 ! 4003d4d8 <_TOD>
40018100: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
40018104: 80 a0 a0 00 cmp %g2, 0
40018108: 02 80 00 36 be 400181e0 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
4001810c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( !routine )
40018110: 80 a6 a0 00 cmp %i2, 0
40018114: 02 80 00 33 be 400181e0 <rtems_timer_server_fire_when+0x100>
40018118: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
4001811c: 7f ff f3 7f call 40014f18 <_TOD_Validate>
40018120: 90 10 00 19 mov %i1, %o0
40018124: 80 8a 20 ff btst 0xff, %o0
40018128: 02 80 00 2e be 400181e0 <rtems_timer_server_fire_when+0x100>
4001812c: 82 10 20 14 mov 0x14, %g1
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
40018130: 7f ff f3 40 call 40014e30 <_TOD_To_seconds>
40018134: 90 10 00 19 mov %i1, %o0
40018138: b2 10 00 08 mov %o0, %i1
4001813c: d0 1c 20 d8 ldd [ %l0 + 0xd8 ], %o0
40018140: 94 10 20 00 clr %o2
40018144: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40018148: 40 00 4f e1 call 4002c0cc <__divdi3>
4001814c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
40018150: 80 a6 40 09 cmp %i1, %o1
40018154: 08 80 00 23 bleu 400181e0 <rtems_timer_server_fire_when+0x100>
40018158: 82 10 20 14 mov 0x14, %g1
4001815c: 11 10 00 f7 sethi %hi(0x4003dc00), %o0
40018160: 92 10 00 18 mov %i0, %o1
40018164: 90 12 22 f8 or %o0, 0x2f8, %o0
40018168: 40 00 0a d9 call 4001accc <_Objects_Get>
4001816c: 94 07 bf fc add %fp, -4, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40018170: c2 07 bf fc ld [ %fp + -4 ], %g1
40018174: 80 a0 60 00 cmp %g1, 0
40018178: 12 80 00 19 bne 400181dc <rtems_timer_server_fire_when+0xfc>
4001817c: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
40018180: 40 00 12 54 call 4001cad0 <_Watchdog_Remove>
40018184: 90 02 20 10 add %o0, 0x10, %o0
40018188: d0 1c 20 d8 ldd [ %l0 + 0xd8 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
4001818c: 82 10 20 03 mov 3, %g1
40018190: 94 10 20 00 clr %o2
40018194: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40018198: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
4001819c: f4 27 60 2c st %i2, [ %i5 + 0x2c ]
the_watchdog->id = id;
400181a0: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
400181a4: f6 27 60 34 st %i3, [ %i5 + 0x34 ]
400181a8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400181ac: 40 00 4f c8 call 4002c0cc <__divdi3>
400181b0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_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 );
400181b4: c2 07 20 04 ld [ %i4 + 4 ], %g1
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
400181b8: 92 26 40 09 sub %i1, %o1, %o1
(*timer_server->schedule_operation)( timer_server, the_timer );
400181bc: 90 10 00 1c mov %i4, %o0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
400181c0: d2 27 60 1c st %o1, [ %i5 + 0x1c ]
(*timer_server->schedule_operation)( timer_server, the_timer );
400181c4: 9f c0 40 00 call %g1
400181c8: 92 10 00 1d mov %i5, %o1
_Thread_Enable_dispatch();
400181cc: 40 00 0e 6b call 4001bb78 <_Thread_Enable_dispatch>
400181d0: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
400181d4: 10 80 00 03 b 400181e0 <rtems_timer_server_fire_when+0x100>
400181d8: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
400181dc: 82 10 20 04 mov 4, %g1
}
400181e0: 81 c7 e0 08 ret
400181e4: 91 e8 00 01 restore %g0, %g1, %o0
40002d74 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
40002d74: 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) {
40002d78: 03 08 00 00 sethi %hi(0x20000000), %g1
40002d7c: 80 8e 00 01 btst %i0, %g1
40002d80: 12 80 00 0e bne 40002db8 <rtems_verror+0x44>
40002d84: ba 10 00 18 mov %i0, %i5
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40002d88: 03 10 00 76 sethi %hi(0x4001d800), %g1
40002d8c: c2 00 60 a8 ld [ %g1 + 0xa8 ], %g1 ! 4001d8a8 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
40002d90: 39 1c 00 00 sethi %hi(0x70000000), %i4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40002d94: d0 00 60 08 ld [ %g1 + 8 ], %o0
40002d98: 40 00 30 38 call 4000ee78 <fflush>
40002d9c: b8 2f 40 1c andn %i5, %i4, %i4
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
40002da0: 03 10 00 00 sethi %hi(0x40000000), %g1
40002da4: 80 8f 40 01 btst %i5, %g1
40002da8: 12 80 00 15 bne 40002dfc <rtems_verror+0x88>
40002dac: ba 10 20 00 clr %i5
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
40002db0: 10 80 00 17 b 40002e0c <rtems_verror+0x98>
40002db4: 37 10 00 76 sethi %hi(0x4001d800), %i3
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
40002db8: 05 10 00 78 sethi %hi(0x4001e000), %g2
40002dbc: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 ! 4001e06c <rtems_panic_in_progress>
40002dc0: 86 00 60 01 add %g1, 1, %g3
40002dc4: 80 a0 60 00 cmp %g1, 0
40002dc8: 02 80 00 06 be 40002de0 <rtems_verror+0x6c> <== ALWAYS TAKEN
40002dcc: c6 20 a0 6c st %g3, [ %g2 + 0x6c ]
*
* 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;
40002dd0: 03 10 00 78 sethi %hi(0x4001e000), %g1 <== NOT EXECUTED
40002dd4: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 4001e200 <_Thread_Dispatch_disable_level><== NOT EXECUTED
++level;
40002dd8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
40002ddc: c4 20 62 00 st %g2, [ %g1 + 0x200 ] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
40002de0: 03 10 00 78 sethi %hi(0x4001e000), %g1
40002de4: c2 00 60 6c ld [ %g1 + 0x6c ], %g1 ! 4001e06c <rtems_panic_in_progress>
40002de8: 80 a0 60 02 cmp %g1, 2
40002dec: 04 bf ff e7 ble 40002d88 <rtems_verror+0x14> <== ALWAYS TAKEN
40002df0: b0 10 20 00 clr %i0
40002df4: 81 c7 e0 08 ret <== NOT EXECUTED
40002df8: 81 e8 00 00 restore <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
40002dfc: 40 00 2f 1c call 4000ea6c <__errno>
40002e00: 01 00 00 00 nop
40002e04: fa 02 00 00 ld [ %o0 ], %i5
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
40002e08: 37 10 00 76 sethi %hi(0x4001d800), %i3
40002e0c: c2 06 e0 a8 ld [ %i3 + 0xa8 ], %g1 ! 4001d8a8 <_impure_ptr>
40002e10: 92 10 00 19 mov %i1, %o1
40002e14: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40002e18: 40 00 44 b0 call 400140d8 <vfprintf>
40002e1c: 94 10 00 1a mov %i2, %o2
if (status)
40002e20: 80 a7 20 00 cmp %i4, 0
40002e24: 02 80 00 0c be 40002e54 <rtems_verror+0xe0>
40002e28: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
40002e2c: c2 06 e0 a8 ld [ %i3 + 0xa8 ], %g1
40002e30: 90 10 00 1c mov %i4, %o0
40002e34: 7f ff ff ca call 40002d5c <rtems_status_text>
40002e38: f6 00 60 0c ld [ %g1 + 0xc ], %i3
40002e3c: 13 10 00 6f sethi %hi(0x4001bc00), %o1
40002e40: 94 10 00 08 mov %o0, %o2
40002e44: 92 12 61 10 or %o1, 0x110, %o1
40002e48: 40 00 31 08 call 4000f268 <fprintf>
40002e4c: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
40002e50: b0 06 00 08 add %i0, %o0, %i0
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
40002e54: 80 a7 60 00 cmp %i5, 0
40002e58: 22 80 00 1c be,a 40002ec8 <rtems_verror+0x154>
40002e5c: 3b 10 00 76 sethi %hi(0x4001d800), %i5
if ((local_errno > 0) && *strerror(local_errno))
40002e60: 80 a7 60 00 cmp %i5, 0
40002e64: 04 80 00 11 ble 40002ea8 <rtems_verror+0x134>
40002e68: 03 10 00 76 sethi %hi(0x4001d800), %g1
40002e6c: 40 00 34 7f call 40010068 <strerror>
40002e70: 90 10 00 1d mov %i5, %o0
40002e74: c2 4a 00 00 ldsb [ %o0 ], %g1
40002e78: 80 a0 60 00 cmp %g1, 0
40002e7c: 02 80 00 0b be 40002ea8 <rtems_verror+0x134> <== NEVER TAKEN
40002e80: 03 10 00 76 sethi %hi(0x4001d800), %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
40002e84: c2 00 60 a8 ld [ %g1 + 0xa8 ], %g1 ! 4001d8a8 <_impure_ptr>
40002e88: 90 10 00 1d mov %i5, %o0
40002e8c: 40 00 34 77 call 40010068 <strerror>
40002e90: f8 00 60 0c ld [ %g1 + 0xc ], %i4
40002e94: 13 10 00 6f sethi %hi(0x4001bc00), %o1
40002e98: 94 10 00 08 mov %o0, %o2
40002e9c: 92 12 61 20 or %o1, 0x120, %o1
40002ea0: 10 80 00 07 b 40002ebc <rtems_verror+0x148>
40002ea4: 90 10 00 1c mov %i4, %o0
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40002ea8: c2 00 60 a8 ld [ %g1 + 0xa8 ], %g1
40002eac: 13 10 00 6f sethi %hi(0x4001bc00), %o1
40002eb0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40002eb4: 92 12 61 30 or %o1, 0x130, %o1
40002eb8: 94 10 00 1d mov %i5, %o2
40002ebc: 40 00 30 eb call 4000f268 <fprintf>
40002ec0: 3b 10 00 76 sethi %hi(0x4001d800), %i5
40002ec4: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
40002ec8: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
40002ecc: 13 10 00 6f sethi %hi(0x4001bc00), %o1
40002ed0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40002ed4: 40 00 30 e5 call 4000f268 <fprintf>
40002ed8: 92 12 61 48 or %o1, 0x148, %o1
(void) fflush(stderr);
40002edc: c2 07 60 a8 ld [ %i5 + 0xa8 ], %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");
40002ee0: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stderr);
40002ee4: 40 00 2f e5 call 4000ee78 <fflush>
40002ee8: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
40002eec: 81 c7 e0 08 ret
40002ef0: 81 e8 00 00 restore
400233e4 <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
400233e4: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
400233e8: 37 1f ff ff sethi %hi(0x7ffffc00), %i3
int sign = 0;
400233ec: b8 10 20 00 clr %i4
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
400233f0: b6 16 e3 ff or %i3, 0x3ff, %i3
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
400233f4: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
400233f8: 21 10 01 7e sethi %hi(0x4005f800), %l0
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
400233fc: 23 10 01 7e sethi %hi(0x4005f800), %l1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40023400: c2 06 20 04 ld [ %i0 + 4 ], %g1
40023404: 82 00 7f ff add %g1, -1, %g1
40023408: 80 a0 60 00 cmp %g1, 0
4002340c: 16 80 00 07 bge 40023428 <scanInt+0x44> <== ALWAYS TAKEN
40023410: c2 26 20 04 st %g1, [ %i0 + 4 ]
40023414: d0 04 20 e0 ld [ %l0 + 0xe0 ], %o0 <== NOT EXECUTED
40023418: 40 00 61 f8 call 4003bbf8 <__srget_r> <== NOT EXECUTED
4002341c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
40023420: 10 80 00 07 b 4002343c <scanInt+0x58> <== NOT EXECUTED
40023424: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40023428: c4 06 00 00 ld [ %i0 ], %g2
4002342c: d0 08 80 00 ldub [ %g2 ], %o0
40023430: 84 00 a0 01 inc %g2
40023434: c4 26 00 00 st %g2, [ %i0 ]
if (c == ':')
40023438: 80 a2 20 3a cmp %o0, 0x3a
4002343c: 02 80 00 21 be 400234c0 <scanInt+0xdc>
40023440: 80 a7 20 00 cmp %i4, 0
break;
if (sign == 0) {
40023444: 12 80 00 08 bne 40023464 <scanInt+0x80>
40023448: c4 04 60 d0 ld [ %l1 + 0xd0 ], %g2
if (c == '-') {
4002344c: 80 a2 20 2d cmp %o0, 0x2d
40023450: 12 80 00 05 bne 40023464 <scanInt+0x80>
40023454: b8 10 20 01 mov 1, %i4
sign = -1;
limit++;
40023458: b6 06 e0 01 inc %i3
continue;
4002345c: 10 bf ff e9 b 40023400 <scanInt+0x1c>
40023460: b8 10 3f ff mov -1, %i4
}
sign = 1;
}
if (!isdigit(c))
40023464: 84 00 80 08 add %g2, %o0, %g2
40023468: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
4002346c: 80 88 a0 04 btst 4, %g2
40023470: 02 80 00 1d be 400234e4 <scanInt+0x100>
40023474: b4 02 3f d0 add %o0, -48, %i2
return 0;
d = c - '0';
if ((i > (limit / 10))
40023478: 92 10 20 0a mov 0xa, %o1
4002347c: 40 00 b2 1e call 4004fcf4 <.udiv>
40023480: 90 10 00 1b mov %i3, %o0
40023484: 80 a7 40 08 cmp %i5, %o0
40023488: 38 80 00 15 bgu,a 400234dc <scanInt+0xf8>
4002348c: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
40023490: 12 80 00 08 bne 400234b0 <scanInt+0xcc>
40023494: 83 2f 60 01 sll %i5, 1, %g1
40023498: 90 10 00 1b mov %i3, %o0
4002349c: 40 00 b2 c2 call 4004ffa4 <.urem>
400234a0: 92 10 20 0a mov 0xa, %o1
400234a4: 80 a6 80 08 cmp %i2, %o0
400234a8: 18 80 00 0f bgu 400234e4 <scanInt+0x100> <== ALWAYS TAKEN
400234ac: 83 2f 60 01 sll %i5, 1, %g1
return 0;
i = i * 10 + d;
400234b0: bb 2f 60 03 sll %i5, 3, %i5
400234b4: ba 00 40 1d add %g1, %i5, %i5
400234b8: 10 bf ff d2 b 40023400 <scanInt+0x1c>
400234bc: ba 06 80 1d add %i2, %i5, %i5
}
if (sign == 0)
400234c0: 02 80 00 07 be 400234dc <scanInt+0xf8> <== NEVER TAKEN
400234c4: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
400234c8: 90 10 00 1c mov %i4, %o0
400234cc: 92 10 00 1d mov %i5, %o1
400234d0: 40 00 b1 cf call 4004fc0c <.umul>
400234d4: b0 10 20 01 mov 1, %i0
400234d8: d0 26 40 00 st %o0, [ %i1 ]
return 1;
400234dc: 81 c7 e0 08 ret
400234e0: 81 e8 00 00 restore
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
400234e4: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
400234e8: 81 c7 e0 08 ret
400234ec: 81 e8 00 00 restore
400235e0 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
400235e0: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
400235e4: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
400235e8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400235ec: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
400235f0: 90 10 00 18 mov %i0, %o0
400235f4: 92 10 00 19 mov %i1, %o1
400235f8: 94 07 a0 4c add %fp, 0x4c, %o2
400235fc: 7f ff ff bd call 400234f0 <scanString>
40023600: 96 07 a0 50 add %fp, 0x50, %o3
40023604: 80 a2 20 00 cmp %o0, 0
40023608: 12 80 00 04 bne 40023618 <scangr+0x38>
4002360c: 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;
40023610: 81 c7 e0 08 ret
40023614: 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)
40023618: 92 06 60 04 add %i1, 4, %o1
4002361c: 94 07 a0 4c add %fp, 0x4c, %o2
40023620: 96 07 a0 50 add %fp, 0x50, %o3
40023624: 7f ff ff b3 call 400234f0 <scanString>
40023628: 98 10 20 00 clr %o4
4002362c: 80 a2 20 00 cmp %o0, 0
40023630: 02 bf ff f8 be 40023610 <scangr+0x30> <== NEVER TAKEN
40023634: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
40023638: 7f ff ff 6b call 400233e4 <scanInt>
4002363c: 92 07 bf f8 add %fp, -8, %o1
40023640: 80 a2 20 00 cmp %o0, 0
40023644: 02 bf ff f3 be 40023610 <scangr+0x30> <== NEVER TAKEN
40023648: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
4002364c: 92 07 bf fc add %fp, -4, %o1
40023650: 94 07 a0 4c add %fp, 0x4c, %o2
40023654: 96 07 a0 50 add %fp, 0x50, %o3
40023658: 7f ff ff a6 call 400234f0 <scanString>
4002365c: 98 10 20 01 mov 1, %o4
40023660: 80 a2 20 00 cmp %o0, 0
40023664: 02 bf ff eb be 40023610 <scangr+0x30> <== NEVER TAKEN
40023668: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
4002366c: c6 07 bf fc ld [ %fp + -4 ], %g3
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
40023670: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40023674: 84 10 00 03 mov %g3, %g2
40023678: 10 80 00 05 b 4002368c <scangr+0xac>
4002367c: 82 10 20 01 mov 1, %g1
40023680: 84 00 a0 01 inc %g2
if(*cp == ',')
memcount++;
40023684: 80 a0 00 04 cmp %g0, %g4
40023688: 82 60 7f ff subx %g1, -1, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
4002368c: c8 48 80 00 ldsb [ %g2 ], %g4
40023690: 80 a1 20 00 cmp %g4, 0
40023694: 32 bf ff fb bne,a 40023680 <scangr+0xa0>
40023698: 88 19 20 2c xor %g4, 0x2c, %g4
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
4002369c: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
400236a0: 83 28 60 02 sll %g1, 2, %g1
400236a4: 82 00 60 13 add %g1, 0x13, %g1
400236a8: 80 a0 80 01 cmp %g2, %g1
400236ac: 0a bf ff d9 bcs 40023610 <scangr+0x30> <== NEVER TAKEN
400236b0: c2 07 a0 4c ld [ %fp + 0x4c ], %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400236b4: 84 10 20 01 mov 1, %g2
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
400236b8: 82 00 60 0f add %g1, 0xf, %g1
400236bc: 82 08 7f f0 and %g1, -16, %g1
400236c0: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
400236c4: c6 20 40 00 st %g3, [ %g1 ]
}
/**
* Extract a single group record from the database
*/
static int scangr(
400236c8: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400236cc: 10 80 00 0a b 400236f4 <scangr+0x114>
400236d0: 82 00 60 01 inc %g1
if(*cp == ',') {
400236d4: 32 80 00 08 bne,a 400236f4 <scangr+0x114>
400236d8: 82 00 60 01 inc %g1
*cp = '\0';
400236dc: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
400236e0: c8 06 60 0c ld [ %i1 + 0xc ], %g4
400236e4: 87 28 a0 02 sll %g2, 2, %g3
400236e8: 84 00 a0 01 inc %g2
400236ec: c2 21 00 03 st %g1, [ %g4 + %g3 ]
400236f0: 82 00 60 01 inc %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400236f4: c6 48 7f ff ldsb [ %g1 + -1 ], %g3
400236f8: 80 a0 e0 00 cmp %g3, 0
400236fc: 32 bf ff f6 bne,a 400236d4 <scangr+0xf4>
40023700: 80 a0 e0 2c cmp %g3, 0x2c
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
40023704: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40023708: 85 28 a0 02 sll %g2, 2, %g2
4002370c: c0 20 40 02 clr [ %g1 + %g2 ]
return 1;
}
40023710: 81 c7 e0 08 ret
40023714: 91 e8 20 01 restore %g0, 1, %o0
40023718 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40023718: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
4002371c: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40023720: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40023724: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40023728: 90 10 00 18 mov %i0, %o0
4002372c: 92 10 00 19 mov %i1, %o1
40023730: 94 07 a0 4c add %fp, 0x4c, %o2
40023734: 7f ff ff 6f call 400234f0 <scanString>
40023738: 96 07 a0 50 add %fp, 0x50, %o3
4002373c: 80 a2 20 00 cmp %o0, 0
40023740: 12 80 00 04 bne 40023750 <scanpw+0x38>
40023744: 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;
40023748: 81 c7 e0 08 ret
4002374c: 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)
40023750: 92 06 60 04 add %i1, 4, %o1
40023754: 94 07 a0 4c add %fp, 0x4c, %o2
40023758: 96 07 a0 50 add %fp, 0x50, %o3
4002375c: 7f ff ff 65 call 400234f0 <scanString>
40023760: 98 10 20 00 clr %o4
40023764: 80 a2 20 00 cmp %o0, 0
40023768: 02 bf ff f8 be 40023748 <scanpw+0x30> <== NEVER TAKEN
4002376c: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
40023770: 7f ff ff 1d call 400233e4 <scanInt>
40023774: 92 07 bf f8 add %fp, -8, %o1
40023778: 80 a2 20 00 cmp %o0, 0
4002377c: 02 bf ff f3 be 40023748 <scanpw+0x30>
40023780: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
40023784: 7f ff ff 18 call 400233e4 <scanInt>
40023788: 92 07 bf fc add %fp, -4, %o1
4002378c: 80 a2 20 00 cmp %o0, 0
40023790: 02 bf ff ee be 40023748 <scanpw+0x30>
40023794: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
40023798: 92 06 60 0c add %i1, 0xc, %o1
4002379c: 94 07 a0 4c add %fp, 0x4c, %o2
400237a0: 96 07 a0 50 add %fp, 0x50, %o3
400237a4: 7f ff ff 53 call 400234f0 <scanString>
400237a8: 98 10 20 00 clr %o4
400237ac: 80 a2 20 00 cmp %o0, 0
400237b0: 02 bf ff e6 be 40023748 <scanpw+0x30> <== NEVER TAKEN
400237b4: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
400237b8: 92 06 60 10 add %i1, 0x10, %o1
400237bc: 94 07 a0 4c add %fp, 0x4c, %o2
400237c0: 96 07 a0 50 add %fp, 0x50, %o3
400237c4: 7f ff ff 4b call 400234f0 <scanString>
400237c8: 98 10 20 00 clr %o4
400237cc: 80 a2 20 00 cmp %o0, 0
400237d0: 02 bf ff de be 40023748 <scanpw+0x30> <== NEVER TAKEN
400237d4: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
400237d8: 92 06 60 14 add %i1, 0x14, %o1
400237dc: 94 07 a0 4c add %fp, 0x4c, %o2
400237e0: 96 07 a0 50 add %fp, 0x50, %o3
400237e4: 7f ff ff 43 call 400234f0 <scanString>
400237e8: 98 10 20 00 clr %o4
400237ec: 80 a2 20 00 cmp %o0, 0
400237f0: 02 bf ff d6 be 40023748 <scanpw+0x30> <== NEVER TAKEN
400237f4: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
400237f8: 92 06 60 18 add %i1, 0x18, %o1
400237fc: 94 07 a0 4c add %fp, 0x4c, %o2
40023800: 96 07 a0 50 add %fp, 0x50, %o3
40023804: 7f ff ff 3b call 400234f0 <scanString>
40023808: 98 10 20 01 mov 1, %o4
4002380c: 80 a2 20 00 cmp %o0, 0
40023810: 02 bf ff ce be 40023748 <scanpw+0x30>
40023814: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
40023818: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
4002381c: c2 07 bf fc ld [ %fp + -4 ], %g1
40023820: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
40023824: 81 c7 e0 08 ret
40023828: 91 e8 20 01 restore %g0, 1, %o0
400072d0 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
400072d0: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
400072d4: 80 a6 20 04 cmp %i0, 4
400072d8: 18 80 00 06 bgu 400072f0 <sched_get_priority_max+0x20>
400072dc: 82 10 20 01 mov 1, %g1
400072e0: b1 28 40 18 sll %g1, %i0, %i0
400072e4: 80 8e 20 17 btst 0x17, %i0
400072e8: 12 80 00 08 bne 40007308 <sched_get_priority_max+0x38> <== ALWAYS TAKEN
400072ec: 03 10 00 78 sethi %hi(0x4001e000), %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
400072f0: 40 00 20 0e call 4000f328 <__errno>
400072f4: b0 10 3f ff mov -1, %i0
400072f8: 82 10 20 16 mov 0x16, %g1
400072fc: c2 22 00 00 st %g1, [ %o0 ]
40007300: 81 c7 e0 08 ret
40007304: 81 e8 00 00 restore
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
40007308: f0 08 60 ac ldub [ %g1 + 0xac ], %i0
}
4000730c: 81 c7 e0 08 ret
40007310: 91 ee 3f ff restore %i0, -1, %o0
40007314 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
40007314: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
40007318: 80 a6 20 04 cmp %i0, 4
4000731c: 18 80 00 06 bgu 40007334 <sched_get_priority_min+0x20>
40007320: 82 10 20 01 mov 1, %g1
40007324: 83 28 40 18 sll %g1, %i0, %g1
40007328: 80 88 60 17 btst 0x17, %g1
4000732c: 12 80 00 06 bne 40007344 <sched_get_priority_min+0x30> <== ALWAYS TAKEN
40007330: b0 10 20 01 mov 1, %i0
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40007334: 40 00 1f fd call 4000f328 <__errno>
40007338: b0 10 3f ff mov -1, %i0
4000733c: 82 10 20 16 mov 0x16, %g1
40007340: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
40007344: 81 c7 e0 08 ret
40007348: 81 e8 00 00 restore
4000734c <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
4000734c: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
40007350: 80 a6 20 00 cmp %i0, 0
40007354: 02 80 00 0b be 40007380 <sched_rr_get_interval+0x34> <== NEVER TAKEN
40007358: 80 a6 60 00 cmp %i1, 0
4000735c: 7f ff f0 07 call 40003378 <getpid>
40007360: 01 00 00 00 nop
40007364: 80 a6 00 08 cmp %i0, %o0
40007368: 02 80 00 06 be 40007380 <sched_rr_get_interval+0x34>
4000736c: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
40007370: 40 00 1f ee call 4000f328 <__errno>
40007374: 01 00 00 00 nop
40007378: 10 80 00 07 b 40007394 <sched_rr_get_interval+0x48>
4000737c: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
if ( !interval )
40007380: 12 80 00 08 bne 400073a0 <sched_rr_get_interval+0x54>
40007384: 03 10 00 7a sethi %hi(0x4001e800), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
40007388: 40 00 1f e8 call 4000f328 <__errno>
4000738c: 01 00 00 00 nop
40007390: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40007394: c2 22 00 00 st %g1, [ %o0 ]
40007398: 81 c7 e0 08 ret
4000739c: 91 e8 3f ff restore %g0, -1, %o0
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
400073a0: d0 00 63 c0 ld [ %g1 + 0x3c0 ], %o0
400073a4: 92 10 00 19 mov %i1, %o1
400073a8: 40 00 0e 63 call 4000ad34 <_Timespec_From_ticks>
400073ac: b0 10 20 00 clr %i0
return 0;
}
400073b0: 81 c7 e0 08 ret
400073b4: 81 e8 00 00 restore
40007d68 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
40007d68: 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;
40007d6c: 03 10 00 8b sethi %hi(0x40022c00), %g1
40007d70: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 40022c10 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40007d74: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
40007d78: 84 00 a0 01 inc %g2
40007d7c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40007d80: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40007d84: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
40007d88: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
40007d8c: b4 8e 62 00 andcc %i1, 0x200, %i2
40007d90: 02 80 00 05 be 40007da4 <sem_open+0x3c>
40007d94: b8 10 20 00 clr %i4
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
40007d98: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40007d9c: 82 07 a0 4c add %fp, 0x4c, %g1
40007da0: c2 27 bf ec st %g1, [ %fp + -20 ]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
40007da4: 37 10 00 8b sethi %hi(0x40022c00), %i3
40007da8: 92 10 00 18 mov %i0, %o1
40007dac: 90 16 e2 d4 or %i3, 0x2d4, %o0
40007db0: 94 07 bf f0 add %fp, -16, %o2
40007db4: 7f ff fe 7e call 400077ac <_POSIX_Name_to_id>
40007db8: 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 ) {
40007dbc: ba 92 20 00 orcc %o0, 0, %i5
40007dc0: 22 80 00 0e be,a 40007df8 <sem_open+0x90>
40007dc4: 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) ) ) {
40007dc8: 80 a7 60 02 cmp %i5, 2
40007dcc: 12 80 00 04 bne 40007ddc <sem_open+0x74>
40007dd0: 80 a6 a0 00 cmp %i2, 0
40007dd4: 12 80 00 20 bne 40007e54 <sem_open+0xec>
40007dd8: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
40007ddc: 40 00 0d b7 call 4000b4b8 <_Thread_Enable_dispatch>
40007de0: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
40007de4: 40 00 22 eb call 40010990 <__errno>
40007de8: 01 00 00 00 nop
40007dec: fa 22 00 00 st %i5, [ %o0 ]
40007df0: 81 c7 e0 08 ret
40007df4: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
40007df8: 80 a6 6a 00 cmp %i1, 0xa00
40007dfc: 12 80 00 0a bne 40007e24 <sem_open+0xbc>
40007e00: d2 07 bf f0 ld [ %fp + -16 ], %o1
_Thread_Enable_dispatch();
40007e04: 40 00 0d ad call 4000b4b8 <_Thread_Enable_dispatch>
40007e08: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
40007e0c: 40 00 22 e1 call 40010990 <__errno>
40007e10: 01 00 00 00 nop
40007e14: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
40007e18: c2 22 00 00 st %g1, [ %o0 ]
40007e1c: 81 c7 e0 08 ret
40007e20: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
40007e24: 94 07 bf f8 add %fp, -8, %o2
40007e28: 40 00 09 ea call 4000a5d0 <_Objects_Get>
40007e2c: 90 16 e2 d4 or %i3, 0x2d4, %o0
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
40007e30: 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 );
40007e34: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
40007e38: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
40007e3c: 40 00 0d 9f call 4000b4b8 <_Thread_Enable_dispatch>
40007e40: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
40007e44: 40 00 0d 9d call 4000b4b8 <_Thread_Enable_dispatch>
40007e48: 01 00 00 00 nop
goto return_id;
40007e4c: 10 80 00 0d b 40007e80 <sem_open+0x118>
40007e50: f0 07 bf f4 ld [ %fp + -12 ], %i0
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
40007e54: 94 10 20 00 clr %o2
40007e58: 96 10 00 1c mov %i4, %o3
40007e5c: 98 07 bf f4 add %fp, -12, %o4
40007e60: 40 00 19 1b call 4000e2cc <_POSIX_Semaphore_Create_support>
40007e64: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
40007e68: 40 00 0d 94 call 4000b4b8 <_Thread_Enable_dispatch>
40007e6c: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
40007e70: 80 a7 7f ff cmp %i5, -1
40007e74: 22 80 00 04 be,a 40007e84 <sem_open+0x11c> <== NEVER TAKEN
40007e78: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
40007e7c: f0 07 bf f4 ld [ %fp + -12 ], %i0
40007e80: b0 06 20 08 add %i0, 8, %i0
#endif
}
40007e84: 81 c7 e0 08 ret
40007e88: 81 e8 00 00 restore
400072c8 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
400072c8: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
400072cc: 80 a6 a0 00 cmp %i2, 0
400072d0: 02 80 00 0a be 400072f8 <sigaction+0x30>
400072d4: 83 2e 20 02 sll %i0, 2, %g1
*oact = _POSIX_signals_Vectors[ sig ];
400072d8: 85 2e 20 04 sll %i0, 4, %g2
400072dc: 82 20 80 01 sub %g2, %g1, %g1
400072e0: 13 10 00 66 sethi %hi(0x40019800), %o1
400072e4: 90 10 00 1a mov %i2, %o0
400072e8: 92 12 63 f0 or %o1, 0x3f0, %o1
400072ec: 94 10 20 0c mov 0xc, %o2
400072f0: 40 00 23 56 call 40010048 <memcpy>
400072f4: 92 02 40 01 add %o1, %g1, %o1
if ( !sig )
400072f8: 80 a6 20 00 cmp %i0, 0
400072fc: 32 80 00 03 bne,a 40007308 <sigaction+0x40>
40007300: 82 06 3f ff add %i0, -1, %g1
40007304: 30 80 00 06 b,a 4000731c <sigaction+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
40007308: 80 a0 60 1f cmp %g1, 0x1f
4000730c: 18 80 00 04 bgu 4000731c <sigaction+0x54>
40007310: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
40007314: 12 80 00 08 bne 40007334 <sigaction+0x6c>
40007318: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
4000731c: 40 00 21 10 call 4000f75c <__errno>
40007320: 01 00 00 00 nop
40007324: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40007328: c2 22 00 00 st %g1, [ %o0 ]
4000732c: 10 80 00 20 b 400073ac <sigaction+0xe4>
40007330: 82 10 3f ff mov -1, %g1
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
40007334: 02 80 00 1e be 400073ac <sigaction+0xe4> <== NEVER TAKEN
40007338: 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 );
4000733c: 7f ff ec 3f call 40002438 <sparc_disable_interrupts>
40007340: 01 00 00 00 nop
40007344: b8 10 00 08 mov %o0, %i4
if ( act->sa_handler == SIG_DFL ) {
40007348: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000734c: 3b 10 00 66 sethi %hi(0x40019800), %i5
40007350: 80 a0 60 00 cmp %g1, 0
40007354: 12 80 00 0a bne 4000737c <sigaction+0xb4>
40007358: ba 17 63 f0 or %i5, 0x3f0, %i5
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
4000735c: 83 2e 20 02 sll %i0, 2, %g1
40007360: 13 10 00 60 sethi %hi(0x40018000), %o1
40007364: b1 2e 20 04 sll %i0, 4, %i0
40007368: 92 12 62 d4 or %o1, 0x2d4, %o1
4000736c: b0 26 00 01 sub %i0, %g1, %i0
40007370: 90 07 40 18 add %i5, %i0, %o0
40007374: 10 80 00 09 b 40007398 <sigaction+0xd0>
40007378: 92 02 40 18 add %o1, %i0, %o1
} else {
_POSIX_signals_Clear_process_signals( sig );
4000737c: 40 00 16 3a call 4000cc64 <_POSIX_signals_Clear_process_signals>
40007380: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
40007384: 83 2e 20 02 sll %i0, 2, %g1
40007388: 92 10 00 19 mov %i1, %o1
4000738c: b1 2e 20 04 sll %i0, 4, %i0
40007390: 90 26 00 01 sub %i0, %g1, %o0
40007394: 90 07 40 08 add %i5, %o0, %o0
40007398: 40 00 23 2c call 40010048 <memcpy>
4000739c: 94 10 20 0c mov 0xc, %o2
}
_ISR_Enable( level );
400073a0: 7f ff ec 2a call 40002448 <sparc_enable_interrupts>
400073a4: 90 10 00 1c mov %i4, %o0
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
400073a8: 82 10 20 00 clr %g1
}
400073ac: 81 c7 e0 08 ret
400073b0: 91 e8 00 01 restore %g0, %g1, %o0
4000780c <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
4000780c: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
40007810: 80 a6 20 00 cmp %i0, 0
40007814: 02 80 00 0e be 4000784c <sigtimedwait+0x40>
40007818: 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 ) {
4000781c: 02 80 00 10 be 4000785c <sigtimedwait+0x50>
40007820: b6 10 20 00 clr %i3
if ( !_Timespec_Is_valid( timeout ) )
40007824: 40 00 0e ac call 4000b2d4 <_Timespec_Is_valid>
40007828: 90 10 00 1a mov %i2, %o0
4000782c: 80 8a 20 ff btst 0xff, %o0
40007830: 02 80 00 07 be 4000784c <sigtimedwait+0x40>
40007834: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
40007838: 40 00 0e b9 call 4000b31c <_Timespec_To_ticks>
4000783c: 90 10 00 1a mov %i2, %o0
if ( !interval )
40007840: b6 92 20 00 orcc %o0, 0, %i3
40007844: 12 80 00 07 bne 40007860 <sigtimedwait+0x54> <== ALWAYS TAKEN
40007848: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
4000784c: 40 00 21 90 call 4000fe8c <__errno>
40007850: 01 00 00 00 nop
40007854: 10 80 00 63 b 400079e0 <sigtimedwait+0x1d4>
40007858: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
4000785c: 80 a6 60 00 cmp %i1, 0
40007860: 22 80 00 02 be,a 40007868 <sigtimedwait+0x5c>
40007864: b2 07 bf f4 add %fp, -12, %i1
the_thread = _Thread_Executing;
40007868: 21 10 00 68 sethi %hi(0x4001a000), %l0
4000786c: a0 14 23 a0 or %l0, 0x3a0, %l0 ! 4001a3a0 <_Per_CPU_Information>
40007870: fa 04 20 10 ld [ %l0 + 0x10 ], %i5
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
40007874: 7f ff eb ce call 400027ac <sparc_disable_interrupts>
40007878: f8 07 61 50 ld [ %i5 + 0x150 ], %i4
4000787c: b4 10 00 08 mov %o0, %i2
if ( *set & api->signals_pending ) {
40007880: c4 06 00 00 ld [ %i0 ], %g2
40007884: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
40007888: 80 88 80 01 btst %g2, %g1
4000788c: 22 80 00 12 be,a 400078d4 <sigtimedwait+0xc8>
40007890: 03 10 00 69 sethi %hi(0x4001a400), %g1
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
40007894: 7f ff ff c6 call 400077ac <_POSIX_signals_Get_lowest>
40007898: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals(
4000789c: 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 );
400078a0: 92 10 00 08 mov %o0, %o1
400078a4: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
400078a8: 96 10 20 00 clr %o3
400078ac: 90 10 00 1c mov %i4, %o0
400078b0: 40 00 17 08 call 4000d4d0 <_POSIX_signals_Clear_signals>
400078b4: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
400078b8: 7f ff eb c1 call 400027bc <sparc_enable_interrupts>
400078bc: 90 10 00 1a mov %i2, %o0
the_info->si_code = SI_USER;
400078c0: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
400078c4: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
400078c8: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
400078cc: 10 80 00 47 b 400079e8 <sigtimedwait+0x1dc>
400078d0: fa 06 40 00 ld [ %i1 ], %i5
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
400078d4: c2 00 61 f4 ld [ %g1 + 0x1f4 ], %g1
400078d8: 80 88 80 01 btst %g2, %g1
400078dc: 22 80 00 12 be,a 40007924 <sigtimedwait+0x118>
400078e0: 82 10 3f ff mov -1, %g1
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
400078e4: 7f ff ff b2 call 400077ac <_POSIX_signals_Get_lowest>
400078e8: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
400078ec: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
400078f0: ba 10 00 08 mov %o0, %i5
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
400078f4: 96 10 20 01 mov 1, %o3
400078f8: 90 10 00 1c mov %i4, %o0
400078fc: 92 10 00 1d mov %i5, %o1
40007900: 40 00 16 f4 call 4000d4d0 <_POSIX_signals_Clear_signals>
40007904: 98 10 20 00 clr %o4
_ISR_Enable( level );
40007908: 7f ff eb ad call 400027bc <sparc_enable_interrupts>
4000790c: 90 10 00 1a mov %i2, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
40007910: 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;
40007914: fa 26 40 00 st %i5, [ %i1 ]
the_info->si_code = SI_USER;
40007918: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
4000791c: 10 80 00 33 b 400079e8 <sigtimedwait+0x1dc>
40007920: c0 26 60 08 clr [ %i1 + 8 ]
return signo;
}
the_info->si_signo = -1;
40007924: c2 26 40 00 st %g1, [ %i1 ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40007928: 03 10 00 67 sethi %hi(0x40019c00), %g1
4000792c: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 40019e90 <_Thread_Dispatch_disable_level>
++level;
40007930: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007934: c4 20 62 90 st %g2, [ %g1 + 0x290 ]
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
40007938: 82 10 20 04 mov 4, %g1
4000793c: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
the_thread->Wait.option = *set;
40007940: c2 06 00 00 ld [ %i0 ], %g1
the_thread->Wait.return_argument = the_info;
40007944: f2 27 60 28 st %i1, [ %i5 + 0x28 ]
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
40007948: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
4000794c: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
40007950: 35 10 00 69 sethi %hi(0x4001a400), %i2
40007954: b4 16 a1 8c or %i2, 0x18c, %i2 ! 4001a58c <_POSIX_signals_Wait_queue>
40007958: f4 27 60 44 st %i2, [ %i5 + 0x44 ]
4000795c: e2 26 a0 30 st %l1, [ %i2 + 0x30 ]
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
40007960: 7f ff eb 97 call 400027bc <sparc_enable_interrupts>
40007964: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
40007968: 90 10 00 1a mov %i2, %o0
4000796c: 92 10 00 1b mov %i3, %o1
40007970: 15 10 00 2c sethi %hi(0x4000b000), %o2
40007974: 40 00 0d 08 call 4000ad94 <_Thread_queue_Enqueue_with_handler>
40007978: 94 12 a1 00 or %o2, 0x100, %o2 ! 4000b100 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
4000797c: 40 00 0b d0 call 4000a8bc <_Thread_Enable_dispatch>
40007980: 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 );
40007984: d2 06 40 00 ld [ %i1 ], %o1
40007988: 90 10 00 1c mov %i4, %o0
4000798c: 94 10 00 19 mov %i1, %o2
40007990: 96 10 20 00 clr %o3
40007994: 40 00 16 cf call 4000d4d0 <_POSIX_signals_Clear_signals>
40007998: 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)
4000799c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
400079a0: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
400079a4: 80 a0 60 04 cmp %g1, 4
400079a8: 12 80 00 09 bne 400079cc <sigtimedwait+0x1c0>
400079ac: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
400079b0: fa 06 40 00 ld [ %i1 ], %i5
400079b4: 82 07 7f ff add %i5, -1, %g1
400079b8: a3 2c 40 01 sll %l1, %g1, %l1
400079bc: c2 06 00 00 ld [ %i0 ], %g1
400079c0: 80 8c 40 01 btst %l1, %g1
400079c4: 12 80 00 09 bne 400079e8 <sigtimedwait+0x1dc>
400079c8: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
400079cc: 40 00 21 30 call 4000fe8c <__errno>
400079d0: 01 00 00 00 nop
400079d4: 03 10 00 68 sethi %hi(0x4001a000), %g1
400079d8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001a3b0 <_Per_CPU_Information+0x10>
400079dc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
400079e0: c2 22 00 00 st %g1, [ %o0 ]
return -1;
400079e4: ba 10 3f ff mov -1, %i5
}
return the_info->si_signo;
}
400079e8: 81 c7 e0 08 ret
400079ec: 91 e8 00 1d restore %g0, %i5, %o0
40009724 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
40009724: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
40009728: 92 10 20 00 clr %o1
4000972c: 90 10 00 18 mov %i0, %o0
40009730: 7f ff ff 80 call 40009530 <sigtimedwait>
40009734: 94 10 20 00 clr %o2
if ( status != -1 ) {
40009738: 80 a2 3f ff cmp %o0, -1
4000973c: 02 80 00 06 be 40009754 <sigwait+0x30>
40009740: 80 a6 60 00 cmp %i1, 0
if ( sig )
40009744: 32 80 00 09 bne,a 40009768 <sigwait+0x44> <== ALWAYS TAKEN
40009748: d0 26 40 00 st %o0, [ %i1 ]
*sig = status;
return 0;
4000974c: 81 c7 e0 08 ret <== NOT EXECUTED
40009750: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
return errno;
40009754: 40 00 20 60 call 400118d4 <__errno>
40009758: 01 00 00 00 nop
4000975c: f0 02 00 00 ld [ %o0 ], %i0
40009760: 81 c7 e0 08 ret
40009764: 81 e8 00 00 restore
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
40009768: b0 10 20 00 clr %i0
}
return errno;
}
4000976c: 81 c7 e0 08 ret
40009770: 81 e8 00 00 restore
40005c64 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
40005c64: 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)) {
40005c68: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005c6c: 80 88 6e 78 btst 0xe78, %g1
40005c70: 02 80 00 0d be 40005ca4 <siproc+0x40> <== NEVER TAKEN
40005c74: 94 10 20 00 clr %o2
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005c78: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
40005c7c: 40 00 04 bd call 40006f70 <rtems_semaphore_obtain>
40005c80: 92 10 20 00 clr %o1
i = iproc (c, tty);
40005c84: 90 10 00 18 mov %i0, %o0
40005c88: 7f ff ff 6b call 40005a34 <iproc>
40005c8c: 92 10 00 19 mov %i1, %o1
40005c90: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
40005c94: 40 00 05 00 call 40007094 <rtems_semaphore_release>
40005c98: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
40005c9c: 81 c7 e0 08 ret
40005ca0: 81 e8 00 00 restore
}
else {
i = iproc (c, tty);
40005ca4: 7f ff ff 64 call 40005a34 <iproc> <== NOT EXECUTED
40005ca8: 81 e8 00 00 restore <== NOT EXECUTED
4000e094 <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 )
{
4000e094: 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 ) {
4000e098: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000e09c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000e0a0: 80 a6 40 01 cmp %i1, %g1
4000e0a4: 12 80 00 7f bne 4000e2a0 <sparse_disk_ioctl+0x20c>
4000e0a8: fa 06 20 3c ld [ %i0 + 0x3c ], %i5
rtems_blkdev_request *r = argp;
switch ( r->req ) {
4000e0ac: e8 06 80 00 ld [ %i2 ], %l4
4000e0b0: 80 a5 20 01 cmp %l4, 1
4000e0b4: 18 80 00 95 bgu 4000e308 <sparse_disk_ioctl+0x274> <== NEVER TAKEN
4000e0b8: 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 );
4000e0bc: d0 07 40 00 ld [ %i5 ], %o0
4000e0c0: 94 10 20 00 clr %o2
4000e0c4: 7f ff eb a8 call 40008f64 <rtems_semaphore_obtain>
4000e0c8: 25 10 00 38 sethi %hi(0x4000e000), %l2
static int sparse_disk_read_write(
rtems_sparse_disk *sparse_disk,
rtems_blkdev_request *req,
const bool read )
{
int rv = 0;
4000e0cc: b6 10 20 00 clr %i3
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
4000e0d0: b0 10 20 00 clr %i0
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
4000e0d4: 10 80 00 63 b 4000e260 <sparse_disk_ioctl+0x1cc>
4000e0d8: a4 14 a0 60 or %l2, 0x60, %l2
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
4000e0dc: a6 10 20 00 clr %l3
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
4000e0e0: 84 00 a0 18 add %g2, 0x18, %g2
4000e0e4: 82 06 80 02 add %i2, %g2, %g1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
4000e0e8: f2 06 80 02 ld [ %i2 + %g2 ], %i1
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
4000e0ec: ea 00 60 08 ld [ %g1 + 8 ], %l5
block = scatter_gather->block;
buff_size = scatter_gather->length;
4000e0f0: 10 80 00 54 b 4000e240 <sparse_disk_ioctl+0x1ac>
4000e0f4: f8 00 60 04 ld [ %g1 + 4 ], %i4
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
4000e0f8: c0 27 bf fc clr [ %fp + -4 ]
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
4000e0fc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
4000e100: 80 a5 20 00 cmp %l4, 0
4000e104: 12 80 00 1a bne 4000e16c <sparse_disk_ioctl+0xd8>
4000e108: a2 05 40 13 add %l5, %l3, %l1
4000e10c: 80 a7 00 01 cmp %i4, %g1
4000e110: 08 80 00 03 bleu 4000e11c <sparse_disk_ioctl+0x88>
4000e114: b6 10 00 1c mov %i4, %i3
4000e118: b6 10 00 01 mov %g1, %i3
size_t bytes_to_copy = sparse_disk->media_block_size;
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
4000e11c: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
4000e120: d4 07 60 08 ld [ %i5 + 8 ], %o2
4000e124: 90 07 bf f8 add %fp, -8, %o0
4000e128: 96 10 20 08 mov 8, %o3
4000e12c: 40 00 31 c6 call 4001a844 <bsearch>
4000e130: 98 10 00 12 mov %l2, %o4
4000e134: 82 10 00 08 mov %o0, %g1
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
4000e138: 80 a0 60 00 cmp %g1, 0
4000e13c: 02 80 00 07 be 4000e158 <sparse_disk_ioctl+0xc4>
4000e140: 90 10 00 11 mov %l1, %o0
memcpy( buffer, key->data, bytes_to_copy );
4000e144: d2 00 60 04 ld [ %g1 + 4 ], %o1
4000e148: 40 00 34 86 call 4001b360 <memcpy>
4000e14c: 94 10 00 1b mov %i3, %o2
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000e150: 10 80 00 3a b 4000e238 <sparse_disk_ioctl+0x1a4>
4000e154: b2 06 60 01 inc %i1
);
if ( NULL != key )
memcpy( buffer, key->data, bytes_to_copy );
else
memset( buffer, sparse_disk->fill_pattern, buffer_size );
4000e158: d2 0f 60 14 ldub [ %i5 + 0x14 ], %o1
4000e15c: 40 00 34 be call 4001b454 <memset>
4000e160: 94 10 00 1c mov %i4, %o2
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000e164: 10 80 00 35 b 4000e238 <sparse_disk_ioctl+0x1a4>
4000e168: b2 06 60 01 inc %i1
4000e16c: 80 a7 00 01 cmp %i4, %g1
4000e170: 08 80 00 03 bleu 4000e17c <sparse_disk_ioctl+0xe8>
4000e174: a0 10 00 1c mov %i4, %l0
4000e178: a0 10 00 01 mov %g1, %l0
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
4000e17c: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
4000e180: d4 07 60 08 ld [ %i5 + 8 ], %o2
4000e184: 90 07 bf f8 add %fp, -8, %o0
4000e188: 96 10 20 08 mov 8, %o3
4000e18c: 40 00 31 ae call 4001a844 <bsearch>
4000e190: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
4000e194: b6 92 20 00 orcc %o0, 0, %i3
4000e198: 32 80 00 23 bne,a 4000e224 <sparse_disk_ioctl+0x190>
4000e19c: d0 06 e0 04 ld [ %i3 + 4 ], %o0
4000e1a0: 10 80 00 08 b 4000e1c0 <sparse_disk_ioctl+0x12c>
4000e1a4: 84 10 20 00 clr %g2
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
if ( buffer[i] != sparse_disk->fill_pattern )
4000e1a8: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000e1ac: 82 00 60 01 inc %g1
if ( buffer[i] != sparse_disk->fill_pattern )
4000e1b0: 84 18 c0 02 xor %g3, %g2, %g2
4000e1b4: 80 a0 00 02 cmp %g0, %g2
4000e1b8: 10 80 00 03 b 4000e1c4 <sparse_disk_ioctl+0x130>
4000e1bc: 84 40 20 00 addx %g0, 0, %g2
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
4000e1c0: 82 10 20 00 clr %g1
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000e1c4: 80 a0 40 10 cmp %g1, %l0
4000e1c8: 1a 80 00 05 bcc 4000e1dc <sparse_disk_ioctl+0x148>
4000e1cc: 86 18 a0 01 xor %g2, 1, %g3
4000e1d0: 80 88 e0 ff btst 0xff, %g3
4000e1d4: 32 bf ff f5 bne,a 4000e1a8 <sparse_disk_ioctl+0x114>
4000e1d8: c6 0c 40 01 ldub [ %l1 + %g1 ], %g3
if ( buffer[i] != sparse_disk->fill_pattern )
block_needs_writing = true;
}
if ( block_needs_writing ) {
4000e1dc: 80 88 a0 ff btst 0xff, %g2
4000e1e0: 22 80 00 15 be,a 4000e234 <sparse_disk_ioctl+0x1a0>
4000e1e4: b6 10 00 10 mov %l0, %i3
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
4000e1e8: d2 07 60 08 ld [ %i5 + 8 ], %o1
4000e1ec: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000e1f0: 80 a2 40 01 cmp %o1, %g1
4000e1f4: 1a 80 00 10 bcc 4000e234 <sparse_disk_ioctl+0x1a0> <== NEVER TAKEN
4000e1f8: b6 10 3f ff mov -1, %i3
key = &sparse_disk->key_table[sparse_disk->used_count];
4000e1fc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
4000e200: 83 2a 60 03 sll %o1, 3, %g1
key->block = block;
4000e204: f2 22 00 01 st %i1, [ %o0 + %g1 ]
++sparse_disk->used_count;
4000e208: 92 02 60 01 inc %o1
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
key = &sparse_disk->key_table[sparse_disk->used_count];
4000e20c: b6 02 00 01 add %o0, %g1, %i3
key->block = block;
++sparse_disk->used_count;
4000e210: d2 27 60 08 st %o1, [ %i5 + 8 ]
qsort( sparse_disk->key_table, sparse_disk->used_count,
4000e214: 94 10 20 08 mov 8, %o2
4000e218: 40 00 34 d5 call 4001b56c <qsort>
4000e21c: 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 );
4000e220: d0 06 e0 04 ld [ %i3 + 4 ], %o0
4000e224: 92 10 00 11 mov %l1, %o1
4000e228: 40 00 34 4e call 4001b360 <memcpy>
4000e22c: 94 10 00 10 mov %l0, %o2
else if ( block_needs_writing )
return -1;
return bytes_to_copy;
4000e230: b6 10 00 10 mov %l0, %i3
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000e234: b2 06 60 01 inc %i1
bytes_handled += rv;
4000e238: a6 04 c0 1b add %l3, %i3, %l3
buff_size -= rv;
4000e23c: b8 27 00 1b sub %i4, %i3, %i4
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
4000e240: 80 a7 20 00 cmp %i4, 0
4000e244: 02 80 00 04 be 4000e254 <sparse_disk_ioctl+0x1c0>
4000e248: 80 a6 e0 00 cmp %i3, 0
4000e24c: 36 bf ff ab bge,a 4000e0f8 <sparse_disk_ioctl+0x64> <== ALWAYS TAKEN
4000e250: f2 27 bf f8 st %i1, [ %fp + -8 ]
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
4000e254: 80 a6 e0 00 cmp %i3, 0
4000e258: 06 80 00 06 bl 4000e270 <sparse_disk_ioctl+0x1dc> <== NEVER TAKEN
4000e25c: b0 06 20 01 inc %i0
( 0 <= rv ) && ( req_buffer < req->bufnum );
4000e260: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000e264: 80 a6 00 01 cmp %i0, %g1
4000e268: 0a bf ff 9d bcs 4000e0dc <sparse_disk_ioctl+0x48>
4000e26c: 85 2e 20 04 sll %i0, 4, %g2
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
4000e270: 7f ff eb 86 call 40009088 <rtems_semaphore_release>
4000e274: d0 07 40 00 ld [ %i5 ], %o0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
4000e278: 90 10 00 1a mov %i2, %o0
4000e27c: 92 10 20 1b mov 0x1b, %o1
if ( 0 > rv )
4000e280: 80 a6 e0 00 cmp %i3, 0
4000e284: 06 80 00 03 bl 4000e290 <sparse_disk_ioctl+0x1fc> <== NEVER TAKEN
4000e288: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000e28c: 92 10 20 00 clr %o1
4000e290: 9f c0 40 00 call %g1
4000e294: b0 10 20 00 clr %i0
4000e298: 81 c7 e0 08 ret
4000e29c: 81 e8 00 00 restore
case RTEMS_BLKDEV_REQ_WRITE:
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
4000e2a0: 03 08 00 10 sethi %hi(0x20004000), %g1
4000e2a4: 82 10 62 07 or %g1, 0x207, %g1 ! 20004207 <RAM_SIZE+0x1fc04207>
4000e2a8: 80 a6 40 01 cmp %i1, %g1
4000e2ac: 12 80 00 12 bne 4000e2f4 <sparse_disk_ioctl+0x260>
4000e2b0: 90 10 00 18 mov %i0, %o0
sc = rtems_semaphore_delete( sd->mutex );
4000e2b4: 7f ff ea fd call 40008ea8 <rtems_semaphore_delete>
4000e2b8: d0 07 40 00 ld [ %i5 ], %o0
if ( RTEMS_SUCCESSFUL != sc )
4000e2bc: 80 a2 20 00 cmp %o0, 0
4000e2c0: 22 80 00 05 be,a 4000e2d4 <sparse_disk_ioctl+0x240> <== ALWAYS TAKEN
4000e2c4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
rtems_fatal_error_occurred( 0xdeadbeef );
4000e2c8: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
4000e2cc: 7f ff ec ff call 400096c8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000e2d0: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
sd->mutex = RTEMS_ID_NONE;
4000e2d4: c0 27 40 00 clr [ %i5 ]
if ( NULL != sd->delete_handler )
4000e2d8: 80 a0 60 00 cmp %g1, 0
4000e2dc: 02 bf ff ef be 4000e298 <sparse_disk_ioctl+0x204> <== NEVER TAKEN
4000e2e0: b0 10 20 00 clr %i0
( *sd->delete_handler )( sd );
4000e2e4: 9f c0 40 00 call %g1
4000e2e8: 90 10 00 1d mov %i5, %o0
4000e2ec: 81 c7 e0 08 ret
4000e2f0: 81 e8 00 00 restore
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
4000e2f4: 92 10 00 19 mov %i1, %o1
4000e2f8: 40 00 0b 2f call 40010fb4 <rtems_blkdev_ioctl>
4000e2fc: 94 10 00 1a mov %i2, %o2
4000e300: 81 c7 e0 08 ret
4000e304: 91 e8 00 08 restore %g0, %o0, %o0
}
errno = EINVAL;
4000e308: 40 00 31 71 call 4001a8cc <__errno> <== NOT EXECUTED
4000e30c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e310: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000e314: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
4000e318: 81 c7 e0 08 ret <== NOT EXECUTED
4000e31c: 81 e8 00 00 restore <== NOT EXECUTED
400052fc <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
400052fc: 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;
40005300: c4 06 21 48 ld [ %i0 + 0x148 ], %g2
if ( this_reent ) {
40005304: 80 a0 a0 00 cmp %g2, 0
40005308: 02 80 00 0c be 40005338 <sync_per_thread+0x3c> <== NEVER TAKEN
4000530c: 3b 10 00 5f sethi %hi(0x40017c00), %i5
current_reent = _Thread_Executing->libc_reent;
40005310: ba 17 60 b0 or %i5, 0xb0, %i5 ! 40017cb0 <_Per_CPU_Information>
40005314: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
40005318: 13 10 00 14 sethi %hi(0x40005000), %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;
4000531c: f8 00 61 48 ld [ %g1 + 0x148 ], %i4
_Thread_Executing->libc_reent = this_reent;
40005320: c4 20 61 48 st %g2, [ %g1 + 0x148 ]
_fwalk (t->libc_reent, sync_wrapper);
40005324: d0 06 21 48 ld [ %i0 + 0x148 ], %o0
40005328: 40 00 2c 1d call 4001039c <_fwalk>
4000532c: 92 12 63 40 or %o1, 0x340, %o1
_Thread_Executing->libc_reent = current_reent;
40005330: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005334: f8 20 61 48 st %i4, [ %g1 + 0x148 ]
40005338: 81 c7 e0 08 ret
4000533c: 81 e8 00 00 restore
400065a0 <sysconf>:
*/
long sysconf(
int name
)
{
400065a0: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
400065a4: 80 a6 20 02 cmp %i0, 2
400065a8: 12 80 00 09 bne 400065cc <sysconf+0x2c>
400065ac: 03 10 00 59 sethi %hi(0x40016400), %g1
return (TOD_MICROSECONDS_PER_SECOND /
400065b0: 03 10 00 52 sethi %hi(0x40014800), %g1
400065b4: d2 00 63 d4 ld [ %g1 + 0x3d4 ], %o1 ! 40014bd4 <Configuration+0xc>
400065b8: 11 00 03 d0 sethi %hi(0xf4000), %o0
400065bc: 40 00 30 64 call 4001274c <.udiv>
400065c0: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
400065c4: 81 c7 e0 08 ret
400065c8: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
400065cc: 80 a6 20 04 cmp %i0, 4
400065d0: 02 80 00 13 be 4000661c <sysconf+0x7c>
400065d4: d0 00 60 08 ld [ %g1 + 8 ], %o0
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
400065d8: 80 a6 20 33 cmp %i0, 0x33
400065dc: 02 80 00 10 be 4000661c <sysconf+0x7c>
400065e0: 90 10 24 00 mov 0x400, %o0
return 1024;
if ( name == _SC_PAGESIZE )
400065e4: 80 a6 20 08 cmp %i0, 8
400065e8: 02 80 00 0d be 4000661c <sysconf+0x7c>
400065ec: 11 00 00 04 sethi %hi(0x1000), %o0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
400065f0: 80 a6 20 4f cmp %i0, 0x4f
400065f4: 02 80 00 0a be 4000661c <sysconf+0x7c> <== NEVER TAKEN
400065f8: 90 10 20 20 mov 0x20, %o0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
400065fc: 80 a6 22 03 cmp %i0, 0x203
40006600: 02 80 00 07 be 4000661c <sysconf+0x7c> <== NEVER TAKEN
40006604: 90 10 20 00 clr %o0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40006608: 40 00 20 de call 4000e980 <__errno>
4000660c: 01 00 00 00 nop
40006610: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40006614: c2 22 00 00 st %g1, [ %o0 ]
40006618: 90 10 3f ff mov -1, %o0
}
4000661c: b0 10 00 08 mov %o0, %i0
40006620: 81 c7 e0 08 ret
40006624: 81 e8 00 00 restore
400126e4 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
400126e4: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
400126e8: 80 a6 60 00 cmp %i1, 0
400126ec: 02 80 00 10 be 4001272c <tcsetattr+0x48>
400126f0: 80 a6 60 01 cmp %i1, 1
400126f4: 02 80 00 08 be 40012714 <tcsetattr+0x30>
400126f8: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
400126fc: 40 00 10 d7 call 40016a58 <__errno>
40012700: b0 10 3f ff mov -1, %i0
40012704: 82 10 20 86 mov 0x86, %g1
40012708: c2 22 00 00 st %g1, [ %o0 ]
4001270c: 81 c7 e0 08 ret
40012710: 81 e8 00 00 restore
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
40012714: 92 10 20 03 mov 3, %o1
40012718: 40 00 0d 70 call 40015cd8 <ioctl>
4001271c: 94 10 20 00 clr %o2
40012720: 80 a2 20 00 cmp %o0, 0
40012724: 26 80 00 04 bl,a 40012734 <tcsetattr+0x50> <== NEVER TAKEN
40012728: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4001272c: 40 00 0d 6b call 40015cd8 <ioctl>
40012730: 93 e8 20 02 restore %g0, 2, %o1
}
}
40012734: 81 c7 e0 08 ret <== NOT EXECUTED
40012738: 81 e8 00 00 restore <== NOT EXECUTED
40007e8c <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
40007e8c: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
40007e90: 80 a6 20 01 cmp %i0, 1
40007e94: 12 80 00 13 bne 40007ee0 <timer_create+0x54>
40007e98: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
40007e9c: 02 80 00 11 be 40007ee0 <timer_create+0x54>
40007ea0: 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) {
40007ea4: 02 80 00 13 be 40007ef0 <timer_create+0x64>
40007ea8: 03 10 00 8b sethi %hi(0x40022c00), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
40007eac: c2 06 40 00 ld [ %i1 ], %g1
40007eb0: 82 00 7f ff add %g1, -1, %g1
40007eb4: 80 a0 60 01 cmp %g1, 1
40007eb8: 28 80 00 03 bleu,a 40007ec4 <timer_create+0x38> <== ALWAYS TAKEN
40007ebc: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007ec0: 30 80 00 08 b,a 40007ee0 <timer_create+0x54> <== NOT EXECUTED
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
40007ec4: 80 a0 60 00 cmp %g1, 0
40007ec8: 32 80 00 03 bne,a 40007ed4 <timer_create+0x48> <== ALWAYS TAKEN
40007ecc: 82 00 7f ff add %g1, -1, %g1
40007ed0: 30 80 00 04 b,a 40007ee0 <timer_create+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
40007ed4: 80 a0 60 1f cmp %g1, 0x1f
40007ed8: 28 80 00 06 bleu,a 40007ef0 <timer_create+0x64> <== ALWAYS TAKEN
40007edc: 03 10 00 8b sethi %hi(0x40022c00), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
40007ee0: 40 00 22 ac call 40010990 <__errno>
40007ee4: 01 00 00 00 nop
40007ee8: 10 80 00 10 b 40007f28 <timer_create+0x9c>
40007eec: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40007ef0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
++level;
40007ef4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007ef8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
* 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 );
40007efc: 11 10 00 8b sethi %hi(0x40022c00), %o0
40007f00: 40 00 08 6e call 4000a0b8 <_Objects_Allocate>
40007f04: 90 12 23 14 or %o0, 0x314, %o0 ! 40022f14 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
40007f08: 80 a2 20 00 cmp %o0, 0
40007f0c: 12 80 00 0a bne 40007f34 <timer_create+0xa8>
40007f10: 82 10 20 02 mov 2, %g1
_Thread_Enable_dispatch();
40007f14: 40 00 0d 69 call 4000b4b8 <_Thread_Enable_dispatch>
40007f18: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
40007f1c: 40 00 22 9d call 40010990 <__errno>
40007f20: 01 00 00 00 nop
40007f24: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
40007f28: c2 22 00 00 st %g1, [ %o0 ]
40007f2c: 81 c7 e0 08 ret
40007f30: 91 e8 3f ff restore %g0, -1, %o0
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
40007f34: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
40007f38: 03 10 00 8c sethi %hi(0x40023000), %g1
40007f3c: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 ! 40023170 <_Per_CPU_Information+0x10>
if ( evp != NULL ) {
40007f40: 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;
40007f44: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
40007f48: 02 80 00 08 be 40007f68 <timer_create+0xdc>
40007f4c: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
40007f50: c2 06 40 00 ld [ %i1 ], %g1
40007f54: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
40007f58: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007f5c: c2 22 20 44 st %g1, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
40007f60: c2 06 60 08 ld [ %i1 + 8 ], %g1
40007f64: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007f68: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007f6c: 07 10 00 8b sethi %hi(0x40022c00), %g3
40007f70: c6 00 e3 30 ld [ %g3 + 0x330 ], %g3 ! 40022f30 <_POSIX_Timer_Information+0x1c>
}
ptimer->overrun = 0;
40007f74: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
40007f78: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
40007f7c: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
40007f80: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
40007f84: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40007f88: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
40007f8c: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
40007f90: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
40007f94: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007f98: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007f9c: 85 28 a0 02 sll %g2, 2, %g2
40007fa0: 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;
40007fa4: 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;
40007fa8: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
40007fac: 40 00 0d 43 call 4000b4b8 <_Thread_Enable_dispatch>
40007fb0: b0 10 20 00 clr %i0
return 0;
}
40007fb4: 81 c7 e0 08 ret
40007fb8: 81 e8 00 00 restore
40006a94 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
40006a94: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
40006a98: 80 a6 a0 00 cmp %i2, 0
40006a9c: 02 80 00 80 be 40006c9c <timer_settime+0x208> <== NEVER TAKEN
40006aa0: 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) ) ) {
40006aa4: 40 00 0f 36 call 4000a77c <_Timespec_Is_valid>
40006aa8: 90 06 a0 08 add %i2, 8, %o0
40006aac: 80 8a 20 ff btst 0xff, %o0
40006ab0: 02 80 00 7b be 40006c9c <timer_settime+0x208>
40006ab4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
40006ab8: 40 00 0f 31 call 4000a77c <_Timespec_Is_valid>
40006abc: 90 10 00 1a mov %i2, %o0
40006ac0: 80 8a 20 ff btst 0xff, %o0
40006ac4: 02 80 00 76 be 40006c9c <timer_settime+0x208> <== NEVER TAKEN
40006ac8: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
40006acc: 12 80 00 74 bne 40006c9c <timer_settime+0x208>
40006ad0: 90 07 bf f0 add %fp, -16, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
40006ad4: 92 10 00 1a mov %i2, %o1
40006ad8: 40 00 24 66 call 4000fc70 <memcpy>
40006adc: 94 10 20 10 mov 0x10, %o2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
40006ae0: 80 a6 60 04 cmp %i1, 4
40006ae4: 12 80 00 1f bne 40006b60 <timer_settime+0xcc>
40006ae8: 11 10 00 7b sethi %hi(0x4001ec00), %o0
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40006aec: 90 07 bf e0 add %fp, -32, %o0
40006af0: 13 10 00 7a sethi %hi(0x4001e800), %o1
40006af4: 40 00 06 74 call 400084c4 <_TOD_Get_with_nanoseconds>
40006af8: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4001ebb8 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40006afc: 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);
40006b00: 94 10 20 00 clr %o2
40006b04: 90 10 00 1c mov %i4, %o0
40006b08: 92 10 00 1d mov %i5, %o1
40006b0c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006b10: 40 00 48 92 call 40018d58 <__divdi3>
40006b14: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006b18: 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);
40006b1c: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006b20: 90 10 00 1c mov %i4, %o0
40006b24: 92 10 00 1d mov %i5, %o1
40006b28: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006b2c: 40 00 49 76 call 40019104 <__moddi3>
40006b30: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
/* 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 ) )
40006b34: 90 07 bf f8 add %fp, -8, %o0
40006b38: d2 27 bf ec st %o1, [ %fp + -20 ]
40006b3c: 40 00 0f 22 call 4000a7c4 <_Timespec_Less_than>
40006b40: 92 07 bf e8 add %fp, -24, %o1
40006b44: 80 8a 20 ff btst 0xff, %o0
40006b48: 12 80 00 55 bne 40006c9c <timer_settime+0x208>
40006b4c: 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 );
40006b50: 90 07 bf e8 add %fp, -24, %o0
40006b54: 40 00 0f 2c call 4000a804 <_Timespec_Subtract>
40006b58: 94 10 00 09 mov %o1, %o2
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
40006b5c: 11 10 00 7b sethi %hi(0x4001ec00), %o0
40006b60: 92 10 00 18 mov %i0, %o1
40006b64: 90 12 23 34 or %o0, 0x334, %o0
40006b68: 40 00 08 fe call 40008f60 <_Objects_Get>
40006b6c: 94 07 bf dc add %fp, -36, %o2
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
40006b70: c2 07 bf dc ld [ %fp + -36 ], %g1
40006b74: 80 a0 60 00 cmp %g1, 0
40006b78: 12 80 00 49 bne 40006c9c <timer_settime+0x208>
40006b7c: 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 ) {
40006b80: c2 07 bf f8 ld [ %fp + -8 ], %g1
40006b84: 80 a0 60 00 cmp %g1, 0
40006b88: 12 80 00 14 bne 40006bd8 <timer_settime+0x144>
40006b8c: c2 07 bf fc ld [ %fp + -4 ], %g1
40006b90: 80 a0 60 00 cmp %g1, 0
40006b94: 12 80 00 11 bne 40006bd8 <timer_settime+0x144>
40006b98: 01 00 00 00 nop
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
40006b9c: 40 00 10 28 call 4000ac3c <_Watchdog_Remove>
40006ba0: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
40006ba4: 80 a6 e0 00 cmp %i3, 0
40006ba8: 02 80 00 05 be 40006bbc <timer_settime+0x128>
40006bac: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
40006bb0: 92 06 60 54 add %i1, 0x54, %o1
40006bb4: 40 00 24 2f call 4000fc70 <memcpy>
40006bb8: 94 10 20 10 mov 0x10, %o2
/* The new data are set */
ptimer->timer_data = normalize;
40006bbc: 90 06 60 54 add %i1, 0x54, %o0
40006bc0: 92 07 bf f0 add %fp, -16, %o1
40006bc4: 40 00 24 2b call 4000fc70 <memcpy>
40006bc8: 94 10 20 10 mov 0x10, %o2
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
40006bcc: 82 10 20 04 mov 4, %g1
40006bd0: 10 80 00 2f b 40006c8c <timer_settime+0x1f8>
40006bd4: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
40006bd8: 40 00 0f 1c call 4000a848 <_Timespec_To_ticks>
40006bdc: 90 10 00 1a mov %i2, %o0
40006be0: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
40006be4: 40 00 0f 19 call 4000a848 <_Timespec_To_ticks>
40006be8: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
40006bec: 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 );
40006bf0: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
40006bf4: 17 10 00 1b sethi %hi(0x40006c00), %o3
40006bf8: 90 06 60 10 add %i1, 0x10, %o0
40006bfc: 96 12 e0 b4 or %o3, 0xb4, %o3
40006c00: 40 00 17 e3 call 4000cb8c <_POSIX_Timer_Insert_helper>
40006c04: 98 10 00 19 mov %i1, %o4
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
40006c08: 80 8a 20 ff btst 0xff, %o0
40006c0c: 02 80 00 20 be 40006c8c <timer_settime+0x1f8>
40006c10: 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 )
40006c14: 02 80 00 05 be 40006c28 <timer_settime+0x194>
40006c18: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
40006c1c: 92 06 60 54 add %i1, 0x54, %o1
40006c20: 40 00 24 14 call 4000fc70 <memcpy>
40006c24: 94 10 20 10 mov 0x10, %o2
ptimer->timer_data = normalize;
40006c28: 94 10 20 10 mov 0x10, %o2
40006c2c: 92 07 bf f0 add %fp, -16, %o1
40006c30: 40 00 24 10 call 4000fc70 <memcpy>
40006c34: 90 06 60 54 add %i1, 0x54, %o0
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
40006c38: 82 10 20 03 mov 3, %g1
40006c3c: 90 07 bf e0 add %fp, -32, %o0
40006c40: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
40006c44: 13 10 00 7a sethi %hi(0x4001e800), %o1
40006c48: 40 00 06 1f call 400084c4 <_TOD_Get_with_nanoseconds>
40006c4c: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4001ebb8 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40006c50: 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);
40006c54: 94 10 20 00 clr %o2
40006c58: 90 10 00 1c mov %i4, %o0
40006c5c: 92 10 00 1d mov %i5, %o1
40006c60: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006c64: 40 00 48 3d call 40018d58 <__divdi3>
40006c68: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006c6c: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
40006c70: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006c74: 94 10 20 00 clr %o2
40006c78: 92 10 00 1d mov %i5, %o1
40006c7c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006c80: 40 00 49 21 call 40019104 <__moddi3>
40006c84: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
40006c88: 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();
40006c8c: 40 00 0c 36 call 40009d64 <_Thread_Enable_dispatch>
40006c90: b0 10 20 00 clr %i0
40006c94: 81 c7 e0 08 ret
40006c98: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
40006c9c: 40 00 21 a4 call 4000f32c <__errno>
40006ca0: b0 10 3f ff mov -1, %i0
40006ca4: 82 10 20 16 mov 0x16, %g1
40006ca8: c2 22 00 00 st %g1, [ %o0 ]
}
40006cac: 81 c7 e0 08 ret
40006cb0: 81 e8 00 00 restore
40006964 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
40006964: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
40006968: 3b 10 00 62 sethi %hi(0x40018800), %i5
4000696c: ba 17 60 88 or %i5, 0x88, %i5 ! 40018888 <_POSIX_signals_Ualarm_timer>
40006970: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40006974: 80 a0 60 00 cmp %g1, 0
40006978: 12 80 00 0a bne 400069a0 <ualarm+0x3c>
4000697c: b8 10 00 18 mov %i0, %i4
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40006980: 03 10 00 1a sethi %hi(0x40006800), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40006984: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
40006988: 82 10 61 38 or %g1, 0x138, %g1
the_watchdog->id = id;
4000698c: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40006990: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40006994: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
40006998: 10 80 00 1b b 40006a04 <ualarm+0xa0>
4000699c: b0 10 20 00 clr %i0
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
400069a0: 40 00 0f 92 call 4000a7e8 <_Watchdog_Remove>
400069a4: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
400069a8: 90 02 3f fe add %o0, -2, %o0
400069ac: 80 a2 20 01 cmp %o0, 1
400069b0: 18 80 00 15 bgu 40006a04 <ualarm+0xa0> <== NEVER TAKEN
400069b4: 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);
400069b8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400069bc: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
400069c0: 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);
400069c4: 90 02 00 01 add %o0, %g1, %o0
400069c8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
400069cc: 40 00 0e 4d call 4000a300 <_Timespec_From_ticks>
400069d0: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
400069d4: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
400069d8: 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;
400069dc: 85 28 60 03 sll %g1, 3, %g2
400069e0: 87 28 60 08 sll %g1, 8, %g3
400069e4: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
400069e8: 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;
400069ec: b1 28 a0 06 sll %g2, 6, %i0
400069f0: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
400069f4: 40 00 34 d5 call 40013d48 <.div>
400069f8: 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;
400069fc: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
40006a00: b0 02 00 18 add %o0, %i0, %i0
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
40006a04: 80 a7 20 00 cmp %i4, 0
40006a08: 02 80 00 19 be 40006a6c <ualarm+0x108>
40006a0c: 3b 00 03 d0 sethi %hi(0xf4000), %i5
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
40006a10: 90 10 00 1c mov %i4, %o0
40006a14: 40 00 34 cb call 40013d40 <.udiv>
40006a18: 92 17 62 40 or %i5, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40006a1c: 92 17 62 40 or %i5, 0x240, %o1
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
40006a20: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40006a24: 40 00 35 73 call 40013ff0 <.urem>
40006a28: 90 10 00 1c mov %i4, %o0
40006a2c: 85 2a 20 07 sll %o0, 7, %g2
40006a30: 83 2a 20 02 sll %o0, 2, %g1
40006a34: 82 20 80 01 sub %g2, %g1, %g1
40006a38: 90 00 40 08 add %g1, %o0, %o0
40006a3c: 91 2a 20 03 sll %o0, 3, %o0
40006a40: d0 27 bf fc st %o0, [ %fp + -4 ]
ticks = _Timespec_To_ticks( &tp );
40006a44: 40 00 0e 44 call 4000a354 <_Timespec_To_ticks>
40006a48: 90 07 bf f8 add %fp, -8, %o0
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
40006a4c: 40 00 0e 42 call 4000a354 <_Timespec_To_ticks>
40006a50: 90 07 bf f8 add %fp, -8, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006a54: 13 10 00 62 sethi %hi(0x40018800), %o1
40006a58: 92 12 60 88 or %o1, 0x88, %o1 ! 40018888 <_POSIX_signals_Ualarm_timer>
40006a5c: d0 22 60 0c st %o0, [ %o1 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006a60: 11 10 00 60 sethi %hi(0x40018000), %o0
40006a64: 40 00 0f 09 call 4000a688 <_Watchdog_Insert>
40006a68: 90 12 20 38 or %o0, 0x38, %o0 ! 40018038 <_Watchdog_Ticks_chain>
}
return remaining;
}
40006a6c: 81 c7 e0 08 ret
40006a70: 81 e8 00 00 restore
4000652c <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 )
{
4000652c: 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 =
40006530: 94 10 20 18 mov 0x18, %o2
40006534: 92 10 00 18 mov %i0, %o1
40006538: 7f ff f7 09 call 4000415c <rtems_filesystem_eval_path_start>
4000653c: 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;
40006540: 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)(
40006544: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40006548: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000654c: 9f c0 40 00 call %g1
40006550: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
40006554: 80 8a 20 ff btst 0xff, %o0
40006558: 02 80 00 26 be 400065f0 <unmount+0xc4>
4000655c: 03 10 00 56 sethi %hi(0x40015800), %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;
40006560: c2 00 61 3c ld [ %g1 + 0x13c ], %g1 ! 4001593c <rtems_current_user_env>
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
40006564: c4 00 40 00 ld [ %g1 ], %g2
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
40006568: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000656c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40006570: 80 a7 40 01 cmp %i5, %g1
40006574: 22 80 00 06 be,a 4000658c <unmount+0x60>
40006578: 82 10 20 01 mov 1, %g1
4000657c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40006580: 82 1f 40 01 xor %i5, %g1, %g1
40006584: 80 a0 00 01 cmp %g0, %g1
40006588: 82 60 3f ff subx %g0, -1, %g1
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
4000658c: 80 a0 60 00 cmp %g1, 0
40006590: 12 80 00 14 bne 400065e0 <unmount+0xb4>
40006594: 01 00 00 00 nop
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
40006598: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000659c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
400065a0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400065a4: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
400065a8: 9f c0 40 00 call %g1
400065ac: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
400065b0: b0 92 20 00 orcc %o0, 0, %i0
400065b4: 12 80 00 14 bne 40006604 <unmount+0xd8>
400065b8: 01 00 00 00 nop
rtems_id self_task_id = rtems_task_self();
400065bc: 40 00 03 f6 call 40007594 <rtems_task_self>
400065c0: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
400065c4: 7f ff ee 8c call 40001ff4 <sparc_disable_interrupts>
400065c8: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
400065cc: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
400065d0: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
400065d4: 7f ff ee 8c call 40002004 <sparc_enable_interrupts>
400065d8: 01 00 00 00 nop
400065dc: 30 80 00 0a b,a 40006604 <unmount+0xd8>
}
} else {
errno = EBUSY;
400065e0: 40 00 21 42 call 4000eae8 <__errno>
400065e4: 01 00 00 00 nop
400065e8: 10 80 00 05 b 400065fc <unmount+0xd0>
400065ec: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10>
rv = -1;
}
} else {
errno = EACCES;
400065f0: 40 00 21 3e call 4000eae8 <__errno>
400065f4: 01 00 00 00 nop
400065f8: 82 10 20 0d mov 0xd, %g1 ! d <PROM_START+0xd>
400065fc: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
40006600: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
40006604: 7f ff f7 12 call 4000424c <rtems_filesystem_eval_path_cleanup>
40006608: 90 07 bf c8 add %fp, -56, %o0
if ( rv == 0 ) {
4000660c: 80 a6 20 00 cmp %i0, 0
40006610: 12 80 00 0b bne 4000663c <unmount+0x110>
40006614: 11 20 00 00 sethi %hi(0x80000000), %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40006618: 92 10 20 00 clr %o1
4000661c: 94 10 20 00 clr %o2
40006620: 40 00 03 19 call 40007284 <rtems_event_system_receive>
40006624: 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 ) {
40006628: 80 a2 20 00 cmp %o0, 0
4000662c: 02 80 00 04 be 4000663c <unmount+0x110> <== ALWAYS TAKEN
40006630: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
40006634: 40 00 04 77 call 40007810 <rtems_fatal_error_occurred> <== NOT EXECUTED
40006638: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
}
}
return rv;
}
4000663c: 81 c7 e0 08 ret
40006640: 81 e8 00 00 restore
4001ac98 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
4001ac98: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001ac9c: 03 10 00 75 sethi %hi(0x4001d400), %g1
4001aca0: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 4001d6e4 <rtems_libio_number_iops>
4001aca4: 80 a6 00 01 cmp %i0, %g1
4001aca8: 1a 80 00 16 bcc 4001ad00 <write+0x68>
4001acac: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
4001acb0: b1 2e 20 06 sll %i0, 6, %i0
4001acb4: b0 26 00 01 sub %i0, %g1, %i0
4001acb8: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001acbc: d0 00 60 70 ld [ %g1 + 0x70 ], %o0 ! 4001e070 <rtems_libio_iops>
4001acc0: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001acc4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001acc8: 80 88 61 00 btst 0x100, %g1
4001accc: 02 80 00 0d be 4001ad00 <write+0x68>
4001acd0: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001acd4: 12 80 00 06 bne 4001acec <write+0x54> <== ALWAYS TAKEN
4001acd8: 80 a6 a0 00 cmp %i2, 0
4001acdc: 7f ff cf 64 call 4000ea6c <__errno> <== NOT EXECUTED
4001ace0: 01 00 00 00 nop <== NOT EXECUTED
4001ace4: 10 80 00 0a b 4001ad0c <write+0x74> <== NOT EXECUTED
4001ace8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
4001acec: 02 80 00 10 be 4001ad2c <write+0x94>
4001acf0: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001acf4: 80 88 60 04 btst 4, %g1
4001acf8: 32 80 00 08 bne,a 4001ad18 <write+0x80>
4001acfc: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001ad00: 7f ff cf 5b call 4000ea6c <__errno>
4001ad04: 01 00 00 00 nop
4001ad08: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4001ad0c: c2 22 00 00 st %g1, [ %o0 ]
4001ad10: 81 c7 e0 08 ret
4001ad14: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
4001ad18: 92 10 00 19 mov %i1, %o1
4001ad1c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4001ad20: 9f c0 40 00 call %g1
4001ad24: 94 10 00 1a mov %i2, %o2
4001ad28: b0 10 00 08 mov %o0, %i0
}
4001ad2c: 81 c7 e0 08 ret
4001ad30: 81 e8 00 00 restore
40007430 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40007430: 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 );
40007434: 03 10 00 5a sethi %hi(0x40016800), %g1
40007438: c2 00 63 84 ld [ %g1 + 0x384 ], %g1 ! 40016b84 <rtems_libio_number_iops>
4000743c: 80 a6 00 01 cmp %i0, %g1
40007440: 2a 80 00 03 bcs,a 4000744c <writev+0x1c>
40007444: 83 2e 20 03 sll %i0, 3, %g1
40007448: 30 80 00 0c b,a 40007478 <writev+0x48>
iop = rtems_libio_iop( fd );
4000744c: b1 2e 20 06 sll %i0, 6, %i0
40007450: b0 26 00 01 sub %i0, %g1, %i0
40007454: 03 10 00 5d sethi %hi(0x40017400), %g1
40007458: f8 00 60 dc ld [ %g1 + 0xdc ], %i4 ! 400174dc <rtems_libio_iops>
4000745c: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
40007460: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40007464: 80 88 61 00 btst 0x100, %g1
40007468: 02 80 00 04 be 40007478 <writev+0x48>
4000746c: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40007470: 12 80 00 06 bne 40007488 <writev+0x58> <== ALWAYS TAKEN
40007474: 80 a6 60 00 cmp %i1, 0
40007478: 40 00 1f cc call 4000f3a8 <__errno>
4000747c: 01 00 00 00 nop
40007480: 10 80 00 20 b 40007500 <writev+0xd0>
40007484: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
40007488: 02 80 00 1b be 400074f4 <writev+0xc4>
4000748c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
40007490: 04 80 00 19 ble 400074f4 <writev+0xc4>
40007494: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
40007498: 24 80 00 03 ble,a 400074a4 <writev+0x74> <== ALWAYS TAKEN
4000749c: b5 2e a0 03 sll %i2, 3, %i2
400074a0: 30 80 00 15 b,a 400074f4 <writev+0xc4> <== NOT EXECUTED
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
400074a4: 82 10 20 00 clr %g1
400074a8: 86 10 20 01 mov 1, %g3
400074ac: 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 )
400074b0: c8 06 40 01 ld [ %i1 + %g1 ], %g4
400074b4: 80 a1 20 00 cmp %g4, 0
400074b8: 02 80 00 0f be 400074f4 <writev+0xc4>
400074bc: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
400074c0: c8 01 20 04 ld [ %g4 + 4 ], %g4
all_zeros = false;
400074c4: 80 a0 00 04 cmp %g0, %g4
400074c8: ba 40 3f ff addx %g0, -1, %i5
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
400074cc: 88 81 00 02 addcc %g4, %g2, %g4
400074d0: 0c 80 00 09 bneg 400074f4 <writev+0xc4>
400074d4: 86 08 c0 1d and %g3, %i5, %g3
400074d8: 80 a1 00 02 cmp %g4, %g2
400074dc: 06 80 00 03 bl 400074e8 <writev+0xb8>
400074e0: ba 10 20 01 mov 1, %i5
400074e4: ba 10 20 00 clr %i5
400074e8: 80 8f 60 ff btst 0xff, %i5
400074ec: 02 80 00 07 be 40007508 <writev+0xd8>
400074f0: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
400074f4: 40 00 1f ad call 4000f3a8 <__errno>
400074f8: 01 00 00 00 nop
400074fc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40007500: 10 80 00 21 b 40007584 <writev+0x154>
40007504: c2 22 00 00 st %g1, [ %o0 ]
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
40007508: 80 a0 40 1a cmp %g1, %i2
4000750c: 12 bf ff e9 bne 400074b0 <writev+0x80>
40007510: 84 10 00 04 mov %g4, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
40007514: 80 88 e0 ff btst 0xff, %g3
40007518: 12 80 00 19 bne 4000757c <writev+0x14c>
4000751c: b0 10 20 00 clr %i0
40007520: ba 10 20 00 clr %i5
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
40007524: b6 06 40 1d add %i1, %i5, %i3
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
40007528: d4 06 e0 04 ld [ %i3 + 4 ], %o2
4000752c: 80 a2 a0 00 cmp %o2, 0
40007530: 22 80 00 10 be,a 40007570 <writev+0x140> <== NEVER TAKEN
40007534: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
40007538: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000753c: d2 06 40 1d ld [ %i1 + %i5 ], %o1
40007540: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40007544: 9f c0 40 00 call %g1
40007548: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
4000754c: 80 a2 20 00 cmp %o0, 0
40007550: 26 80 00 0b bl,a 4000757c <writev+0x14c> <== NEVER TAKEN
40007554: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
40007558: 32 80 00 02 bne,a 40007560 <writev+0x130> <== ALWAYS TAKEN
4000755c: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40007560: c2 06 e0 04 ld [ %i3 + 4 ], %g1
40007564: 80 a2 00 01 cmp %o0, %g1
40007568: 12 80 00 05 bne 4000757c <writev+0x14c> <== NEVER TAKEN
4000756c: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40007570: 80 a7 40 1a cmp %i5, %i2
40007574: 12 bf ff ed bne 40007528 <writev+0xf8>
40007578: b6 06 40 1d add %i1, %i5, %i3
4000757c: 81 c7 e0 08 ret
40007580: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
40007584: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
40007588: 81 c7 e0 08 ret
4000758c: 81 e8 00 00 restore