RTEMS 4.11Annotated Report
Thu Dec 20 18:17:14 2012
4000bcd4 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
4000bcd4: 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();
4000bcd8: 40 00 02 6f call 4000c694 <geteuid>
4000bcdc: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000bce0: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000bce4: 91 2a 20 10 sll %o0, 0x10, %o0
4000bce8: 91 32 20 10 srl %o0, 0x10, %o0
4000bcec: 80 a2 00 01 cmp %o0, %g1
4000bcf0: 02 80 00 0a be 4000bd18 <IMFS_chown+0x44>
4000bcf4: 80 a2 20 00 cmp %o0, 0
4000bcf8: 22 80 00 09 be,a 4000bd1c <IMFS_chown+0x48> <== NEVER TAKEN
4000bcfc: f2 37 60 3c sth %i1, [ %i5 + 0x3c ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
4000bd00: 40 00 0f 79 call 4000fae4 <__errno>
4000bd04: b0 10 3f ff mov -1, %i0
4000bd08: 82 10 20 01 mov 1, %g1
4000bd0c: c2 22 00 00 st %g1, [ %o0 ]
4000bd10: 81 c7 e0 08 ret
4000bd14: 81 e8 00 00 restore
#endif
jnode->st_uid = owner;
4000bd18: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
4000bd1c: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
4000bd20: 90 07 bf f8 add %fp, -8, %o0
4000bd24: 7f ff e0 ea call 400040cc <gettimeofday>
4000bd28: 92 10 20 00 clr %o1
4000bd2c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000bd30: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000bd34: 81 c7 e0 08 ret
4000bd38: 91 e8 20 00 restore %g0, 0, %o0
400060b4 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
400060b4: 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, "...." );
400060b8: 35 10 00 8f sethi %hi(0x40023c00), %i2
400060bc: 39 10 00 97 sethi %hi(0x40025c00), %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
400060c0: 21 10 00 8f sethi %hi(0x40023c00), %l0
return;
}
puts("");
400060c4: 23 10 00 91 sethi %hi(0x40024400), %l1
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
400060c8: 25 10 00 8f sethi %hi(0x40023c00), %l2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
400060cc: 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, "...." );
400060d0: b4 16 a0 88 or %i2, 0x88, %i2
400060d4: b8 17 21 08 or %i4, 0x108, %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
400060d8: a0 14 20 f8 or %l0, 0xf8, %l0
return;
}
puts("");
400060dc: a2 14 61 f8 or %l1, 0x1f8, %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 );
400060e0: 10 80 00 4d b 40006214 <IMFS_dump_directory+0x160>
400060e4: a4 14 a0 e0 or %l2, 0xe0, %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
400060e8: 90 10 00 1a mov %i2, %o0
400060ec: 40 00 37 85 call 40013f00 <fputs>
400060f0: b6 06 e0 01 inc %i3
400060f4: 10 80 00 03 b 40006100 <IMFS_dump_directory+0x4c>
400060f8: c2 07 00 00 ld [ %i4 ], %g1
400060fc: 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++ )
40006100: 80 a6 c0 19 cmp %i3, %i1
40006104: 04 bf ff f9 ble 400060e8 <IMFS_dump_directory+0x34>
40006108: d2 00 60 08 ld [ %g1 + 8 ], %o1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4000610c: 40 00 37 7d call 40013f00 <fputs>
40006110: 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;
40006114: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
40006118: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
4000611c: 80 a2 a0 06 cmp %o2, 6
40006120: 38 80 00 2d bgu,a 400061d4 <IMFS_dump_directory+0x120> <== NEVER TAKEN
40006124: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
40006128: 95 2a a0 02 sll %o2, 2, %o2
4000612c: 03 10 00 18 sethi %hi(0x40006000), %g1
40006130: 82 10 60 98 or %g1, 0x98, %g1 ! 40006098 <bsp_interrupt_handler_default+0x18>
40006134: c2 00 40 0a ld [ %g1 + %o2 ], %g1
40006138: 81 c0 40 00 jmp %g1
4000613c: 01 00 00 00 nop
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
40006140: c2 07 00 00 ld [ %i4 ], %g1
40006144: 90 10 20 2f mov 0x2f, %o0
40006148: 40 00 37 3a call 40013e30 <fputc>
4000614c: d2 00 60 08 ld [ %g1 + 8 ], %o1
40006150: 30 80 00 26 b,a 400061e8 <IMFS_dump_directory+0x134>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
40006154: c2 07 00 00 ld [ %i4 ], %g1
40006158: 13 10 00 8f sethi %hi(0x40023c00), %o1
4000615c: d0 00 60 08 ld [ %g1 + 8 ], %o0
40006160: 92 12 60 90 or %o1, 0x90, %o1
40006164: 10 80 00 08 b 40006184 <IMFS_dump_directory+0xd0>
40006168: 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)",
4000616c: c2 07 00 00 ld [ %i4 ], %g1
40006170: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
40006174: d0 00 60 08 ld [ %g1 + 8 ], %o0
40006178: d6 07 60 58 ld [ %i5 + 0x58 ], %o3
4000617c: 13 10 00 8f sethi %hi(0x40023c00), %o1
40006180: 92 12 60 a8 or %o1, 0xa8, %o1 ! 40023ca8 <Callbacks.6428+0x158>
40006184: 40 00 37 0f call 40013dc0 <fprintf>
40006188: 01 00 00 00 nop
4000618c: 30 80 00 17 b,a 400061e8 <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 ")",
40006190: c2 07 00 00 ld [ %i4 ], %g1
40006194: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
40006198: d0 00 60 08 ld [ %g1 + 8 ], %o0
4000619c: 13 10 00 8f sethi %hi(0x40023c00), %o1
400061a0: 40 00 37 08 call 40013dc0 <fprintf>
400061a4: 92 12 60 b8 or %o1, 0xb8, %o1 ! 40023cb8 <Callbacks.6428+0x168>
400061a8: 30 80 00 10 b,a 400061e8 <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" );
400061ac: 11 10 00 8f sethi %hi(0x40023c00), %o0
400061b0: c2 07 00 00 ld [ %i4 ], %g1
400061b4: 10 80 00 04 b 400061c4 <IMFS_dump_directory+0x110>
400061b8: 90 12 20 c8 or %o0, 0xc8, %o0
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
400061bc: c2 07 00 00 ld [ %i4 ], %g1
400061c0: 90 10 00 12 mov %l2, %o0
400061c4: 40 00 37 4f call 40013f00 <fputs>
400061c8: 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;
400061cc: 10 80 00 0a b 400061f4 <IMFS_dump_directory+0x140>
400061d0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
400061d4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400061d8: 40 00 36 fa call 40013dc0 <fprintf> <== NOT EXECUTED
400061dc: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
400061e0: 10 80 00 05 b 400061f4 <IMFS_dump_directory+0x140> <== NOT EXECUTED
400061e4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
return;
}
puts("");
400061e8: 40 00 3e 2d call 40015a9c <puts>
400061ec: 90 10 00 11 mov %l1, %o0
400061f0: 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 ) )
400061f4: c2 00 40 00 ld [ %g1 ], %g1
400061f8: 80 a0 60 00 cmp %g1, 0
400061fc: 32 80 00 06 bne,a 40006214 <IMFS_dump_directory+0x160>
40006200: fa 07 40 00 ld [ %i5 ], %i5
IMFS_dump_directory( the_jnode, level + 1 );
40006204: 90 10 00 1d mov %i5, %o0
40006208: 7f ff ff ab call 400060b4 <IMFS_dump_directory>
4000620c: 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 ) {
40006210: 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 ));
40006214: 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 );
40006218: 80 a7 40 01 cmp %i5, %g1
4000621c: 12 bf ff b8 bne 400060fc <IMFS_dump_directory+0x48>
40006220: 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 );
}
}
40006224: 81 c7 e0 08 ret
40006228: 81 e8 00 00 restore
4000be78 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
4000be78: 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;
4000be7c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
4000be80: 90 10 00 18 mov %i0, %o0
4000be84: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
4000be88: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
4000be8c: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
4000be90: 40 00 03 18 call 4000caf0 <rtems_filesystem_eval_path_check_access>
4000be94: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
4000be98: 80 8a 20 ff btst 0xff, %o0
4000be9c: 12 80 00 04 bne 4000beac <IMFS_eval_token+0x34>
4000bea0: 80 a6 e0 01 cmp %i3, 1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000bea4: 81 c7 e0 08 ret
4000bea8: 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] == '.';
4000beac: 12 80 00 06 bne 4000bec4 <IMFS_eval_token+0x4c>
4000beb0: 82 10 20 00 clr %g1
4000beb4: c2 4e 80 00 ldsb [ %i2 ], %g1
4000beb8: 82 18 60 2e xor %g1, 0x2e, %g1
4000bebc: 80 a0 00 01 cmp %g0, %g1
4000bec0: 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 ) ) {
4000bec4: 80 a0 60 00 cmp %g1, 0
4000bec8: 12 80 00 2b bne 4000bf74 <IMFS_eval_token+0xfc>
4000becc: 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] == '.';
4000bed0: 12 80 00 0b bne 4000befc <IMFS_eval_token+0x84>
4000bed4: 80 a0 60 00 cmp %g1, 0
4000bed8: c4 4e 80 00 ldsb [ %i2 ], %g2
4000bedc: 80 a0 a0 2e cmp %g2, 0x2e
4000bee0: 12 80 00 07 bne 4000befc <IMFS_eval_token+0x84>
4000bee4: 80 a0 60 00 cmp %g1, 0
4000bee8: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
4000beec: 82 18 60 2e xor %g1, 0x2e, %g1
4000bef0: 80 a0 00 01 cmp %g0, %g1
4000bef4: 82 60 3f ff subx %g0, -1, %g1
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
4000bef8: 80 a0 60 00 cmp %g1, 0
4000befc: 22 80 00 04 be,a 4000bf0c <IMFS_eval_token+0x94>
4000bf00: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
return dir->Parent;
4000bf04: 10 80 00 17 b 4000bf60 <IMFS_eval_token+0xe8>
4000bf08: 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 );
4000bf0c: 10 80 00 10 b 4000bf4c <IMFS_eval_token+0xd4>
4000bf10: 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
4000bf14: 92 10 00 1a mov %i2, %o1
4000bf18: 40 00 14 ac call 400111c8 <strncmp>
4000bf1c: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
4000bf20: 80 a2 20 00 cmp %o0, 0
4000bf24: 12 80 00 06 bne 4000bf3c <IMFS_eval_token+0xc4>
4000bf28: 82 10 20 00 clr %g1
4000bf2c: 82 07 40 1b add %i5, %i3, %g1
4000bf30: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
4000bf34: 80 a0 00 01 cmp %g0, %g1
4000bf38: 82 60 3f ff subx %g0, -1, %g1
if ( match ) {
4000bf3c: 80 a0 60 00 cmp %g1, 0
4000bf40: 12 80 00 09 bne 4000bf64 <IMFS_eval_token+0xec>
4000bf44: 80 a7 60 00 cmp %i5, 0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000bf48: 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 ) {
4000bf4c: 80 a7 40 19 cmp %i5, %i1
4000bf50: 12 bf ff f1 bne 4000bf14 <IMFS_eval_token+0x9c>
4000bf54: 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;
4000bf58: 81 c7 e0 08 ret
4000bf5c: 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 ) {
4000bf60: 80 a7 60 00 cmp %i5, 0
4000bf64: 32 80 00 06 bne,a 4000bf7c <IMFS_eval_token+0x104>
4000bf68: 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;
4000bf6c: 81 c7 e0 08 ret
4000bf70: 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 ) ) {
4000bf74: 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 );
4000bf78: 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;
4000bf7c: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
4000bf80: 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;
4000bf84: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000bf88: 84 60 3f ff subx %g0, -1, %g2
4000bf8c: 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;
4000bf90: 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)) {
4000bf94: 80 a0 60 02 cmp %g1, 2
4000bf98: 12 80 00 0a bne 4000bfc0 <IMFS_eval_token+0x148>
4000bf9c: 88 10 00 02 mov %g2, %g4
4000bfa0: 80 a0 a0 00 cmp %g2, 0
4000bfa4: 22 80 00 2b be,a 4000c050 <IMFS_eval_token+0x1d8>
4000bfa8: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
4000bfac: 80 88 e0 08 btst 8, %g3
4000bfb0: 22 80 00 29 be,a 4000c054 <IMFS_eval_token+0x1dc>
4000bfb4: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
entry = entry->info.hard_link.link_node;
4000bfb8: 10 80 00 26 b 4000c050 <IMFS_eval_token+0x1d8>
4000bfbc: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
4000bfc0: 80 a0 60 03 cmp %g1, 3
4000bfc4: 12 80 00 10 bne 4000c004 <IMFS_eval_token+0x18c>
4000bfc8: 80 a0 60 00 cmp %g1, 0
4000bfcc: 80 a0 a0 00 cmp %g2, 0
4000bfd0: 02 80 00 04 be 4000bfe0 <IMFS_eval_token+0x168>
4000bfd4: 80 88 e0 10 btst 0x10, %g3
4000bfd8: 22 80 00 1f be,a 4000c054 <IMFS_eval_token+0x1dc>
4000bfdc: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
const char *target = entry->info.sym_link.name;
4000bfe0: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
4000bfe4: 40 00 14 47 call 40011100 <strlen>
4000bfe8: 90 10 00 1d mov %i5, %o0
4000bfec: 92 10 00 1d mov %i5, %o1
4000bff0: 94 10 00 08 mov %o0, %o2
4000bff4: 7f ff e4 cf call 40005330 <rtems_filesystem_eval_path_recursive>
4000bff8: 90 10 00 18 mov %i0, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000bffc: 81 c7 e0 08 ret
4000c000: 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 ) {
4000c004: 32 80 00 14 bne,a 4000c054 <IMFS_eval_token+0x1dc>
4000c008: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
if ( node->info.directory.mt_fs != NULL ) {
4000c00c: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
4000c010: 80 a2 60 00 cmp %o1, 0
4000c014: 02 80 00 0f be 4000c050 <IMFS_eval_token+0x1d8>
4000c018: 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(
4000c01c: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
4000c020: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
4000c024: 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;
4000c028: 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(
4000c02c: 40 00 02 b1 call 4000caf0 <rtems_filesystem_eval_path_check_access>
4000c030: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
4000c034: 80 8a 20 ff btst 0xff, %o0
4000c038: 02 80 00 04 be 4000c048 <IMFS_eval_token+0x1d0> <== NEVER TAKEN
4000c03c: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
4000c040: 7f ff e4 a3 call 400052cc <rtems_filesystem_eval_path_restart>
4000c044: 92 10 00 1c mov %i4, %o1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000c048: 81 c7 e0 08 ret
4000c04c: 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;
4000c050: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
4000c054: 82 00 7f ff add %g1, -1, %g1
4000c058: c2 37 20 34 sth %g1, [ %i4 + 0x34 ]
++entry->reference_count;
4000c05c: c2 17 60 34 lduh [ %i5 + 0x34 ], %g1
4000c060: 82 00 60 01 inc %g1
4000c064: 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;
4000c068: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
currentloc->node_access = entry;
4000c06c: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
4000c070: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000c074: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000c078: b0 09 20 ff and %g4, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
4000c07c: 81 c7 e0 08 ret
4000c080: 81 e8 00 00 restore
4000c09c <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4000c09c: 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();
4000c0a0: 40 00 01 7d call 4000c694 <geteuid>
4000c0a4: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000c0a8: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000c0ac: 91 2a 20 10 sll %o0, 0x10, %o0
4000c0b0: 91 32 20 10 srl %o0, 0x10, %o0
4000c0b4: 80 a2 00 01 cmp %o0, %g1
4000c0b8: 02 80 00 0a be 4000c0e0 <IMFS_fchmod+0x44>
4000c0bc: 80 a2 20 00 cmp %o0, 0
4000c0c0: 22 80 00 09 be,a 4000c0e4 <IMFS_fchmod+0x48> <== NEVER TAKEN
4000c0c4: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
4000c0c8: 40 00 0e 87 call 4000fae4 <__errno>
4000c0cc: b0 10 3f ff mov -1, %i0
4000c0d0: 82 10 20 01 mov 1, %g1
4000c0d4: c2 22 00 00 st %g1, [ %o0 ]
4000c0d8: 81 c7 e0 08 ret
4000c0dc: 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);
4000c0e0: 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 );
4000c0e4: 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);
4000c0e8: 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 );
4000c0ec: 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);
4000c0f0: b2 0e 6f ff and %i1, 0xfff, %i1
4000c0f4: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
4000c0f8: 7f ff df f5 call 400040cc <gettimeofday>
4000c0fc: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
4000c100: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000c104: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000c108: 81 c7 e0 08 ret
4000c10c: 91 e8 20 00 restore %g0, 0, %o0
400042b4 <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
400042b4: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
400042b8: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
400042bc: 96 10 00 18 mov %i0, %o3
400042c0: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
400042c4: 92 10 00 19 mov %i1, %o1
400042c8: 40 00 28 f5 call 4000e69c <pipe_write>
400042cc: 94 10 00 1a mov %i2, %o2
if (err > 0) {
400042d0: b0 92 20 00 orcc %o0, 0, %i0
400042d4: 04 80 00 09 ble 400042f8 <IMFS_fifo_write+0x44>
400042d8: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
400042dc: 40 00 03 86 call 400050f4 <gettimeofday>
400042e0: 92 10 20 00 clr %o1
400042e4: c2 07 bf f8 ld [ %fp + -8 ], %g1
400042e8: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
400042ec: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
400042f0: 81 c7 e0 08 ret
400042f4: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
400042f8: 80 a6 20 00 cmp %i0, 0
400042fc: 02 80 00 06 be 40004314 <IMFS_fifo_write+0x60> <== NEVER TAKEN
40004300: 01 00 00 00 nop
40004304: 40 00 34 fb call 400116f0 <__errno>
40004308: b0 20 00 18 neg %i0
4000430c: f0 22 00 00 st %i0, [ %o0 ]
40004310: b0 10 3f ff mov -1, %i0
}
40004314: 81 c7 e0 08 ret
40004318: 81 e8 00 00 restore
4000c110 <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
)
{
4000c110: 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;
4000c114: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
4000c118: b8 07 bf e8 add %fp, -24, %i4
4000c11c: 92 10 00 1b mov %i3, %o1
4000c120: 90 10 00 1c mov %i4, %o0
4000c124: 40 00 10 c1 call 40010428 <memcpy>
4000c128: 94 10 20 18 mov 0x18, %o2
jnode = (IMFS_jnode_t *)loc.node_access;
4000c12c: 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;
4000c130: c0 26 e0 08 clr [ %i3 + 8 ]
4000c134: b6 10 00 1c mov %i4, %i3
4000c138: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
do {
next = jnode->Parent;
4000c13c: f8 07 60 08 ld [ %i5 + 8 ], %i4
4000c140: 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 ) ) {
4000c144: 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;
4000c148: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000c14c: 80 a0 60 00 cmp %g1, 0
4000c150: 12 80 00 07 bne 4000c16c <IMFS_fsunmount+0x5c>
4000c154: c4 27 bf f8 st %g2, [ %fp + -8 ]
4000c158: 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 );
4000c15c: 82 07 60 54 add %i5, 0x54, %g1
4000c160: 80 a0 80 01 cmp %g2, %g1
4000c164: 32 80 00 10 bne,a 4000c1a4 <IMFS_fsunmount+0x94>
4000c168: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
result = IMFS_rmnod( NULL, &loc );
4000c16c: 90 10 20 00 clr %o0
4000c170: 7f ff de 4d call 40003aa4 <IMFS_rmnod>
4000c174: 92 10 00 1b mov %i3, %o1
if ( result != 0 )
4000c178: 80 a2 20 00 cmp %o0, 0
4000c17c: 02 80 00 04 be 4000c18c <IMFS_fsunmount+0x7c> <== ALWAYS TAKEN
4000c180: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
4000c184: 7f ff f1 76 call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000c188: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
IMFS_node_destroy( jnode );
4000c18c: 7f ff dd 74 call 4000375c <IMFS_node_destroy>
4000c190: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
4000c194: 80 a7 20 00 cmp %i4, 0
4000c198: 02 80 00 0e be 4000c1d0 <IMFS_fsunmount+0xc0>
4000c19c: 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;
4000c1a0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( IMFS_is_directory( jnode ) ) {
4000c1a4: c2 00 40 00 ld [ %g1 ], %g1
4000c1a8: 80 a0 60 00 cmp %g1, 0
4000c1ac: 32 bf ff e4 bne,a 4000c13c <IMFS_fsunmount+0x2c> <== NEVER TAKEN
4000c1b0: 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;
4000c1b4: 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 );
4000c1b8: 84 07 60 54 add %i5, 0x54, %g2
if ( jnode_has_children( jnode ) )
4000c1bc: 80 a0 40 02 cmp %g1, %g2
4000c1c0: 02 bf ff de be 4000c138 <IMFS_fsunmount+0x28>
4000c1c4: 80 a0 60 00 cmp %g1, 0
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
4000c1c8: 12 bf ff dc bne 4000c138 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
4000c1cc: ba 10 00 01 mov %g1, %i5
4000c1d0: 81 c7 e0 08 ret
4000c1d4: 81 e8 00 00 restore
40003650 <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]
)
{
40003650: 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 ) );
40003654: 90 10 20 01 mov 1, %o0
40003658: 40 00 01 c0 call 40003d58 <calloc>
4000365c: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
40003660: ba 92 20 00 orcc %o0, 0, %i5
40003664: 02 80 00 24 be 400036f4 <IMFS_initialize_support+0xa4>
40003668: 03 10 00 7b sethi %hi(0x4001ec00), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
4000366c: c4 00 62 fc ld [ %g1 + 0x2fc ], %g2 ! 4001eefc <imfs_instance.6621>
memcpy(
40003670: 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++;
40003674: c4 27 40 00 st %g2, [ %i5 ]
40003678: 84 00 a0 01 inc %g2
memcpy(
4000367c: 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++;
40003680: c4 20 62 fc st %g2, [ %g1 + 0x2fc ]
memcpy(
40003684: 40 00 33 69 call 40010428 <memcpy>
40003688: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
4000368c: d2 07 60 08 ld [ %i5 + 8 ], %o1
40003690: 90 10 00 1d mov %i5, %o0
40003694: 15 10 00 74 sethi %hi(0x4001d000), %o2
40003698: 96 10 20 00 clr %o3
4000369c: 94 12 a3 18 or %o2, 0x318, %o2
400036a0: 19 00 00 10 sethi %hi(0x4000), %o4
400036a4: 9a 10 20 00 clr %o5
400036a8: 40 00 21 a5 call 4000bd3c <IMFS_allocate_node>
400036ac: 98 13 21 ed or %o4, 0x1ed, %o4
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
400036b0: 80 a2 20 00 cmp %o0, 0
400036b4: 02 80 00 10 be 400036f4 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
400036b8: 03 10 00 75 sethi %hi(0x4001d400), %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;
400036bc: 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;
400036c0: 82 10 61 84 or %g1, 0x184, %g1
400036c4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
400036c8: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
400036cc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
400036d0: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->ops = op_table;
400036d4: f2 26 20 0c st %i1, [ %i0 + 0xc ]
400036d8: 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;
400036dc: d0 20 60 08 st %o0, [ %g1 + 8 ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
400036e0: 86 10 20 06 mov 6, %g3
400036e4: 03 10 00 79 sethi %hi(0x4001e400), %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
400036e8: 84 10 20 10 mov 0x10, %g2
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
400036ec: 10 80 00 08 b 4000370c <IMFS_initialize_support+0xbc>
400036f0: c2 00 63 70 ld [ %g1 + 0x370 ], %g1
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
400036f4: 40 00 30 fc call 4000fae4 <__errno>
400036f8: b0 10 3f ff mov -1, %i0
400036fc: 82 10 20 0c mov 0xc, %g1
40003700: c2 22 00 00 st %g1, [ %o0 ]
40003704: 81 c7 e0 08 ret
40003708: 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) {
4000370c: 80 a0 80 01 cmp %g2, %g1
40003710: 22 80 00 09 be,a 40003734 <IMFS_initialize_support+0xe4>
40003714: 05 10 00 7b sethi %hi(0x4001ec00), %g2
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
40003718: 34 80 00 06 bg,a 40003730 <IMFS_initialize_support+0xe0>
4000371c: 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) {
40003720: 86 80 ff ff addcc %g3, -1, %g3
40003724: 12 bf ff fa bne 4000370c <IMFS_initialize_support+0xbc> <== ALWAYS TAKEN
40003728: 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);
4000372c: 82 10 20 80 mov 0x80, %g1 <== NOT EXECUTED
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
40003730: 05 10 00 7b sethi %hi(0x4001ec00), %g2
40003734: c2 20 a2 f8 st %g1, [ %g2 + 0x2f8 ] ! 4001eef8 <imfs_memfile_bytes_per_block>
40003738: b0 10 20 00 clr %i0
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
4000373c: 81 c7 e0 08 ret
40003740: 81 e8 00 00 restore
40005420 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
40005420: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40005424: 03 10 00 6c sethi %hi(0x4001b000), %g1
40005428: c2 00 62 3c ld [ %g1 + 0x23c ], %g1 ! 4001b23c <rtems_current_user_env>
switch (mode & S_IFMT) {
4000542c: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
40005430: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005434: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
40005438: 03 00 00 3c sethi %hi(0xf000), %g1
4000543c: 82 0e 40 01 and %i1, %g1, %g1
40005440: 80 a0 40 02 cmp %g1, %g2
40005444: 22 80 00 3a be,a 4000552c <IMFS_make_generic_node+0x10c>
40005448: c2 06 80 00 ld [ %i2 ], %g1
4000544c: 38 80 00 04 bgu,a 4000545c <IMFS_make_generic_node+0x3c> <== ALWAYS TAKEN
40005450: 05 00 00 18 sethi %hi(0x6000), %g2
40005454: 10 80 00 05 b 40005468 <IMFS_make_generic_node+0x48> <== NOT EXECUTED
40005458: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
4000545c: 80 a0 40 02 cmp %g1, %g2
40005460: 02 80 00 32 be 40005528 <IMFS_make_generic_node+0x108>
40005464: 05 00 00 20 sethi %hi(0x8000), %g2
40005468: 80 a0 40 02 cmp %g1, %g2
4000546c: 22 80 00 30 be,a 4000552c <IMFS_make_generic_node+0x10c> <== NEVER TAKEN
40005470: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
40005474: 30 80 00 27 b,a 40005510 <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 =
40005478: 94 10 20 78 mov 0x78, %o2
4000547c: 40 00 07 4e call 400071b4 <rtems_filesystem_eval_path_start>
40005480: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
40005484: 7f ff ff d5 call 400053d8 <IMFS_is_imfs_instance>
40005488: ba 10 00 08 mov %o0, %i5
4000548c: 80 8a 20 ff btst 0xff, %o0
40005490: 02 80 00 19 be 400054f4 <IMFS_make_generic_node+0xd4>
40005494: 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(
40005498: 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;
4000549c: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
400054a0: 90 10 00 1d mov %i5, %o0
400054a4: 92 10 00 1a mov %i2, %o1
400054a8: 98 10 00 19 mov %i1, %o4
400054ac: 9a 07 bf b0 add %fp, -80, %o5
400054b0: 40 00 2d 13 call 400108fc <IMFS_create_node_with_control>
400054b4: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
400054b8: 80 a2 20 00 cmp %o0, 0
400054bc: 02 80 00 11 be 40005500 <IMFS_make_generic_node+0xe0>
400054c0: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
400054c4: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
400054c8: 40 00 02 08 call 40005ce8 <gettimeofday>
400054cc: 90 07 bf a8 add %fp, -88, %o0
400054d0: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
400054d4: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
400054d8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
400054dc: 40 00 02 03 call 40005ce8 <gettimeofday>
400054e0: 92 10 20 00 clr %o1
400054e4: c2 07 bf a8 ld [ %fp + -88 ], %g1
400054e8: b0 10 20 00 clr %i0
400054ec: 10 80 00 05 b 40005500 <IMFS_make_generic_node+0xe0>
400054f0: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
400054f4: 92 10 20 86 mov 0x86, %o1
400054f8: 40 00 06 99 call 40006f5c <rtems_filesystem_eval_path_error>
400054fc: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40005500: 40 00 07 69 call 400072a4 <rtems_filesystem_eval_path_cleanup>
40005504: 90 07 bf c8 add %fp, -56, %o0
40005508: 81 c7 e0 08 ret
4000550c: 81 e8 00 00 restore
} else {
errno = EINVAL;
40005510: 40 00 3c 84 call 40014720 <__errno>
40005514: b0 10 3f ff mov -1, %i0
40005518: 82 10 20 16 mov 0x16, %g1
4000551c: c2 22 00 00 st %g1, [ %o0 ]
40005520: 81 c7 e0 08 ret
40005524: 81 e8 00 00 restore
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
40005528: c2 06 80 00 ld [ %i2 ], %g1
4000552c: 80 a0 60 07 cmp %g1, 7
40005530: 02 bf ff d2 be 40005478 <IMFS_make_generic_node+0x58>
40005534: 92 10 00 18 mov %i0, %o1
40005538: 30 bf ff f6 b,a 40005510 <IMFS_make_generic_node+0xf0>
4000e708 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000e708: 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 );
4000e70c: 94 10 20 01 mov 1, %o2
4000e710: 90 10 00 18 mov %i0, %o0
4000e714: 7f ff fe d7 call 4000e270 <IMFS_memfile_get_block_pointer>
4000e718: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
4000e71c: 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 );
4000e720: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
4000e724: 80 a0 60 00 cmp %g1, 0
4000e728: 12 80 00 08 bne 4000e748 <IMFS_memfile_addblock+0x40>
4000e72c: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
4000e730: 7f ff fe c3 call 4000e23c <memfile_alloc_block>
4000e734: 01 00 00 00 nop
if ( !memory )
4000e738: 80 a2 20 00 cmp %o0, 0
4000e73c: 22 80 00 03 be,a 4000e748 <IMFS_memfile_addblock+0x40> <== NEVER TAKEN
4000e740: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
*block_entry_ptr = memory;
4000e744: d0 27 40 00 st %o0, [ %i5 ]
return 0;
4000e748: 81 c7 e0 08 ret
4000e74c: 81 e8 00 00 restore
4000e91c <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
4000e91c: 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 )
4000e920: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000e924: fa 00 62 f8 ld [ %g1 + 0x2f8 ], %i5 ! 4001eef8 <imfs_memfile_bytes_per_block>
4000e928: b9 37 60 02 srl %i5, 2, %i4
4000e92c: 92 10 00 1c mov %i4, %o1
4000e930: 40 00 28 a2 call 40018bb8 <.umul>
4000e934: 90 07 20 01 add %i4, 1, %o0
4000e938: 92 10 00 1c mov %i4, %o1
4000e93c: 40 00 28 9f call 40018bb8 <.umul>
4000e940: 90 02 20 01 inc %o0
4000e944: 92 10 00 1d mov %i5, %o1
4000e948: 40 00 28 9c call 40018bb8 <.umul>
4000e94c: 90 02 3f ff add %o0, -1, %o0
4000e950: 82 10 20 00 clr %g1
4000e954: 80 a0 40 1a cmp %g1, %i2
4000e958: 34 80 00 0b bg,a 4000e984 <IMFS_memfile_extend+0x68> <== NEVER TAKEN
4000e95c: f8 06 20 50 ld [ %i0 + 0x50 ], %i4 <== NOT EXECUTED
4000e960: 80 a0 40 1a cmp %g1, %i2
4000e964: 12 80 00 04 bne 4000e974 <IMFS_memfile_extend+0x58> <== NEVER TAKEN
4000e968: 80 a2 00 1b cmp %o0, %i3
4000e96c: 38 80 00 06 bgu,a 4000e984 <IMFS_memfile_extend+0x68>
4000e970: f8 06 20 50 ld [ %i0 + 0x50 ], %i4
rtems_set_errno_and_return_minus_one( EFBIG );
4000e974: 40 00 04 5c call 4000fae4 <__errno>
4000e978: 01 00 00 00 nop
4000e97c: 10 80 00 3c b 4000ea6c <IMFS_memfile_extend+0x150>
4000e980: 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 )
4000e984: 80 a6 80 1c cmp %i2, %i4
4000e988: 14 80 00 07 bg 4000e9a4 <IMFS_memfile_extend+0x88> <== NEVER TAKEN
4000e98c: e0 06 20 54 ld [ %i0 + 0x54 ], %l0
4000e990: 80 a6 80 1c cmp %i2, %i4
4000e994: 12 80 00 48 bne 4000eab4 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
4000e998: 80 a6 c0 10 cmp %i3, %l0
4000e99c: 08 80 00 46 bleu 4000eab4 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
4000e9a0: 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;
4000e9a4: a3 3f 60 1f sra %i5, 0x1f, %l1
4000e9a8: 96 10 00 1d mov %i5, %o3
4000e9ac: 94 10 00 11 mov %l1, %o2
4000e9b0: 90 10 00 1a mov %i2, %o0
4000e9b4: 40 00 2a 13 call 40019200 <__divdi3>
4000e9b8: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e9bc: 94 10 00 11 mov %l1, %o2
4000e9c0: 90 10 00 1c mov %i4, %o0
4000e9c4: 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;
4000e9c8: a4 10 00 09 mov %o1, %l2
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e9cc: 40 00 2a 0d call 40019200 <__divdi3>
4000e9d0: 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++ ) {
4000e9d4: 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;
4000e9d8: 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;
4000e9dc: 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;
4000e9e0: 27 10 00 7b sethi %hi(0x4001ec00), %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;
4000e9e4: 40 00 28 75 call 40018bb8 <.umul>
4000e9e8: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000e9ec: 10 80 00 23 b 4000ea78 <IMFS_memfile_extend+0x15c>
4000e9f0: a0 24 00 08 sub %l0, %o0, %l0
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
4000e9f4: 7f ff ff 45 call 4000e708 <IMFS_memfile_addblock>
4000e9f8: 92 10 00 1d mov %i5, %o1
4000e9fc: 80 a2 20 00 cmp %o0, 0
4000ea00: 12 80 00 15 bne 4000ea54 <IMFS_memfile_extend+0x138> <== NEVER TAKEN
4000ea04: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
4000ea08: 22 80 00 1c be,a 4000ea78 <IMFS_memfile_extend+0x15c>
4000ea0c: a2 04 60 01 inc %l1
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
4000ea10: e8 04 e2 f8 ld [ %l3 + 0x2f8 ], %l4
block_p *block_ptr =
4000ea14: 92 10 00 1d mov %i5, %o1
4000ea18: 94 10 20 00 clr %o2
4000ea1c: 7f ff fe 15 call 4000e270 <IMFS_memfile_get_block_pointer>
4000ea20: 90 10 00 18 mov %i0, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
4000ea24: 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;
4000ea28: 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);
4000ea2c: 90 02 00 10 add %o0, %l0, %o0
4000ea30: 92 10 20 00 clr %o1
4000ea34: 94 10 00 14 mov %l4, %o2
4000ea38: 40 00 06 b9 call 4001051c <memset>
4000ea3c: a0 10 20 00 clr %l0
4000ea40: 10 80 00 0e b 4000ea78 <IMFS_memfile_extend+0x15c>
4000ea44: a2 04 60 01 inc %l1
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
4000ea48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000ea4c: 7f ff ff a8 call 4000e8ec <IMFS_memfile_remove_block> <== NOT EXECUTED
4000ea50: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
4000ea54: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000ea58: 1a bf ff fc bcc 4000ea48 <IMFS_memfile_extend+0x12c> <== NOT EXECUTED
4000ea5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
4000ea60: 40 00 04 21 call 4000fae4 <__errno> <== NOT EXECUTED
4000ea64: 01 00 00 00 nop <== NOT EXECUTED
4000ea68: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
4000ea6c: c2 22 00 00 st %g1, [ %o0 ]
4000ea70: 81 c7 e0 08 ret
4000ea74: 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(
4000ea78: 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++ ) {
4000ea7c: 80 a7 40 12 cmp %i5, %l2
4000ea80: 08 bf ff dd bleu 4000e9f4 <IMFS_memfile_extend+0xd8>
4000ea84: 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);
4000ea88: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
4000ea8c: f4 3e 20 50 std %i2, [ %i0 + 0x50 ]
IMFS_update_ctime(the_jnode);
4000ea90: 7f ff d5 8f call 400040cc <gettimeofday>
4000ea94: 90 07 bf f8 add %fp, -8, %o0
4000ea98: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
4000ea9c: 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);
4000eaa0: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime(the_jnode);
4000eaa4: 7f ff d5 8a call 400040cc <gettimeofday>
4000eaa8: 92 10 20 00 clr %o1
4000eaac: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000eab0: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
return 0;
}
4000eab4: 81 c7 e0 08 ret
4000eab8: 91 e8 20 00 restore %g0, 0, %o0
4000e270 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4000e270: 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 ) {
4000e274: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000e278: fa 00 62 f8 ld [ %g1 + 0x2f8 ], %i5 ! 4001eef8 <imfs_memfile_bytes_per_block>
4000e27c: bb 37 60 02 srl %i5, 2, %i5
4000e280: 82 07 7f ff add %i5, -1, %g1
4000e284: 80 a6 40 01 cmp %i1, %g1
4000e288: 18 80 00 18 bgu 4000e2e8 <IMFS_memfile_get_block_pointer+0x78>
4000e28c: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
4000e290: 80 a6 a0 00 cmp %i2, 0
4000e294: 02 80 00 10 be 4000e2d4 <IMFS_memfile_get_block_pointer+0x64>
4000e298: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
if ( !p ) {
4000e29c: 80 a0 60 00 cmp %g1, 0
4000e2a0: 32 80 00 0a bne,a 4000e2c8 <IMFS_memfile_get_block_pointer+0x58>
4000e2a4: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
p = memfile_alloc_block();
4000e2a8: 7f ff ff e5 call 4000e23c <memfile_alloc_block>
4000e2ac: 01 00 00 00 nop
if ( !p )
4000e2b0: 80 a2 20 00 cmp %o0, 0
4000e2b4: 32 80 00 04 bne,a 4000e2c4 <IMFS_memfile_get_block_pointer+0x54><== ALWAYS TAKEN
4000e2b8: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
return 0;
4000e2bc: 81 c7 e0 08 ret <== NOT EXECUTED
4000e2c0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->indirect = p;
}
return &info->indirect[ my_block ];
4000e2c4: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
4000e2c8: b3 2e 60 02 sll %i1, 2, %i1
4000e2cc: 81 c7 e0 08 ret
4000e2d0: 91 ee 00 19 restore %i0, %i1, %o0
}
if ( !p )
4000e2d4: 80 a0 60 00 cmp %g1, 0
4000e2d8: 02 bf ff f9 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e2dc: b3 2e 60 02 sll %i1, 2, %i1
return 0;
return &info->indirect[ my_block ];
4000e2e0: 81 c7 e0 08 ret
4000e2e4: 91 e8 40 19 restore %g1, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4000e2e8: 40 00 2a 34 call 40018bb8 <.umul>
4000e2ec: 92 10 00 1d mov %i5, %o1
4000e2f0: 82 02 3f ff add %o0, -1, %g1
4000e2f4: 80 a6 40 01 cmp %i1, %g1
4000e2f8: 18 80 00 2c bgu 4000e3a8 <IMFS_memfile_get_block_pointer+0x138>
4000e2fc: b8 10 00 08 mov %o0, %i4
my_block -= FIRST_DOUBLY_INDIRECT;
4000e300: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000e304: 92 10 00 1d mov %i5, %o1
4000e308: 40 00 2b 12 call 40018f50 <.urem>
4000e30c: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000e310: 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;
4000e314: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000e318: 40 00 2a 62 call 40018ca0 <.udiv>
4000e31c: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
if ( malloc_it ) {
4000e320: 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;
4000e324: ba 10 00 08 mov %o0, %i5
p = info->doubly_indirect;
if ( malloc_it ) {
4000e328: 02 80 00 17 be 4000e384 <IMFS_memfile_get_block_pointer+0x114>
4000e32c: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !p ) {
4000e330: 80 a2 20 00 cmp %o0, 0
4000e334: 12 80 00 08 bne 4000e354 <IMFS_memfile_get_block_pointer+0xe4>
4000e338: bb 2f 60 02 sll %i5, 2, %i5
p = memfile_alloc_block();
4000e33c: 7f ff ff c0 call 4000e23c <memfile_alloc_block>
4000e340: 01 00 00 00 nop
if ( !p )
4000e344: 80 a2 20 00 cmp %o0, 0
4000e348: 02 bf ff dd be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e34c: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
4000e350: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
}
p1 = (block_p *)p[ doubly ];
4000e354: b6 02 00 1d add %o0, %i5, %i3
4000e358: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p1 ) {
4000e35c: 80 a2 20 00 cmp %o0, 0
4000e360: 12 80 00 4a bne 4000e488 <IMFS_memfile_get_block_pointer+0x218>
4000e364: b1 2f 20 02 sll %i4, 2, %i0
p1 = memfile_alloc_block();
4000e368: 7f ff ff b5 call 4000e23c <memfile_alloc_block>
4000e36c: 01 00 00 00 nop
if ( !p1 )
4000e370: 80 a2 20 00 cmp %o0, 0
4000e374: 02 bf ff d2 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e378: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
4000e37c: 10 80 00 43 b 4000e488 <IMFS_memfile_get_block_pointer+0x218>
4000e380: d0 26 c0 00 st %o0, [ %i3 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4000e384: 80 a2 20 00 cmp %o0, 0
4000e388: 02 bf ff cd be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e38c: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
4000e390: c2 02 00 1d ld [ %o0 + %i5 ], %g1
if ( !p )
4000e394: 80 a0 60 00 cmp %g1, 0
4000e398: 02 bf ff c9 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e39c: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
4000e3a0: 10 80 00 48 b 4000e4c0 <IMFS_memfile_get_block_pointer+0x250>
4000e3a4: b1 2f 20 02 sll %i4, 2, %i0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4000e3a8: 90 02 20 01 inc %o0
4000e3ac: 40 00 2a 03 call 40018bb8 <.umul>
4000e3b0: 92 10 00 1d mov %i5, %o1
4000e3b4: 90 02 3f ff add %o0, -1, %o0
4000e3b8: 80 a6 40 08 cmp %i1, %o0
4000e3bc: 18 bf ff c0 bgu 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e3c0: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000e3c4: 92 10 00 1d mov %i5, %o1
4000e3c8: 40 00 2a e2 call 40018f50 <.urem>
4000e3cc: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000e3d0: 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;
4000e3d4: b6 10 00 08 mov %o0, %i3
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000e3d8: 40 00 2a 32 call 40018ca0 <.udiv>
4000e3dc: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4000e3e0: 92 10 00 1d mov %i5, %o1
4000e3e4: 40 00 2a 2f call 40018ca0 <.udiv>
4000e3e8: b2 10 00 08 mov %o0, %i1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000e3ec: 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;
4000e3f0: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000e3f4: 40 00 2a d7 call 40018f50 <.urem>
4000e3f8: 90 10 00 19 mov %i1, %o0
p = info->triply_indirect;
if ( malloc_it ) {
4000e3fc: 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;
4000e400: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
4000e404: 02 80 00 23 be 4000e490 <IMFS_memfile_get_block_pointer+0x220>
4000e408: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
4000e40c: 80 a2 20 00 cmp %o0, 0
4000e410: 12 80 00 08 bne 4000e430 <IMFS_memfile_get_block_pointer+0x1c0>
4000e414: b9 2f 20 02 sll %i4, 2, %i4
p = memfile_alloc_block();
4000e418: 7f ff ff 89 call 4000e23c <memfile_alloc_block>
4000e41c: 01 00 00 00 nop
if ( !p )
4000e420: 80 a2 20 00 cmp %o0, 0
4000e424: 02 bf ff a6 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e428: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
4000e42c: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
}
p1 = (block_p *) p[ triply ];
4000e430: b4 02 00 1c add %o0, %i4, %i2
4000e434: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p1 ) {
4000e438: 80 a2 20 00 cmp %o0, 0
4000e43c: 12 80 00 08 bne 4000e45c <IMFS_memfile_get_block_pointer+0x1ec>
4000e440: bb 2f 60 02 sll %i5, 2, %i5
p1 = memfile_alloc_block();
4000e444: 7f ff ff 7e call 4000e23c <memfile_alloc_block>
4000e448: 01 00 00 00 nop
if ( !p1 )
4000e44c: 80 a2 20 00 cmp %o0, 0
4000e450: 02 bf ff 9b be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e454: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
4000e458: d0 26 80 00 st %o0, [ %i2 ]
}
p2 = (block_p *)p1[ doubly ];
4000e45c: b8 02 00 1d add %o0, %i5, %i4
4000e460: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p2 ) {
4000e464: 80 a2 20 00 cmp %o0, 0
4000e468: 12 80 00 08 bne 4000e488 <IMFS_memfile_get_block_pointer+0x218>
4000e46c: b1 2e e0 02 sll %i3, 2, %i0
p2 = memfile_alloc_block();
4000e470: 7f ff ff 73 call 4000e23c <memfile_alloc_block>
4000e474: 01 00 00 00 nop
if ( !p2 )
4000e478: 80 a2 20 00 cmp %o0, 0
4000e47c: 02 bf ff 90 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e480: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
4000e484: d0 27 00 00 st %o0, [ %i4 ]
}
return (block_p *)&p2[ singly ];
4000e488: 81 c7 e0 08 ret
4000e48c: 91 ea 00 18 restore %o0, %i0, %o0
}
if ( !p )
4000e490: 80 a2 20 00 cmp %o0, 0
4000e494: 02 bf ff 8a be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e498: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p1 = (block_p *) p[ triply ];
4000e49c: c2 02 00 1c ld [ %o0 + %i4 ], %g1
if ( !p1 )
4000e4a0: 80 a0 60 00 cmp %g1, 0
4000e4a4: 02 bf ff 86 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e4a8: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
4000e4ac: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
4000e4b0: 80 a0 60 00 cmp %g1, 0
4000e4b4: 02 bf ff 82 be 4000e2bc <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
4000e4b8: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
4000e4bc: b1 2e e0 02 sll %i3, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
4000e4c0: 81 c7 e0 08 ret
4000e4c4: 91 e8 40 18 restore %g1, %i0, %o0
4000e4c8 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000e4c8: 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;
4000e4cc: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
4000e4d0: 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 ) {
4000e4d4: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000e4d8: a0 10 00 19 mov %i1, %l0
4000e4dc: 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 ) {
4000e4e0: 80 a0 60 05 cmp %g1, 5
4000e4e4: 12 80 00 17 bne 4000e540 <IMFS_memfile_read+0x78>
4000e4e8: 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))
4000e4ec: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
4000e4f0: 82 10 20 00 clr %g1
4000e4f4: 86 a6 c0 11 subcc %i3, %l1, %g3
4000e4f8: 84 66 80 19 subx %i2, %i1, %g2
4000e4fc: 80 a0 40 02 cmp %g1, %g2
4000e500: 14 80 00 07 bg 4000e51c <IMFS_memfile_read+0x54> <== NEVER TAKEN
4000e504: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
4000e508: 80 a0 40 02 cmp %g1, %g2
4000e50c: 12 80 00 06 bne 4000e524 <IMFS_memfile_read+0x5c> <== NEVER TAKEN
4000e510: 80 a7 00 03 cmp %i4, %g3
4000e514: 28 80 00 05 bleu,a 4000e528 <IMFS_memfile_read+0x60> <== NEVER TAKEN
4000e518: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
4000e51c: 10 80 00 03 b 4000e528 <IMFS_memfile_read+0x60>
4000e520: 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;
4000e524: 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);
4000e528: 90 10 00 12 mov %l2, %o0
4000e52c: 92 02 40 11 add %o1, %l1, %o1
4000e530: 40 00 07 be call 40010428 <memcpy>
4000e534: 94 10 00 18 mov %i0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000e538: 10 80 00 5d b 4000e6ac <IMFS_memfile_read+0x1e4>
4000e53c: 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 )
4000e540: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
4000e544: 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;
4000e548: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
4000e54c: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
4000e550: 80 a1 00 03 cmp %g4, %g3
4000e554: 14 80 00 08 bg 4000e574 <IMFS_memfile_read+0xac> <== NEVER TAKEN
4000e558: b6 07 00 1a add %i4, %i2, %i3
4000e55c: 80 a1 00 03 cmp %g4, %g3
4000e560: 32 80 00 07 bne,a 4000e57c <IMFS_memfile_read+0xb4> <== NEVER TAKEN
4000e564: 03 10 00 7b sethi %hi(0x4001ec00), %g1 <== NOT EXECUTED
4000e568: 80 a6 c0 02 cmp %i3, %g2
4000e56c: 28 80 00 04 bleu,a 4000e57c <IMFS_memfile_read+0xb4>
4000e570: 03 10 00 7b sethi %hi(0x4001ec00), %g1
my_length = the_jnode->info.file.size - start;
4000e574: 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;
4000e578: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000e57c: f6 00 62 f8 ld [ %g1 + 0x2f8 ], %i3 ! 4001eef8 <imfs_memfile_bytes_per_block>
4000e580: 90 10 00 10 mov %l0, %o0
4000e584: b5 3e e0 1f sra %i3, 0x1f, %i2
4000e588: 96 10 00 1b mov %i3, %o3
4000e58c: 94 10 00 1a mov %i2, %o2
4000e590: 40 00 2c 07 call 400195ac <__moddi3>
4000e594: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e598: 94 10 00 1a mov %i2, %o2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e59c: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e5a0: 90 10 00 10 mov %l0, %o0
4000e5a4: 92 10 00 11 mov %l1, %o1
4000e5a8: 40 00 2b 16 call 40019200 <__divdi3>
4000e5ac: 96 10 00 1b mov %i3, %o3
if ( start_offset ) {
4000e5b0: 80 a4 e0 00 cmp %l3, 0
4000e5b4: 02 80 00 18 be 4000e614 <IMFS_memfile_read+0x14c>
4000e5b8: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000e5bc: b6 26 c0 13 sub %i3, %l3, %i3
4000e5c0: 80 a7 00 1b cmp %i4, %i3
4000e5c4: 08 80 00 03 bleu 4000e5d0 <IMFS_memfile_read+0x108>
4000e5c8: b2 10 00 1c mov %i4, %i1
4000e5cc: 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 );
4000e5d0: 90 10 00 1d mov %i5, %o0
4000e5d4: 92 10 00 1a mov %i2, %o1
4000e5d8: 94 10 20 00 clr %o2
4000e5dc: 7f ff ff 25 call 4000e270 <IMFS_memfile_get_block_pointer>
4000e5e0: b0 10 20 00 clr %i0
if ( !block_ptr )
4000e5e4: 80 a2 20 00 cmp %o0, 0
4000e5e8: 02 80 00 35 be 4000e6bc <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
4000e5ec: 94 10 00 19 mov %i1, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4000e5f0: d2 02 00 00 ld [ %o0 ], %o1
4000e5f4: 90 10 00 12 mov %l2, %o0
4000e5f8: 92 02 40 13 add %o1, %l3, %o1
4000e5fc: 40 00 07 8b call 40010428 <memcpy>
4000e600: a4 04 80 19 add %l2, %i1, %l2
dest += to_copy;
block++;
4000e604: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000e608: b8 27 00 19 sub %i4, %i1, %i4
copied += to_copy;
4000e60c: 10 80 00 03 b 4000e618 <IMFS_memfile_read+0x150>
4000e610: 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;
4000e614: b0 10 20 00 clr %i0
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e618: 03 10 00 7b sethi %hi(0x4001ec00), %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(
4000e61c: a4 24 80 18 sub %l2, %i0, %l2
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e620: f6 00 62 f8 ld [ %g1 + 0x2f8 ], %i3
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000e624: 10 80 00 0f b 4000e660 <IMFS_memfile_read+0x198>
4000e628: a0 10 00 01 mov %g1, %l0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e62c: 90 10 00 1d mov %i5, %o0
4000e630: 92 10 00 1a mov %i2, %o1
4000e634: 7f ff ff 0f call 4000e270 <IMFS_memfile_get_block_pointer>
4000e638: 94 10 20 00 clr %o2
if ( !block_ptr )
4000e63c: 82 92 20 00 orcc %o0, 0, %g1
4000e640: 02 80 00 1f be 4000e6bc <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
4000e644: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4000e648: d2 00 40 00 ld [ %g1 ], %o1
4000e64c: 94 10 00 1b mov %i3, %o2
4000e650: 40 00 07 76 call 40010428 <memcpy>
4000e654: b4 06 a0 01 inc %i2
dest += to_copy;
block++;
my_length -= to_copy;
4000e658: b8 27 00 1b sub %i4, %i3, %i4
copied += to_copy;
4000e65c: 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 ) {
4000e660: c2 04 22 f8 ld [ %l0 + 0x2f8 ], %g1
4000e664: 80 a7 00 01 cmp %i4, %g1
4000e668: 1a bf ff f1 bcc 4000e62c <IMFS_memfile_read+0x164>
4000e66c: 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 ) {
4000e670: 80 a7 20 00 cmp %i4, 0
4000e674: 02 80 00 0e be 4000e6ac <IMFS_memfile_read+0x1e4>
4000e678: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e67c: 90 10 00 1d mov %i5, %o0
4000e680: 92 10 00 1a mov %i2, %o1
4000e684: 7f ff fe fb call 4000e270 <IMFS_memfile_get_block_pointer>
4000e688: 94 10 20 00 clr %o2
if ( !block_ptr )
4000e68c: 82 92 20 00 orcc %o0, 0, %g1
4000e690: 02 80 00 0b be 4000e6bc <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
4000e694: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4000e698: d2 00 40 00 ld [ %g1 ], %o1
4000e69c: 94 10 00 1c mov %i4, %o2
4000e6a0: 40 00 07 62 call 40010428 <memcpy>
4000e6a4: b0 07 00 18 add %i4, %i0, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000e6a8: 90 07 bf f8 add %fp, -8, %o0
4000e6ac: 7f ff d6 88 call 400040cc <gettimeofday>
4000e6b0: 92 10 20 00 clr %o1
4000e6b4: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000e6b8: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return copied;
}
4000e6bc: 81 c7 e0 08 ret
4000e6c0: 81 e8 00 00 restore
4000e7c0 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4000e7c0: 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;
4000e7c4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000e7c8: fa 00 62 f8 ld [ %g1 + 0x2f8 ], %i5 ! 4001eef8 <imfs_memfile_bytes_per_block>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4000e7cc: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4000e7d0: 80 a0 60 00 cmp %g1, 0
4000e7d4: 02 80 00 05 be 4000e7e8 <IMFS_memfile_remove+0x28>
4000e7d8: bb 37 60 02 srl %i5, 2, %i5
memfile_free_blocks_in_table( &info->indirect, to_free );
4000e7dc: 90 06 20 58 add %i0, 0x58, %o0
4000e7e0: 7f ff ff e5 call 4000e774 <memfile_free_blocks_in_table>
4000e7e4: 92 10 00 1d mov %i5, %o1
}
if ( info->doubly_indirect ) {
4000e7e8: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000e7ec: b8 10 20 00 clr %i4
4000e7f0: 80 a0 60 00 cmp %g1, 0
4000e7f4: 12 80 00 0d bne 4000e828 <IMFS_memfile_remove+0x68>
4000e7f8: 37 10 00 7b sethi %hi(0x4001ec00), %i3
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
4000e7fc: 10 80 00 15 b 4000e850 <IMFS_memfile_remove+0x90>
4000e800: 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(
4000e804: 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] ) {
4000e808: 90 00 80 01 add %g2, %g1, %o0
4000e80c: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000e810: 80 a0 60 00 cmp %g1, 0
4000e814: 22 80 00 05 be,a 4000e828 <IMFS_memfile_remove+0x68> <== NEVER TAKEN
4000e818: b8 07 20 01 inc %i4 <== NOT EXECUTED
memfile_free_blocks_in_table(
4000e81c: 7f ff ff d6 call 4000e774 <memfile_free_blocks_in_table>
4000e820: 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++ ) {
4000e824: b8 07 20 01 inc %i4
4000e828: c2 06 e2 f8 ld [ %i3 + 0x2f8 ], %g1
4000e82c: 83 30 60 02 srl %g1, 2, %g1
4000e830: 80 a7 00 01 cmp %i4, %g1
4000e834: 2a bf ff f4 bcs,a 4000e804 <IMFS_memfile_remove+0x44>
4000e838: 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 );
4000e83c: 90 06 20 5c add %i0, 0x5c, %o0
4000e840: 7f ff ff cd call 4000e774 <memfile_free_blocks_in_table>
4000e844: 92 10 00 1d mov %i5, %o1
}
if ( info->triply_indirect ) {
4000e848: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
4000e84c: b8 10 20 00 clr %i4
4000e850: 80 a0 60 00 cmp %g1, 0
4000e854: 12 80 00 1c bne 4000e8c4 <IMFS_memfile_remove+0x104>
4000e858: 33 10 00 7b sethi %hi(0x4001ec00), %i1
4000e85c: 81 c7 e0 08 ret
4000e860: 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(
4000e864: 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];
4000e868: f6 00 40 10 ld [ %g1 + %l0 ], %i3
if ( !p ) /* ensure we have a valid pointer */
4000e86c: 80 a6 e0 00 cmp %i3, 0
4000e870: 02 80 00 1b be 4000e8dc <IMFS_memfile_remove+0x11c> <== NEVER TAKEN
4000e874: 90 06 20 60 add %i0, 0x60, %o0
4000e878: 10 80 00 09 b 4000e89c <IMFS_memfile_remove+0xdc>
4000e87c: b4 10 20 00 clr %i2
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
4000e880: 80 a0 60 00 cmp %g1, 0
4000e884: 02 80 00 04 be 4000e894 <IMFS_memfile_remove+0xd4> <== NEVER TAKEN
4000e888: 90 10 00 1b mov %i3, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4000e88c: 7f ff ff ba call 4000e774 <memfile_free_blocks_in_table>
4000e890: 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++ ) {
4000e894: b4 06 a0 01 inc %i2
4000e898: b6 06 e0 04 add %i3, 4, %i3
4000e89c: c2 06 62 f8 ld [ %i1 + 0x2f8 ], %g1
4000e8a0: 83 30 60 02 srl %g1, 2, %g1
4000e8a4: 80 a6 80 01 cmp %i2, %g1
4000e8a8: 2a bf ff f6 bcs,a 4000e880 <IMFS_memfile_remove+0xc0>
4000e8ac: 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(
4000e8b0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000e8b4: 92 10 00 1d mov %i5, %o1
4000e8b8: 90 02 00 10 add %o0, %l0, %o0
4000e8bc: 7f ff ff ae call 4000e774 <memfile_free_blocks_in_table>
4000e8c0: 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++ ) {
4000e8c4: c2 06 62 f8 ld [ %i1 + 0x2f8 ], %g1
4000e8c8: 83 30 60 02 srl %g1, 2, %g1
4000e8cc: 80 a7 00 01 cmp %i4, %g1
4000e8d0: 2a bf ff e5 bcs,a 4000e864 <IMFS_memfile_remove+0xa4>
4000e8d4: 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(
4000e8d8: 90 06 20 60 add %i0, 0x60, %o0
4000e8dc: 7f ff ff a6 call 4000e774 <memfile_free_blocks_in_table>
4000e8e0: 92 10 00 1d mov %i5, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
4000e8e4: 81 c7 e0 08 ret
4000e8e8: 81 e8 00 00 restore
4000e8ec <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000e8ec: 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 );
4000e8f0: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000e8f4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e8f8: 7f ff fe 5e call 4000e270 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
4000e8fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e900: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
4000e904: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
4000e908: 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 );
4000e90c: 7f ff ff 91 call 4000e750 <memfile_free_block> <== NOT EXECUTED
4000e910: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
4000e914: 81 c7 e0 08 ret <== NOT EXECUTED
4000e918: 81 e8 00 00 restore <== NOT EXECUTED
4000eabc <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4000eabc: 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 ) {
4000eac0: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000eac4: 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;
4000eac8: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
4000eacc: 80 a0 c0 01 cmp %g3, %g1
4000ead0: 14 80 00 1b bg 4000eb3c <IMFS_memfile_write+0x80> <== NEVER TAKEN
4000ead4: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
4000ead8: 80 a0 c0 01 cmp %g3, %g1
4000eadc: 32 80 00 06 bne,a 4000eaf4 <IMFS_memfile_write+0x38> <== NEVER TAKEN
4000eae0: 03 10 00 7b sethi %hi(0x4001ec00), %g1 <== NOT EXECUTED
4000eae4: 80 a2 c0 02 cmp %o3, %g2
4000eae8: 18 80 00 16 bgu 4000eb40 <IMFS_memfile_write+0x84>
4000eaec: 80 a6 40 01 cmp %i1, %g1
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000eaf0: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000eaf4: fa 00 62 f8 ld [ %g1 + 0x2f8 ], %i5 ! 4001eef8 <imfs_memfile_bytes_per_block>
4000eaf8: 92 10 00 1a mov %i2, %o1
4000eafc: a3 3f 60 1f sra %i5, 0x1f, %l1
4000eb00: 96 10 00 1d mov %i5, %o3
4000eb04: 94 10 00 11 mov %l1, %o2
4000eb08: 40 00 2a a9 call 400195ac <__moddi3>
4000eb0c: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000eb10: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000eb14: a0 10 00 09 mov %o1, %l0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000eb18: 94 10 00 11 mov %l1, %o2
4000eb1c: 92 10 00 1a mov %i2, %o1
4000eb20: 40 00 29 b8 call 40019200 <__divdi3>
4000eb24: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
4000eb28: 80 a4 20 00 cmp %l0, 0
4000eb2c: 12 80 00 17 bne 4000eb88 <IMFS_memfile_write+0xcc>
4000eb30: b4 10 00 09 mov %o1, %i2
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
4000eb34: 10 80 00 28 b 4000ebd4 <IMFS_memfile_write+0x118>
4000eb38: 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;
4000eb3c: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000eb40: 14 80 00 09 bg 4000eb64 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
4000eb44: 92 10 20 01 mov 1, %o1
4000eb48: 80 a6 40 01 cmp %i1, %g1
4000eb4c: 32 80 00 06 bne,a 4000eb64 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
4000eb50: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000eb54: 80 a6 80 02 cmp %i2, %g2
4000eb58: 18 80 00 04 bgu 4000eb68 <IMFS_memfile_write+0xac>
4000eb5c: 90 10 00 18 mov %i0, %o0
4000eb60: 92 10 20 00 clr %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
4000eb64: 90 10 00 18 mov %i0, %o0
4000eb68: 92 0a 60 01 and %o1, 1, %o1
4000eb6c: 7f ff ff 6c call 4000e91c <IMFS_memfile_extend>
4000eb70: 94 10 20 00 clr %o2
if ( status )
4000eb74: 82 92 20 00 orcc %o0, 0, %g1
4000eb78: 22 bf ff df be,a 4000eaf4 <IMFS_memfile_write+0x38>
4000eb7c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000eb80: 81 c7 e0 08 ret
4000eb84: 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;
4000eb88: ba 27 40 10 sub %i5, %l0, %i5
4000eb8c: 80 a7 40 1c cmp %i5, %i4
4000eb90: 38 80 00 02 bgu,a 4000eb98 <IMFS_memfile_write+0xdc>
4000eb94: 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 );
4000eb98: 90 10 00 18 mov %i0, %o0
4000eb9c: 92 10 00 1a mov %i2, %o1
4000eba0: 7f ff fd b4 call 4000e270 <IMFS_memfile_get_block_pointer>
4000eba4: 94 10 20 00 clr %o2
if ( !block_ptr )
4000eba8: 80 a2 20 00 cmp %o0, 0
4000ebac: 02 80 00 36 be 4000ec84 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
4000ebb0: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4000ebb4: d0 02 00 00 ld [ %o0 ], %o0
4000ebb8: 92 10 00 1b mov %i3, %o1
4000ebbc: 90 02 00 10 add %o0, %l0, %o0
4000ebc0: 94 10 00 1d mov %i5, %o2
4000ebc4: 40 00 06 19 call 40010428 <memcpy>
4000ebc8: b6 06 c0 1d add %i3, %i5, %i3
src += to_copy;
block++;
4000ebcc: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000ebd0: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000ebd4: 03 10 00 7b sethi %hi(0x4001ec00), %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(
4000ebd8: b6 26 c0 1d sub %i3, %i5, %i3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4000ebdc: f2 00 62 f8 ld [ %g1 + 0x2f8 ], %i1
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000ebe0: 10 80 00 0f b 4000ec1c <IMFS_memfile_write+0x160>
4000ebe4: a2 10 00 01 mov %g1, %l1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000ebe8: 90 10 00 18 mov %i0, %o0
4000ebec: 92 10 00 1a mov %i2, %o1
4000ebf0: 7f ff fd a0 call 4000e270 <IMFS_memfile_get_block_pointer>
4000ebf4: 94 10 20 00 clr %o2
if ( !block_ptr )
4000ebf8: 80 a2 20 00 cmp %o0, 0
4000ebfc: 02 80 00 21 be 4000ec80 <IMFS_memfile_write+0x1c4> <== NEVER TAKEN
4000ec00: 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 );
4000ec04: d0 02 00 00 ld [ %o0 ], %o0
4000ec08: 92 10 00 10 mov %l0, %o1
4000ec0c: 40 00 06 07 call 40010428 <memcpy>
4000ec10: b4 06 a0 01 inc %i2
src += to_copy;
block++;
my_length -= to_copy;
4000ec14: 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(
4000ec18: 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 ) {
4000ec1c: c2 04 62 f8 ld [ %l1 + 0x2f8 ], %g1
4000ec20: 80 a7 00 01 cmp %i4, %g1
4000ec24: 1a bf ff f1 bcc 4000ebe8 <IMFS_memfile_write+0x12c>
4000ec28: 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 ) {
4000ec2c: 80 a7 20 00 cmp %i4, 0
4000ec30: 02 80 00 0f be 4000ec6c <IMFS_memfile_write+0x1b0>
4000ec34: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000ec38: 90 10 00 18 mov %i0, %o0
4000ec3c: 92 10 00 1a mov %i2, %o1
4000ec40: 7f ff fd 8c call 4000e270 <IMFS_memfile_get_block_pointer>
4000ec44: 94 10 20 00 clr %o2
if ( !block_ptr )
4000ec48: 80 a2 20 00 cmp %o0, 0
4000ec4c: 02 80 00 0e be 4000ec84 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
4000ec50: 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 );
4000ec54: d0 02 00 00 ld [ %o0 ], %o0
4000ec58: 92 10 00 10 mov %l0, %o1
4000ec5c: 94 10 00 1c mov %i4, %o2
4000ec60: 40 00 05 f2 call 40010428 <memcpy>
4000ec64: ba 07 40 1c add %i5, %i4, %i5
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4000ec68: 90 07 bf f8 add %fp, -8, %o0
4000ec6c: 7f ff d5 18 call 400040cc <gettimeofday>
4000ec70: 92 10 20 00 clr %o1
4000ec74: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000ec78: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
4000ec7c: 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 )
4000ec80: 82 10 00 1d mov %i5, %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000ec84: b0 10 00 01 mov %g1, %i0
4000ec88: 81 c7 e0 08 ret
4000ec8c: 81 e8 00 00 restore
40003844 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40003844: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
40003848: 05 00 00 3c sethi %hi(0xf000), %g2
4000384c: 07 00 00 10 sethi %hi(0x4000), %g3
40003850: 84 0e c0 02 and %i3, %g2, %g2
40003854: 80 a0 80 03 cmp %g2, %g3
40003858: 02 80 00 12 be 400038a0 <IMFS_mknod+0x5c>
4000385c: 07 00 00 20 sethi %hi(0x8000), %g3
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
40003860: 80 a0 80 03 cmp %g2, %g3
40003864: 02 80 00 11 be 400038a8 <IMFS_mknod+0x64>
40003868: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
4000386c: 07 00 00 08 sethi %hi(0x2000), %g3
40003870: 88 0e c0 04 and %i3, %g4, %g4
40003874: 80 a1 00 03 cmp %g4, %g3
40003878: 12 80 00 05 bne 4000388c <IMFS_mknod+0x48>
4000387c: 07 00 00 04 sethi %hi(0x1000), %g3
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
40003880: 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;
40003884: 10 80 00 0a b 400038ac <IMFS_mknod+0x68>
40003888: 82 10 20 01 mov 1, %g1
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
4000388c: 80 a0 80 03 cmp %g2, %g3
40003890: 32 80 00 08 bne,a 400038b0 <IMFS_mknod+0x6c> <== NEVER TAKEN
40003894: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
*type = IMFS_FIFO;
40003898: 10 80 00 05 b 400038ac <IMFS_mknod+0x68>
4000389c: 82 10 20 06 mov 6, %g1
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
400038a0: 10 80 00 03 b 400038ac <IMFS_mknod+0x68>
400038a4: 82 10 20 00 clr %g1
400038a8: 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 =
400038ac: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
400038b0: 82 00 60 02 add %g1, 2, %g1
400038b4: c4 00 a0 08 ld [ %g2 + 8 ], %g2
400038b8: 83 28 60 02 sll %g1, 2, %g1
400038bc: d2 00 80 01 ld [ %g2 + %g1 ], %o1
400038c0: 90 10 00 18 mov %i0, %o0
400038c4: 94 10 00 19 mov %i1, %o2
400038c8: 96 10 00 1a mov %i2, %o3
400038cc: 98 10 00 1b mov %i3, %o4
400038d0: 40 00 21 4e call 4000be08 <IMFS_create_node_with_control>
400038d4: 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 ) {
400038d8: 80 a2 20 00 cmp %o0, 0
400038dc: 02 80 00 0e be 40003914 <IMFS_mknod+0xd0>
400038e0: 90 07 bf e0 add %fp, -32, %o0
IMFS_jnode_t *parent = parentloc->node_access;
400038e4: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
400038e8: 40 00 01 f9 call 400040cc <gettimeofday>
400038ec: 92 10 20 00 clr %o1
400038f0: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
400038f4: 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 );
400038f8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
400038fc: 40 00 01 f4 call 400040cc <gettimeofday>
40003900: 92 10 20 00 clr %o1
40003904: c2 07 bf e0 ld [ %fp + -32 ], %g1
40003908: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
4000390c: 81 c7 e0 08 ret
40003910: 91 e8 20 00 restore %g0, 0, %o0
} else {
rv = -1;
}
return rv;
}
40003914: 81 c7 e0 08 ret
40003918: 91 e8 3f ff restore %g0, -1, %o0
4000391c <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
4000391c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40003920: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40003924: 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;
40003928: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
4000392c: c4 00 80 00 ld [ %g2 ], %g2
40003930: 80 a0 a0 00 cmp %g2, 0
40003934: 12 80 00 0d bne 40003968 <IMFS_mount+0x4c>
40003938: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
4000393c: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40003940: 80 a0 a0 00 cmp %g2, 0
40003944: 12 80 00 05 bne 40003958 <IMFS_mount+0x3c> <== NEVER TAKEN
40003948: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
4000394c: 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;
40003950: 81 c7 e0 08 ret
40003954: 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;
40003958: 40 00 30 63 call 4000fae4 <__errno> <== NOT EXECUTED
4000395c: 01 00 00 00 nop <== NOT EXECUTED
40003960: 10 80 00 05 b 40003974 <IMFS_mount+0x58> <== NOT EXECUTED
40003964: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40003968: 40 00 30 5f call 4000fae4 <__errno>
4000396c: 01 00 00 00 nop
40003970: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
40003974: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40003978: 81 c7 e0 08 ret
4000397c: 91 e8 3f ff restore %g0, -1, %o0
4000c258 <IMFS_node_remove_directory>:
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
4000c258: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
4000c25c: 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 );
4000c260: 82 06 20 54 add %i0, 0x54, %g1
4000c264: 80 a0 80 01 cmp %g2, %g1
4000c268: 22 80 00 06 be,a 4000c280 <IMFS_node_remove_directory+0x28>
4000c26c: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
errno = ENOTEMPTY;
4000c270: 40 00 0e 1d call 4000fae4 <__errno>
4000c274: 01 00 00 00 nop
4000c278: 10 80 00 08 b 4000c298 <IMFS_node_remove_directory+0x40>
4000c27c: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
4000c280: 80 a0 60 00 cmp %g1, 0
4000c284: 02 80 00 07 be 4000c2a0 <IMFS_node_remove_directory+0x48> <== ALWAYS TAKEN
4000c288: 01 00 00 00 nop
errno = EBUSY;
4000c28c: 40 00 0e 16 call 4000fae4 <__errno> <== NOT EXECUTED
4000c290: 01 00 00 00 nop <== NOT EXECUTED
4000c294: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
4000c298: c2 22 00 00 st %g1, [ %o0 ]
4000c29c: b0 10 20 00 clr %i0
node = NULL;
}
return node;
}
4000c2a0: 81 c7 e0 08 ret
4000c2a4: 81 e8 00 00 restore
40003980 <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;
40003980: 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;
40003984: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40003988: 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 ) {
4000398c: 80 a0 60 02 cmp %g1, 2
40003990: 02 80 00 06 be 400039a8 <IMFS_node_type+0x28>
40003994: 80 a0 60 05 cmp %g1, 5
40003998: 12 80 00 08 bne 400039b8 <IMFS_node_type+0x38> <== ALWAYS TAKEN
4000399c: 90 10 20 04 mov 4, %o0
400039a0: 81 c3 e0 08 retl <== NOT EXECUTED
400039a4: 01 00 00 00 nop <== NOT EXECUTED
400039a8: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
400039ac: c2 00 60 4c ld [ %g1 + 0x4c ], %g1
case IMFS_HARD_LINK:
type = IMFS_type( node->info.hard_link.link_node );
break;
400039b0: 81 c3 e0 08 retl
400039b4: d0 00 40 00 ld [ %g1 ], %o0
type = imfs_type;
break;
}
return type;
}
400039b8: 81 c3 e0 08 retl
400039bc: 90 10 00 01 mov %g1, %o0
400039fc <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400039fc: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
40003a00: 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 ) {
40003a04: c2 07 60 08 ld [ %i5 + 8 ], %g1
40003a08: 80 a0 60 00 cmp %g1, 0
40003a0c: 02 80 00 20 be 40003a8c <IMFS_rename+0x90> <== NEVER TAKEN
40003a10: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
40003a14: 80 a7 20 1f cmp %i4, 0x1f
40003a18: 18 80 00 19 bgu 40003a7c <IMFS_rename+0x80> <== NEVER TAKEN
40003a1c: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
40003a20: 92 10 00 1b mov %i3, %o1
40003a24: 40 00 32 81 call 40010428 <memcpy>
40003a28: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
40003a2c: b8 07 40 1c add %i5, %i4, %i4
40003a30: c0 2f 20 0c clrb [ %i4 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40003a34: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40003a38: c2 07 60 04 ld [ %i5 + 4 ], %g1
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
40003a3c: 90 07 bf f8 add %fp, -8, %o0
next->previous = previous;
40003a40: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40003a44: 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;
40003a48: 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;
40003a4c: 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 );
40003a50: 84 06 a0 54 add %i2, 0x54, %g2
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
40003a54: 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;
40003a58: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
old_last->next = the_node;
40003a5c: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
40003a60: c2 27 60 04 st %g1, [ %i5 + 4 ]
40003a64: 40 00 01 9a call 400040cc <gettimeofday>
40003a68: 92 10 20 00 clr %o1
40003a6c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40003a70: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
40003a74: 81 c7 e0 08 ret
40003a78: 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;
40003a7c: 40 00 30 1a call 4000fae4 <__errno> <== NOT EXECUTED
40003a80: 01 00 00 00 nop <== NOT EXECUTED
40003a84: 10 80 00 05 b 40003a98 <IMFS_rename+0x9c> <== NOT EXECUTED
40003a88: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
40003a8c: 40 00 30 16 call 4000fae4 <__errno> <== NOT EXECUTED
40003a90: 01 00 00 00 nop <== NOT EXECUTED
40003a94: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40003a98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003a9c: 81 c7 e0 08 ret <== NOT EXECUTED
40003aa0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40003b7c <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40003b7c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40003b80: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40003b84: 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;
40003b88: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
40003b8c: c4 00 80 00 ld [ %g2 ], %g2
40003b90: 80 a0 a0 00 cmp %g2, 0
40003b94: 12 80 00 0d bne 40003bc8 <IMFS_unmount+0x4c> <== NEVER TAKEN
40003b98: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
40003b9c: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40003ba0: 80 a0 80 18 cmp %g2, %i0
40003ba4: 12 80 00 05 bne 40003bb8 <IMFS_unmount+0x3c> <== NEVER TAKEN
40003ba8: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
40003bac: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
40003bb0: 81 c7 e0 08 ret
40003bb4: 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;
40003bb8: 40 00 2f cb call 4000fae4 <__errno> <== NOT EXECUTED
40003bbc: 01 00 00 00 nop <== NOT EXECUTED
40003bc0: 10 80 00 05 b 40003bd4 <IMFS_unmount+0x58> <== NOT EXECUTED
40003bc4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40003bc8: 40 00 2f c7 call 4000fae4 <__errno> <== NOT EXECUTED
40003bcc: 01 00 00 00 nop <== NOT EXECUTED
40003bd0: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14> <== NOT EXECUTED
40003bd4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003bd8: 81 c7 e0 08 ret <== NOT EXECUTED
40003bdc: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400042b8 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
400042b8: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
400042bc: 03 10 00 79 sethi %hi(0x4001e400), %g1
400042c0: f6 00 63 30 ld [ %g1 + 0x330 ], %i3 ! 4001e730 <RTEMS_Malloc_Heap>
if ( !rtems_configuration_get_unified_work_area() ) {
400042c4: 03 10 00 72 sethi %hi(0x4001c800), %g1
400042c8: c2 08 60 09 ldub [ %g1 + 9 ], %g1 ! 4001c809 <Configuration+0x31>
400042cc: 80 a0 60 00 cmp %g1, 0
400042d0: 12 80 00 1b bne 4000433c <RTEMS_Malloc_Initialize+0x84>
400042d4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
400042d8: 3b 10 00 24 sethi %hi(0x40009000), %i5
400042dc: b8 10 20 00 clr %i4
400042e0: 10 80 00 0b b 4000430c <RTEMS_Malloc_Initialize+0x54>
400042e4: ba 17 61 d4 or %i5, 0x1d4, %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)(
400042e8: d4 06 20 04 ld [ %i0 + 4 ], %o2
400042ec: 90 10 00 1b mov %i3, %o0
400042f0: 9f c7 40 00 call %i5
400042f4: 96 10 20 08 mov 8, %o3
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
400042f8: 80 a2 20 00 cmp %o0, 0
400042fc: 32 80 00 02 bne,a 40004304 <RTEMS_Malloc_Initialize+0x4c><== ALWAYS TAKEN
40004300: 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) {
40004304: b8 07 20 01 inc %i4
40004308: b0 06 20 08 add %i0, 8, %i0
4000430c: 80 a7 00 19 cmp %i4, %i1
40004310: 32 bf ff f6 bne,a 400042e8 <RTEMS_Malloc_Initialize+0x30>
40004314: d2 06 00 00 ld [ %i0 ], %o1
if ( space_available > 0 ) {
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40004318: 03 10 00 24 sethi %hi(0x40009000), %g1
4000431c: 82 10 61 d4 or %g1, 0x1d4, %g1 ! 400091d4 <_Heap_Initialize>
40004320: 80 a7 40 01 cmp %i5, %g1
40004324: 12 80 00 06 bne 4000433c <RTEMS_Malloc_Initialize+0x84>
40004328: 03 10 00 7b sethi %hi(0x4001ec00), %g1
_Internal_error_Occurred(
4000432c: 90 10 20 00 clr %o0
40004330: 92 10 20 01 mov 1, %o1
40004334: 40 00 14 3b call 40009420 <_Internal_error_Occurred>
40004338: 94 10 20 17 mov 0x17, %o2
}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
4000433c: c2 00 62 60 ld [ %g1 + 0x260 ], %g1
40004340: 80 a0 60 00 cmp %g1, 0
40004344: 02 80 00 05 be 40004358 <RTEMS_Malloc_Initialize+0xa0>
40004348: 3b 10 00 7c sethi %hi(0x4001f000), %i5
(*rtems_malloc_statistics_helpers->initialize)();
4000434c: c2 00 40 00 ld [ %g1 ], %g1
40004350: 9f c0 40 00 call %g1
40004354: 01 00 00 00 nop
}
MSBUMP( space_available, _Protected_heap_Get_size( heap ) );
40004358: f8 07 63 00 ld [ %i5 + 0x300 ], %i4
4000435c: 40 00 16 7b call 40009d48 <_Protected_heap_Get_size>
40004360: 90 10 00 1b mov %i3, %o0
40004364: 90 02 00 1c add %o0, %i4, %o0
40004368: d0 27 63 00 st %o0, [ %i5 + 0x300 ]
4000436c: 81 c7 e0 08 ret
40004370: 81 e8 00 00 restore
400228e0 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
400228e0: 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) {
400228e4: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED
400228e8: 32 80 00 0a bne,a 40022910 <Stack_check_Dump_threads_usage+0x30><== NOT EXECUTED
400228ec: e0 06 21 38 ld [ %i0 + 0x138 ], %l0 <== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
400228f0: 3b 10 01 93 sethi %hi(0x40064c00), %i5 <== NOT EXECUTED
400228f4: ba 17 62 7c or %i5, 0x27c, %i5 ! 40064e7c <Stack_check_Interrupt_stack><== NOT EXECUTED
400228f8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
400228fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40022900: 02 80 00 4c be 40022a30 <Stack_check_Dump_threads_usage+0x150><== NOT EXECUTED
40022904: a0 10 20 00 clr %l0 <== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
40022908: 10 80 00 04 b 40022918 <Stack_check_Dump_threads_usage+0x38><== NOT EXECUTED
4002290c: b0 10 20 00 clr %i0 <== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
40022910: 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);
40022914: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
40022918: 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);
4002291c: 84 00 60 10 add %g1, 0x10, %g2 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
40022920: 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;
40022924: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
40022928: 86 0e 7f fc and %i1, -4, %g3 <== NOT EXECUTED
if (*base != U32_PATTERN)
4002292c: 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++)
40022930: 86 00 40 03 add %g1, %g3, %g3 <== NOT EXECUTED
if (*base != U32_PATTERN)
40022934: 10 80 00 06 b 4002294c <Stack_check_Dump_threads_usage+0x6c><== NOT EXECUTED
40022938: 88 11 21 a5 or %g4, 0x1a5, %g4 <== NOT EXECUTED
4002293c: 80 a7 00 04 cmp %i4, %g4 <== NOT EXECUTED
40022940: 12 80 00 08 bne 40022960 <Stack_check_Dump_threads_usage+0x80><== NOT EXECUTED
40022944: 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++)
40022948: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED
4002294c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
40022950: 2a bf ff fb bcs,a 4002293c <Stack_check_Dump_threads_usage+0x5c><== NOT EXECUTED
40022954: 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;
40022958: 10 80 00 06 b 40022970 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
4002295c: 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 )
40022960: 02 80 00 04 be 40022970 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
40022964: b8 10 20 00 clr %i4 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
40022968: b8 00 80 19 add %g2, %i1, %i4 <== NOT EXECUTED
4002296c: b8 27 00 01 sub %i4, %g1, %i4 <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
40022970: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40022974: 02 80 00 12 be 400229bc <Stack_check_Dump_threads_usage+0xdc><== NOT EXECUTED
40022978: 03 10 01 8e sethi %hi(0x40063800), %g1 <== NOT EXECUTED
#endif
{
(*print_handler)(
4002297c: f6 06 20 08 ld [ %i0 + 8 ], %i3 <== NOT EXECUTED
40022980: f4 00 63 28 ld [ %g1 + 0x328 ], %i2 <== NOT EXECUTED
40022984: 03 10 01 8e sethi %hi(0x40063800), %g1 <== NOT EXECUTED
40022988: e2 00 63 24 ld [ %g1 + 0x324 ], %l1 ! 40063b24 <print_context><== NOT EXECUTED
4002298c: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
40022990: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40022994: 7f ff b2 92 call 4000f3dc <rtems_object_get_name> <== NOT EXECUTED
40022998: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
4002299c: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
400229a0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400229a4: 92 12 60 08 or %o1, 8, %o1 <== NOT EXECUTED
400229a8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
400229ac: 9f c6 80 00 call %i2 <== NOT EXECUTED
400229b0: 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,
400229b4: 10 80 00 0a b 400229dc <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
400229b8: 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 );
400229bc: 05 10 01 8e sethi %hi(0x40063800), %g2 <== NOT EXECUTED
400229c0: c2 00 63 28 ld [ %g1 + 0x328 ], %g1 <== NOT EXECUTED
400229c4: d0 00 a3 24 ld [ %g2 + 0x324 ], %o0 <== NOT EXECUTED
400229c8: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
400229cc: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
400229d0: 9f c0 40 00 call %g1 <== NOT EXECUTED
400229d4: 92 12 60 18 or %o1, 0x18, %o1 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400229d8: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400229dc: 35 10 01 8e sethi %hi(0x40063800), %i2 <== NOT EXECUTED
400229e0: 37 10 01 8e sethi %hi(0x40063800), %i3 <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400229e4: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400229e8: c2 06 a3 28 ld [ %i2 + 0x328 ], %g1 <== NOT EXECUTED
400229ec: d0 06 e3 24 ld [ %i3 + 0x324 ], %o0 <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400229f0: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400229f4: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
400229f8: 96 02 80 0b add %o2, %o3, %o3 <== NOT EXECUTED
400229fc: 92 12 60 28 or %o1, 0x28, %o1 <== NOT EXECUTED
40022a00: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
40022a04: 9f c0 40 00 call %g1 <== NOT EXECUTED
40022a08: 9a 10 00 19 mov %i1, %o5 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
40022a0c: 03 10 01 8e sethi %hi(0x40063800), %g1 <== NOT EXECUTED
40022a10: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 40063b20 <Stack_check_Initialized><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40022a14: d0 06 e3 24 ld [ %i3 + 0x324 ], %o0 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
40022a18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40022a1c: 12 80 00 07 bne 40022a38 <Stack_check_Dump_threads_usage+0x158><== NOT EXECUTED
40022a20: c2 06 a3 28 ld [ %i2 + 0x328 ], %g1 <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40022a24: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
40022a28: 9f c0 40 00 call %g1 <== NOT EXECUTED
40022a2c: 92 12 60 48 or %o1, 0x48, %o1 ! 4005a848 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
40022a30: 81 c7 e0 08 ret <== NOT EXECUTED
40022a34: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
40022a38: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
40022a3c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40022a40: 9f c0 40 00 call %g1 <== NOT EXECUTED
40022a44: 92 12 60 58 or %o1, 0x58, %o1 <== NOT EXECUTED
40022a48: 81 c7 e0 08 ret <== NOT EXECUTED
40022a4c: 81 e8 00 00 restore <== NOT EXECUTED
40022b38 <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)
{
40022b38: 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");
40022b3c: 11 10 01 6a sethi %hi(0x4005a800), %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);
40022b40: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
40022b44: 7f ff 87 69 call 400048e8 <printk> <== NOT EXECUTED
40022b48: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
40022b4c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40022b50: 11 10 01 6a sethi %hi(0x4005a800), %o0 <== NOT EXECUTED
40022b54: 7f ff 87 65 call 400048e8 <printk> <== NOT EXECUTED
40022b58: 90 12 20 70 or %o0, 0x70, %o0 ! 4005a870 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328><== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
40022b5c: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
40022b60: 11 10 01 6a sethi %hi(0x4005a800), %o0 <== NOT EXECUTED
40022b64: 7f ff 87 61 call 400048e8 <printk> <== NOT EXECUTED
40022b68: 90 12 20 90 or %o0, 0x90, %o0 ! 4005a890 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348><== NOT EXECUTED
printk(
40022b6c: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40022b70: 11 10 01 6a sethi %hi(0x4005a800), %o0 <== NOT EXECUTED
40022b74: 7f ff 87 5d call 400048e8 <printk> <== NOT EXECUTED
40022b78: 90 12 20 a8 or %o0, 0xa8, %o0 ! 4005a8a8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360><== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
40022b7c: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED
40022b80: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
40022b84: 7f ff b2 16 call 4000f3dc <rtems_object_get_name> <== NOT EXECUTED
40022b88: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
40022b8c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40022b90: 11 10 01 6a sethi %hi(0x4005a800), %o0 <== NOT EXECUTED
40022b94: 7f ff 87 55 call 400048e8 <printk> <== NOT EXECUTED
40022b98: 90 12 20 c0 or %o0, 0xc0, %o0 ! 4005a8c0 <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)
40022b9c: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2 <== NOT EXECUTED
40022ba0: 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(
40022ba4: 11 10 01 6a sethi %hi(0x4005a800), %o0 <== NOT EXECUTED
40022ba8: 96 02 80 09 add %o2, %o1, %o3 <== NOT EXECUTED
40022bac: 7f ff 87 4f call 400048e8 <printk> <== NOT EXECUTED
40022bb0: 90 12 20 d8 or %o0, 0xd8, %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) {
40022bb4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40022bb8: 32 80 00 09 bne,a 40022bdc <Stack_check_report_blown_task+0xa4><== NOT EXECUTED
40022bbc: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
printk(
40022bc0: 11 10 01 6a sethi %hi(0x4005a800), %o0 <== NOT EXECUTED
40022bc4: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
40022bc8: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
40022bcc: 94 07 60 08 add %i5, 8, %o2 <== NOT EXECUTED
40022bd0: 7f ff 87 46 call 400048e8 <printk> <== NOT EXECUTED
40022bd4: 96 07 60 18 add %i5, 0x18, %o3 <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
40022bd8: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40022bdc: 7f ff 95 53 call 40008128 <rtems_fatal> <== NOT EXECUTED
40022be0: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
4000ad6c <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
4000ad6c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
4000ad70: 03 10 00 6d sethi %hi(0x4001b400), %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 );
4000ad74: 7f ff e2 fc call 40003964 <sparc_disable_interrupts>
4000ad78: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 ! 4001b420 <_Per_CPU_Information+0x10>
4000ad7c: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
4000ad80: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
4000ad84: 80 a0 60 00 cmp %g1, 0
4000ad88: 12 80 00 08 bne 4000ada8 <_CORE_RWLock_Release+0x3c>
4000ad8c: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
4000ad90: 7f ff e2 f9 call 40003974 <sparc_enable_interrupts>
4000ad94: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
4000ad98: 82 10 20 02 mov 2, %g1
4000ad9c: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
4000ada0: 81 c7 e0 08 ret
4000ada4: 81 e8 00 00 restore
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
4000ada8: 32 80 00 0b bne,a 4000add4 <_CORE_RWLock_Release+0x68>
4000adac: c0 27 60 34 clr [ %i5 + 0x34 ]
the_rwlock->number_of_readers -= 1;
4000adb0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000adb4: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
4000adb8: 80 a0 60 00 cmp %g1, 0
4000adbc: 02 80 00 05 be 4000add0 <_CORE_RWLock_Release+0x64>
4000adc0: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
4000adc4: 7f ff e2 ec call 40003974 <sparc_enable_interrupts>
4000adc8: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
4000adcc: 30 80 00 24 b,a 4000ae5c <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
4000add0: 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;
4000add4: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
4000add8: 7f ff e2 e7 call 40003974 <sparc_enable_interrupts>
4000addc: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
4000ade0: 40 00 07 6d call 4000cb94 <_Thread_queue_Dequeue>
4000ade4: 90 10 00 18 mov %i0, %o0
if ( next ) {
4000ade8: 80 a2 20 00 cmp %o0, 0
4000adec: 22 80 00 1c be,a 4000ae5c <_CORE_RWLock_Release+0xf0>
4000adf0: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
4000adf4: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4000adf8: 80 a0 60 01 cmp %g1, 1
4000adfc: 32 80 00 05 bne,a 4000ae10 <_CORE_RWLock_Release+0xa4>
4000ae00: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
4000ae04: 82 10 20 02 mov 2, %g1
return CORE_RWLOCK_SUCCESSFUL;
4000ae08: 10 80 00 14 b 4000ae58 <_CORE_RWLock_Release+0xec>
4000ae0c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4000ae10: 82 00 60 01 inc %g1
4000ae14: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4000ae18: 82 10 20 01 mov 1, %g1
4000ae1c: 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 );
4000ae20: 40 00 08 99 call 4000d084 <_Thread_queue_First>
4000ae24: 90 10 00 18 mov %i0, %o0
if ( !next ||
4000ae28: 92 92 20 00 orcc %o0, 0, %o1
4000ae2c: 22 80 00 0c be,a 4000ae5c <_CORE_RWLock_Release+0xf0>
4000ae30: b0 10 20 00 clr %i0
4000ae34: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
4000ae38: 80 a0 60 01 cmp %g1, 1
4000ae3c: 02 80 00 07 be 4000ae58 <_CORE_RWLock_Release+0xec> <== NEVER TAKEN
4000ae40: 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;
4000ae44: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000ae48: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
4000ae4c: 40 00 08 3f call 4000cf48 <_Thread_queue_Extract>
4000ae50: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
}
4000ae54: 30 bf ff f3 b,a 4000ae20 <_CORE_RWLock_Release+0xb4>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000ae58: b0 10 20 00 clr %i0
4000ae5c: 81 c7 e0 08 ret
4000ae60: 81 e8 00 00 restore
4000ae64 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
4000ae64: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000ae68: 90 10 00 18 mov %i0, %o0
4000ae6c: 40 00 06 7e call 4000c864 <_Thread_Get>
4000ae70: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000ae74: c2 07 bf fc ld [ %fp + -4 ], %g1
4000ae78: 80 a0 60 00 cmp %g1, 0
4000ae7c: 12 80 00 08 bne 4000ae9c <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
4000ae80: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000ae84: 40 00 08 bd call 4000d178 <_Thread_queue_Process_timeout>
4000ae88: 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;
4000ae8c: 03 10 00 6b sethi %hi(0x4001ac00), %g1
4000ae90: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 4001af00 <_Thread_Dispatch_disable_level>
--level;
4000ae94: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000ae98: c4 20 63 00 st %g2, [ %g1 + 0x300 ]
4000ae9c: 81 c7 e0 08 ret
4000aea0: 81 e8 00 00 restore
40008efc <_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
)
{
40008efc: 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)) ) {
40008f00: 90 10 00 18 mov %i0, %o0
40008f04: 40 00 07 3d call 4000abf8 <_Thread_queue_Dequeue>
40008f08: ba 10 00 18 mov %i0, %i5
40008f0c: 80 a2 20 00 cmp %o0, 0
40008f10: 12 80 00 0e bne 40008f48 <_CORE_semaphore_Surrender+0x4c>
40008f14: 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 );
40008f18: 7f ff e5 4c call 40002448 <sparc_disable_interrupts>
40008f1c: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
40008f20: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
40008f24: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
40008f28: 80 a0 40 02 cmp %g1, %g2
40008f2c: 1a 80 00 05 bcc 40008f40 <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
40008f30: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
40008f34: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
40008f38: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
40008f3c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
40008f40: 7f ff e5 46 call 40002458 <sparc_enable_interrupts>
40008f44: 01 00 00 00 nop
}
return status;
}
40008f48: 81 c7 e0 08 ret
40008f4c: 81 e8 00 00 restore
40007b84 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
40007b84: 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;
40007b88: e0 06 20 30 ld [ %i0 + 0x30 ], %l0
_ISR_Disable( level );
40007b8c: 7f ff ea 2f call 40002448 <sparc_disable_interrupts>
40007b90: ba 10 00 18 mov %i0, %i5
40007b94: 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;
40007b98: c2 06 80 00 ld [ %i2 ], %g1
40007b9c: b2 16 40 01 or %i1, %g1, %i1
40007ba0: 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;
40007ba4: 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 ) ) {
40007ba8: 82 8e 40 02 andcc %i1, %g2, %g1
40007bac: 02 80 00 3d be 40007ca0 <_Event_Surrender+0x11c>
40007bb0: 07 10 00 7e sethi %hi(0x4001f800), %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() &&
40007bb4: 86 10 e1 90 or %g3, 0x190, %g3 ! 4001f990 <_Per_CPU_Information>
40007bb8: c8 00 e0 08 ld [ %g3 + 8 ], %g4
40007bbc: 80 a1 20 00 cmp %g4, 0
40007bc0: 22 80 00 18 be,a 40007c20 <_Event_Surrender+0x9c>
40007bc4: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
40007bc8: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
40007bcc: 80 a7 40 03 cmp %i5, %g3
40007bd0: 32 80 00 14 bne,a 40007c20 <_Event_Surrender+0x9c>
40007bd4: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
40007bd8: c6 06 c0 00 ld [ %i3 ], %g3
40007bdc: 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 ) &&
40007be0: 80 a0 e0 01 cmp %g3, 1
40007be4: 38 80 00 0f bgu,a 40007c20 <_Event_Surrender+0x9c>
40007be8: 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) ) {
40007bec: 80 a0 40 02 cmp %g1, %g2
40007bf0: 02 80 00 04 be 40007c00 <_Event_Surrender+0x7c>
40007bf4: 80 8c 20 02 btst 2, %l0
40007bf8: 02 80 00 2a be 40007ca0 <_Event_Surrender+0x11c> <== NEVER TAKEN
40007bfc: 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) );
40007c00: 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;
40007c04: 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(
40007c08: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40007c0c: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40007c10: c2 20 80 00 st %g1, [ %g2 ]
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
40007c14: 82 10 20 03 mov 3, %g1
40007c18: 10 80 00 22 b 40007ca0 <_Event_Surrender+0x11c>
40007c1c: 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 ) ) {
40007c20: 80 8f 00 03 btst %i4, %g3
40007c24: 02 80 00 1f be 40007ca0 <_Event_Surrender+0x11c>
40007c28: 80 a0 40 02 cmp %g1, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40007c2c: 02 80 00 04 be 40007c3c <_Event_Surrender+0xb8>
40007c30: 80 8c 20 02 btst 2, %l0
40007c34: 02 80 00 1b be 40007ca0 <_Event_Surrender+0x11c> <== NEVER TAKEN
40007c38: 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;
40007c3c: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
40007c40: 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(
40007c44: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40007c48: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40007c4c: c2 20 80 00 st %g1, [ %g2 ]
_ISR_Flash( level );
40007c50: 7f ff ea 02 call 40002458 <sparc_enable_interrupts>
40007c54: 90 10 00 18 mov %i0, %o0
40007c58: 7f ff e9 fc call 40002448 <sparc_disable_interrupts>
40007c5c: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
40007c60: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
40007c64: 80 a0 60 02 cmp %g1, 2
40007c68: 02 80 00 06 be 40007c80 <_Event_Surrender+0xfc>
40007c6c: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
40007c70: 7f ff e9 fa call 40002458 <sparc_enable_interrupts>
40007c74: 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 );
40007c78: 10 80 00 08 b 40007c98 <_Event_Surrender+0x114>
40007c7c: 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;
40007c80: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
40007c84: 7f ff e9 f5 call 40002458 <sparc_enable_interrupts>
40007c88: 33 04 01 ff sethi %hi(0x1007fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
40007c8c: 40 00 0e 6a call 4000b634 <_Watchdog_Remove>
40007c90: 90 07 60 48 add %i5, 0x48, %o0
40007c94: b2 16 63 f8 or %i1, 0x3f8, %i1
40007c98: 40 00 0a 2a call 4000a540 <_Thread_Clear_state>
40007c9c: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
40007ca0: 7f ff e9 ee call 40002458 <sparc_enable_interrupts>
40007ca4: 81 e8 00 00 restore
40007ca8 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
40007ca8: 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 );
40007cac: 90 10 00 18 mov %i0, %o0
40007cb0: 40 00 0b 06 call 4000a8c8 <_Thread_Get>
40007cb4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40007cb8: c2 07 bf fc ld [ %fp + -4 ], %g1
40007cbc: 80 a0 60 00 cmp %g1, 0
40007cc0: 12 80 00 1b bne 40007d2c <_Event_Timeout+0x84> <== NEVER TAKEN
40007cc4: 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 );
40007cc8: 7f ff e9 e0 call 40002448 <sparc_disable_interrupts>
40007ccc: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
40007cd0: 03 10 00 7e sethi %hi(0x4001f800), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
40007cd4: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 ! 4001f9a0 <_Per_CPU_Information+0x10>
40007cd8: 80 a7 40 01 cmp %i5, %g1
40007cdc: 12 80 00 08 bne 40007cfc <_Event_Timeout+0x54>
40007ce0: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
40007ce4: c2 06 40 00 ld [ %i1 ], %g1
40007ce8: 80 a0 60 01 cmp %g1, 1
40007cec: 12 80 00 05 bne 40007d00 <_Event_Timeout+0x58>
40007cf0: 82 10 20 06 mov 6, %g1
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
40007cf4: 82 10 20 02 mov 2, %g1
40007cf8: c2 26 40 00 st %g1, [ %i1 ]
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
40007cfc: 82 10 20 06 mov 6, %g1
40007d00: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
40007d04: 7f ff e9 d5 call 40002458 <sparc_enable_interrupts>
40007d08: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40007d0c: 90 10 00 1d mov %i5, %o0
40007d10: 13 04 01 ff sethi %hi(0x1007fc00), %o1
40007d14: 40 00 0a 0b call 4000a540 <_Thread_Clear_state>
40007d18: 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;
40007d1c: 03 10 00 7d sethi %hi(0x4001f400), %g1
40007d20: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 4001f480 <_Thread_Dispatch_disable_level>
--level;
40007d24: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40007d28: c4 20 60 80 st %g2, [ %g1 + 0x80 ]
40007d2c: 81 c7 e0 08 ret
40007d30: 81 e8 00 00 restore
4000dcb0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4000dcb0: 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 ) {
4000dcb4: 80 a6 60 00 cmp %i1, 0
4000dcb8: 02 80 00 7a be 4000dea0 <_Heap_Free+0x1f0>
4000dcbc: 88 10 20 01 mov 1, %g4
4000dcc0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4000dcc4: 40 00 2c a3 call 40018f50 <.urem>
4000dcc8: 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
4000dccc: 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);
4000dcd0: 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);
4000dcd4: 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;
4000dcd8: 80 a2 00 1b cmp %o0, %i3
4000dcdc: 0a 80 00 05 bcs 4000dcf0 <_Heap_Free+0x40>
4000dce0: 82 10 20 00 clr %g1
4000dce4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000dce8: 80 a0 40 08 cmp %g1, %o0
4000dcec: 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 ) ) {
4000dcf0: 80 a0 60 00 cmp %g1, 0
4000dcf4: 02 80 00 6b be 4000dea0 <_Heap_Free+0x1f0>
4000dcf8: 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;
4000dcfc: f8 02 20 04 ld [ %o0 + 4 ], %i4
4000dd00: 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);
4000dd04: 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;
4000dd08: 80 a0 40 1b cmp %g1, %i3
4000dd0c: 0a 80 00 05 bcs 4000dd20 <_Heap_Free+0x70> <== NEVER TAKEN
4000dd10: 86 10 20 00 clr %g3
4000dd14: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
4000dd18: 80 a0 c0 01 cmp %g3, %g1
4000dd1c: 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 ) ) {
4000dd20: 80 a0 e0 00 cmp %g3, 0
4000dd24: 02 80 00 5f be 4000dea0 <_Heap_Free+0x1f0> <== NEVER TAKEN
4000dd28: 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;
4000dd2c: fa 00 60 04 ld [ %g1 + 4 ], %i5
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4000dd30: 80 8f 60 01 btst 1, %i5
4000dd34: 22 80 00 5c be,a 4000dea4 <_Heap_Free+0x1f4> <== NEVER TAKEN
4000dd38: 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
4000dd3c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000dd40: 80 a0 40 04 cmp %g1, %g4
4000dd44: 02 80 00 07 be 4000dd60 <_Heap_Free+0xb0>
4000dd48: ba 0f 7f fe and %i5, -2, %i5
4000dd4c: 86 00 40 1d add %g1, %i5, %g3
4000dd50: f4 00 e0 04 ld [ %g3 + 4 ], %i2
4000dd54: b4 1e a0 01 xor %i2, 1, %i2
4000dd58: 10 80 00 03 b 4000dd64 <_Heap_Free+0xb4>
4000dd5c: b4 0e a0 01 and %i2, 1, %i2
4000dd60: b4 10 20 00 clr %i2
if ( !_Heap_Is_prev_used( block ) ) {
4000dd64: 80 8f 20 01 btst 1, %i4
4000dd68: 12 80 00 26 bne 4000de00 <_Heap_Free+0x150>
4000dd6c: 80 8e a0 ff btst 0xff, %i2
uintptr_t const prev_size = block->prev_size;
4000dd70: 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);
4000dd74: 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;
4000dd78: 80 a0 c0 1b cmp %g3, %i3
4000dd7c: 0a 80 00 04 bcs 4000dd8c <_Heap_Free+0xdc> <== NEVER TAKEN
4000dd80: b2 10 20 00 clr %i1
4000dd84: 80 a1 00 03 cmp %g4, %g3
4000dd88: 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 ) ) {
4000dd8c: 80 a6 60 00 cmp %i1, 0
4000dd90: 02 80 00 44 be 4000dea0 <_Heap_Free+0x1f0> <== NEVER TAKEN
4000dd94: 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;
4000dd98: 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) ) {
4000dd9c: 80 8e e0 01 btst 1, %i3
4000dda0: 02 80 00 40 be 4000dea0 <_Heap_Free+0x1f0> <== NEVER TAKEN
4000dda4: 80 8e a0 ff btst 0xff, %i2
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4000dda8: 22 80 00 0f be,a 4000dde4 <_Heap_Free+0x134>
4000ddac: 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;
4000ddb0: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = block->prev;
4000ddb4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
uintptr_t const size = block_size + prev_size + next_block_size;
4000ddb8: ba 00 80 1d add %g2, %i5, %i5
prev->next = next;
4000ddbc: c8 20 60 08 st %g4, [ %g1 + 8 ]
next->prev = prev;
4000ddc0: c2 21 20 0c st %g1, [ %g4 + 0xc ]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4000ddc4: 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;
4000ddc8: b8 07 40 1c add %i5, %i4, %i4
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4000ddcc: 82 00 7f ff add %g1, -1, %g1
4000ddd0: 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;
4000ddd4: 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;
4000ddd8: 82 17 20 01 or %i4, 1, %g1
4000dddc: 10 80 00 27 b 4000de78 <_Heap_Free+0x1c8>
4000dde0: 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;
4000dde4: 88 17 20 01 or %i4, 1, %g4
4000dde8: c8 20 e0 04 st %g4, [ %g3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000ddec: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = size;
4000ddf0: 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;
4000ddf4: 86 08 ff fe and %g3, -2, %g3
4000ddf8: 10 80 00 20 b 4000de78 <_Heap_Free+0x1c8>
4000ddfc: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4000de00: 22 80 00 0d be,a 4000de34 <_Heap_Free+0x184>
4000de04: 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;
4000de08: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = old_block->prev;
4000de0c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
new_block->next = next;
4000de10: c8 22 20 08 st %g4, [ %o0 + 8 ]
new_block->prev = prev;
4000de14: c2 22 20 0c st %g1, [ %o0 + 0xc ]
uintptr_t const size = block_size + next_block_size;
4000de18: 86 07 40 02 add %i5, %g2, %g3
next->prev = new_block;
prev->next = new_block;
4000de1c: 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;
4000de20: d0 21 20 0c st %o0, [ %g4 + 0xc ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000de24: 82 10 e0 01 or %g3, 1, %g1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4000de28: 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;
4000de2c: 10 80 00 13 b 4000de78 <_Heap_Free+0x1c8>
4000de30: c2 22 20 04 st %g1, [ %o0 + 4 ]
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
4000de34: f0 22 20 0c st %i0, [ %o0 + 0xc ]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4000de38: c6 22 20 08 st %g3, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
4000de3c: 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;
4000de40: 86 10 a0 01 or %g2, 1, %g3
4000de44: c6 22 20 04 st %g3, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000de48: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = block_size;
4000de4c: 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;
4000de50: 86 08 ff fe and %g3, -2, %g3
4000de54: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4000de58: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
if ( stats->max_free_blocks < stats->free_blocks ) {
4000de5c: 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;
4000de60: 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;
4000de64: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
4000de68: 80 a0 c0 01 cmp %g3, %g1
4000de6c: 1a 80 00 03 bcc 4000de78 <_Heap_Free+0x1c8>
4000de70: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
4000de74: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
}
/* Statistics */
--stats->used_blocks;
4000de78: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4000de7c: 82 00 7f ff add %g1, -1, %g1
4000de80: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
++stats->frees;
4000de84: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000de88: 82 00 60 01 inc %g1
4000de8c: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->free_size += block_size;
4000de90: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4000de94: 84 00 40 02 add %g1, %g2, %g2
4000de98: 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;
4000de9c: 88 10 20 01 mov 1, %g4
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4000dea0: b0 09 20 01 and %g4, 1, %i0
4000dea4: 81 c7 e0 08 ret
4000dea8: 81 e8 00 00 restore
4000b0ec <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
4000b0ec: 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) {
4000b0f0: b6 10 20 00 clr %i3
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
4000b0f4: 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) {
4000b0f8: 10 80 00 11 b 4000b13c <_Heap_Greedy_allocate+0x50>
4000b0fc: 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 );
4000b100: d2 06 40 01 ld [ %i1 + %g1 ], %o1
4000b104: 90 10 00 1d mov %i5, %o0
4000b108: 94 10 20 00 clr %o2
4000b10c: 40 00 1d 80 call 4001270c <_Heap_Allocate_aligned_with_boundary>
4000b110: 96 10 20 00 clr %o3
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
4000b114: 82 92 20 00 orcc %o0, 0, %g1
4000b118: 22 80 00 09 be,a 4000b13c <_Heap_Greedy_allocate+0x50> <== NEVER TAKEN
4000b11c: 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);
4000b120: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
4000b124: 40 00 34 71 call 400182e8 <.urem>
4000b128: 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);
4000b12c: 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;
4000b130: f8 22 20 08 st %i4, [ %o0 + 8 ]
4000b134: 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) {
4000b138: b6 06 e0 01 inc %i3
4000b13c: 80 a6 c0 1a cmp %i3, %i2
4000b140: 12 bf ff f0 bne 4000b100 <_Heap_Greedy_allocate+0x14>
4000b144: 83 2e e0 02 sll %i3, 2, %g1
4000b148: 10 80 00 0a b 4000b170 <_Heap_Greedy_allocate+0x84>
4000b14c: b0 10 20 00 clr %i0
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
_Heap_Block_allocate(
4000b150: 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;
4000b154: 96 0a ff fe and %o3, -2, %o3
4000b158: 92 10 00 1b mov %i3, %o1
4000b15c: 94 06 e0 08 add %i3, 8, %o2
4000b160: 40 00 00 cb call 4000b48c <_Heap_Block_allocate>
4000b164: 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;
4000b168: f0 26 e0 08 st %i0, [ %i3 + 8 ]
4000b16c: 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;
4000b170: 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 ) {
4000b174: 80 a6 c0 1d cmp %i3, %i5
4000b178: 32 bf ff f6 bne,a 4000b150 <_Heap_Greedy_allocate+0x64>
4000b17c: d6 06 e0 04 ld [ %i3 + 4 ], %o3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
4000b180: 10 80 00 07 b 4000b19c <_Heap_Greedy_allocate+0xb0>
4000b184: 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 ) );
4000b188: 92 07 20 08 add %i4, 8, %o1
4000b18c: 90 10 00 1d mov %i5, %o0
4000b190: 40 00 1d d0 call 400128d0 <_Heap_Free>
4000b194: b8 10 00 1b mov %i3, %i4
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
4000b198: 80 a7 20 00 cmp %i4, 0
4000b19c: 32 bf ff fb bne,a 4000b188 <_Heap_Greedy_allocate+0x9c>
4000b1a0: 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;
}
4000b1a4: 81 c7 e0 08 ret
4000b1a8: 81 e8 00 00 restore
40013714 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40013714: 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;
40013718: 90 10 20 00 clr %o0 <== NOT EXECUTED
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
Heap_Block *current = heap->first_block;
4001371c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
40013720: 10 80 00 0a b 40013748 <_Heap_Iterate+0x34> <== NOT EXECUTED
40013724: 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 );
40013728: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
4001372c: 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);
40013730: 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;
40013734: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
40013738: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4001373c: 9f c6 40 00 call %i1 <== NOT EXECUTED
40013740: 94 0a a0 01 and %o2, 1, %o2 <== NOT EXECUTED
40013744: 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 ) {
40013748: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
4001374c: 02 80 00 05 be 40013760 <_Heap_Iterate+0x4c> <== NOT EXECUTED
40013750: 90 1a 20 01 xor %o0, 1, %o0 <== NOT EXECUTED
40013754: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013758: 32 bf ff f4 bne,a 40013728 <_Heap_Iterate+0x14> <== NOT EXECUTED
4001375c: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40013760: 81 c7 e0 08 ret <== NOT EXECUTED
40013764: 81 e8 00 00 restore <== NOT EXECUTED
4001c4b8 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
4001c4b8: 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);
4001c4bc: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4001c4c0: 7f ff f2 a4 call 40018f50 <.urem>
4001c4c4: 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
4001c4c8: 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);
4001c4cc: 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);
4001c4d0: 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;
4001c4d4: 80 a2 00 04 cmp %o0, %g4
4001c4d8: 0a 80 00 05 bcs 4001c4ec <_Heap_Size_of_alloc_area+0x34>
4001c4dc: 82 10 20 00 clr %g1
4001c4e0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001c4e4: 80 a0 40 08 cmp %g1, %o0
4001c4e8: 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 ) ) {
4001c4ec: 80 a0 60 00 cmp %g1, 0
4001c4f0: 02 80 00 15 be 4001c544 <_Heap_Size_of_alloc_area+0x8c>
4001c4f4: 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;
4001c4f8: c2 02 20 04 ld [ %o0 + 4 ], %g1
4001c4fc: 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);
4001c500: 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;
4001c504: 80 a0 40 04 cmp %g1, %g4
4001c508: 0a 80 00 05 bcs 4001c51c <_Heap_Size_of_alloc_area+0x64> <== NEVER TAKEN
4001c50c: 84 10 20 00 clr %g2
4001c510: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
4001c514: 80 a0 80 01 cmp %g2, %g1
4001c518: 84 60 3f ff subx %g0, -1, %g2
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
4001c51c: 80 a0 a0 00 cmp %g2, 0
4001c520: 02 80 00 09 be 4001c544 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
4001c524: 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;
4001c528: c4 00 60 04 ld [ %g1 + 4 ], %g2
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
4001c52c: 80 88 a0 01 btst 1, %g2
4001c530: 02 80 00 05 be 4001c544 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
4001c534: 82 20 40 19 sub %g1, %i1, %g1
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
4001c538: 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;
4001c53c: 82 00 60 04 add %g1, 4, %g1
4001c540: c2 26 80 00 st %g1, [ %i2 ]
return true;
}
4001c544: b0 08 e0 01 and %g3, 1, %i0
4001c548: 81 c7 e0 08 ret
4001c54c: 81 e8 00 00 restore
40009ce4 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
40009ce4: 9d e3 bf 80 save %sp, -128, %sp
40009ce8: ac 10 00 19 mov %i1, %l6
uintptr_t const page_size = heap->page_size;
40009cec: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
uintptr_t const min_block_size = heap->min_block_size;
40009cf0: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
Heap_Block *const first_block = heap->first_block;
40009cf4: 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;
40009cf8: 80 a6 a0 00 cmp %i2, 0
40009cfc: 02 80 00 05 be 40009d10 <_Heap_Walk+0x2c>
40009d00: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
40009d04: 3b 10 00 27 sethi %hi(0x40009c00), %i5
40009d08: 10 80 00 04 b 40009d18 <_Heap_Walk+0x34>
40009d0c: ba 17 60 94 or %i5, 0x94, %i5 ! 40009c94 <_Heap_Walk_print>
40009d10: 3b 10 00 27 sethi %hi(0x40009c00), %i5
40009d14: ba 17 60 8c or %i5, 0x8c, %i5 ! 40009c8c <_Heap_Walk_print_nothing>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40009d18: 05 10 00 66 sethi %hi(0x40019800), %g2
40009d1c: c4 00 a1 e8 ld [ %g2 + 0x1e8 ], %g2 ! 400199e8 <_System_state_Current>
40009d20: 80 a0 a0 03 cmp %g2, 3
40009d24: 22 80 00 04 be,a 40009d34 <_Heap_Walk+0x50>
40009d28: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
return true;
40009d2c: 10 80 01 2a b 4000a1d4 <_Heap_Walk+0x4f0>
40009d30: 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)(
40009d34: da 06 20 18 ld [ %i0 + 0x18 ], %o5
40009d38: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
40009d3c: f2 23 a0 60 st %i1, [ %sp + 0x60 ]
40009d40: e0 23 a0 64 st %l0, [ %sp + 0x64 ]
40009d44: c4 06 20 08 ld [ %i0 + 8 ], %g2
40009d48: 90 10 00 16 mov %l6, %o0
40009d4c: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40009d50: c4 06 20 0c ld [ %i0 + 0xc ], %g2
40009d54: 92 10 20 00 clr %o1
40009d58: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
40009d5c: 15 10 00 5a sethi %hi(0x40016800), %o2
40009d60: 96 10 00 1c mov %i4, %o3
40009d64: 94 12 a1 90 or %o2, 0x190, %o2
40009d68: 9f c7 40 00 call %i5
40009d6c: 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 ) {
40009d70: 80 a7 20 00 cmp %i4, 0
40009d74: 12 80 00 07 bne 40009d90 <_Heap_Walk+0xac>
40009d78: 80 8f 20 07 btst 7, %i4
(*printer)( source, true, "page size is zero\n" );
40009d7c: 15 10 00 5a sethi %hi(0x40016800), %o2
40009d80: 90 10 00 16 mov %l6, %o0
40009d84: 92 10 20 01 mov 1, %o1
40009d88: 10 80 00 37 b 40009e64 <_Heap_Walk+0x180>
40009d8c: 94 12 a2 28 or %o2, 0x228, %o2
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
40009d90: 22 80 00 08 be,a 40009db0 <_Heap_Walk+0xcc>
40009d94: 90 10 00 1b mov %i3, %o0
(*printer)(
40009d98: 15 10 00 5a sethi %hi(0x40016800), %o2
40009d9c: 90 10 00 16 mov %l6, %o0
40009da0: 92 10 20 01 mov 1, %o1
40009da4: 94 12 a2 40 or %o2, 0x240, %o2
40009da8: 10 80 01 12 b 4000a1f0 <_Heap_Walk+0x50c>
40009dac: 96 10 00 1c mov %i4, %o3
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40009db0: 7f ff df 75 call 40001b84 <.urem>
40009db4: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
40009db8: 80 a2 20 00 cmp %o0, 0
40009dbc: 22 80 00 08 be,a 40009ddc <_Heap_Walk+0xf8>
40009dc0: 90 06 60 08 add %i1, 8, %o0
(*printer)(
40009dc4: 15 10 00 5a sethi %hi(0x40016800), %o2
40009dc8: 90 10 00 16 mov %l6, %o0
40009dcc: 92 10 20 01 mov 1, %o1
40009dd0: 94 12 a2 60 or %o2, 0x260, %o2
40009dd4: 10 80 01 07 b 4000a1f0 <_Heap_Walk+0x50c>
40009dd8: 96 10 00 1b mov %i3, %o3
40009ddc: 7f ff df 6a call 40001b84 <.urem>
40009de0: 92 10 00 1c mov %i4, %o1
);
return false;
}
if (
40009de4: 80 a2 20 00 cmp %o0, 0
40009de8: 22 80 00 07 be,a 40009e04 <_Heap_Walk+0x120>
40009dec: c4 06 60 04 ld [ %i1 + 4 ], %g2
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
40009df0: 15 10 00 5a sethi %hi(0x40016800), %o2
40009df4: 90 10 00 16 mov %l6, %o0
40009df8: 92 10 20 01 mov 1, %o1
40009dfc: 10 80 00 fc b 4000a1ec <_Heap_Walk+0x508>
40009e00: 94 12 a2 88 or %o2, 0x288, %o2
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
40009e04: 80 88 a0 01 btst 1, %g2
40009e08: 32 80 00 07 bne,a 40009e24 <_Heap_Walk+0x140>
40009e0c: f4 04 20 04 ld [ %l0 + 4 ], %i2
(*printer)(
40009e10: 15 10 00 5a sethi %hi(0x40016800), %o2
40009e14: 90 10 00 16 mov %l6, %o0
40009e18: 92 10 20 01 mov 1, %o1
40009e1c: 10 80 00 12 b 40009e64 <_Heap_Walk+0x180>
40009e20: 94 12 a2 c0 or %o2, 0x2c0, %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;
40009e24: 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);
40009e28: 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;
40009e2c: c4 06 a0 04 ld [ %i2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
40009e30: 80 88 a0 01 btst 1, %g2
40009e34: 12 80 00 07 bne 40009e50 <_Heap_Walk+0x16c>
40009e38: 80 a6 80 19 cmp %i2, %i1
(*printer)(
40009e3c: 15 10 00 5a sethi %hi(0x40016800), %o2
40009e40: 90 10 00 16 mov %l6, %o0
40009e44: 92 10 20 01 mov 1, %o1
40009e48: 10 80 00 07 b 40009e64 <_Heap_Walk+0x180>
40009e4c: 94 12 a2 f0 or %o2, 0x2f0, %o2
);
return false;
}
if (
40009e50: 02 80 00 0a be 40009e78 <_Heap_Walk+0x194>
40009e54: 15 10 00 5a sethi %hi(0x40016800), %o2
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
40009e58: 90 10 00 16 mov %l6, %o0
40009e5c: 92 10 20 01 mov 1, %o1
40009e60: 94 12 a3 08 or %o2, 0x308, %o2
40009e64: 9f c7 40 00 call %i5
40009e68: b0 10 20 00 clr %i0
40009e6c: b0 0e 20 ff and %i0, 0xff, %i0
40009e70: 81 c7 e0 08 ret
40009e74: 81 e8 00 00 restore
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
40009e78: 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;
40009e7c: d6 06 20 08 ld [ %i0 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
40009e80: 10 80 00 30 b 40009f40 <_Heap_Walk+0x25c>
40009e84: 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;
40009e88: 80 a0 c0 0b cmp %g3, %o3
40009e8c: 18 80 00 05 bgu 40009ea0 <_Heap_Walk+0x1bc>
40009e90: 84 10 20 00 clr %g2
40009e94: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
40009e98: 80 a0 80 0b cmp %g2, %o3
40009e9c: 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 ) ) {
40009ea0: 80 a0 a0 00 cmp %g2, 0
40009ea4: 32 80 00 07 bne,a 40009ec0 <_Heap_Walk+0x1dc>
40009ea8: 90 02 e0 08 add %o3, 8, %o0
(*printer)(
40009eac: 15 10 00 5a sethi %hi(0x40016800), %o2
40009eb0: 90 10 00 16 mov %l6, %o0
40009eb4: 92 10 20 01 mov 1, %o1
40009eb8: 10 80 00 ce b 4000a1f0 <_Heap_Walk+0x50c>
40009ebc: 94 12 a3 38 or %o2, 0x338, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40009ec0: d6 27 bf fc st %o3, [ %fp + -4 ]
40009ec4: 7f ff df 30 call 40001b84 <.urem>
40009ec8: 92 10 00 11 mov %l1, %o1
);
return false;
}
if (
40009ecc: 80 a2 20 00 cmp %o0, 0
40009ed0: 02 80 00 07 be 40009eec <_Heap_Walk+0x208>
40009ed4: d6 07 bf fc ld [ %fp + -4 ], %o3
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
40009ed8: 15 10 00 5a sethi %hi(0x40016800), %o2
40009edc: 90 10 00 16 mov %l6, %o0
40009ee0: 92 10 20 01 mov 1, %o1
40009ee4: 10 80 00 c3 b 4000a1f0 <_Heap_Walk+0x50c>
40009ee8: 94 12 a3 58 or %o2, 0x358, %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;
40009eec: c4 02 e0 04 ld [ %o3 + 4 ], %g2
40009ef0: 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;
40009ef4: 84 02 c0 02 add %o3, %g2, %g2
40009ef8: c4 00 a0 04 ld [ %g2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
40009efc: 80 88 a0 01 btst 1, %g2
40009f00: 22 80 00 07 be,a 40009f1c <_Heap_Walk+0x238>
40009f04: d8 02 e0 0c ld [ %o3 + 0xc ], %o4
(*printer)(
40009f08: 15 10 00 5a sethi %hi(0x40016800), %o2
40009f0c: 90 10 00 16 mov %l6, %o0
40009f10: 92 10 20 01 mov 1, %o1
40009f14: 10 80 00 b7 b 4000a1f0 <_Heap_Walk+0x50c>
40009f18: 94 12 a3 88 or %o2, 0x388, %o2
);
return false;
}
if ( free_block->prev != prev_block ) {
40009f1c: 80 a3 00 19 cmp %o4, %i1
40009f20: 02 80 00 07 be 40009f3c <_Heap_Walk+0x258>
40009f24: b2 10 00 0b mov %o3, %i1
(*printer)(
40009f28: 15 10 00 5a sethi %hi(0x40016800), %o2
40009f2c: 90 10 00 16 mov %l6, %o0
40009f30: 92 10 20 01 mov 1, %o1
40009f34: 10 80 00 4d b 4000a068 <_Heap_Walk+0x384>
40009f38: 94 12 a3 a8 or %o2, 0x3a8, %o2
return false;
}
prev_block = free_block;
free_block = free_block->next;
40009f3c: 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 ) {
40009f40: 80 a2 c0 18 cmp %o3, %i0
40009f44: 32 bf ff d1 bne,a 40009e88 <_Heap_Walk+0x1a4>
40009f48: 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)(
40009f4c: 2b 10 00 5b sethi %hi(0x40016c00), %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 ) {
40009f50: 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)(
40009f54: aa 15 60 a8 or %l5, 0xa8, %l5
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
40009f58: 23 10 00 5b sethi %hi(0x40016c00), %l1
40009f5c: 2f 10 00 5a sethi %hi(0x40016800), %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;
40009f60: 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;
40009f64: 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;
40009f68: 9e 1e 40 10 xor %i1, %l0, %o7
40009f6c: 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;
40009f70: a8 0c bf fe and %l2, -2, %l4
40009f74: 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);
40009f78: 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;
40009f7c: 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;
40009f80: 80 a3 00 13 cmp %o4, %l3
40009f84: 18 80 00 05 bgu 40009f98 <_Heap_Walk+0x2b4> <== NEVER TAKEN
40009f88: 9e 10 20 00 clr %o7
40009f8c: de 06 20 24 ld [ %i0 + 0x24 ], %o7
40009f90: 80 a3 c0 13 cmp %o7, %l3
40009f94: 9e 60 3f ff subx %g0, -1, %o7
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
40009f98: 80 a3 e0 00 cmp %o7, 0
40009f9c: 32 80 00 07 bne,a 40009fb8 <_Heap_Walk+0x2d4>
40009fa0: da 27 bf f8 st %o5, [ %fp + -8 ]
(*printer)(
40009fa4: 15 10 00 5a sethi %hi(0x40016800), %o2
40009fa8: 90 10 00 16 mov %l6, %o0
40009fac: 92 10 20 01 mov 1, %o1
40009fb0: 10 80 00 2c b 4000a060 <_Heap_Walk+0x37c>
40009fb4: 94 12 a3 e0 or %o2, 0x3e0, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40009fb8: 90 10 00 14 mov %l4, %o0
40009fbc: 7f ff de f2 call 40001b84 <.urem>
40009fc0: 92 10 00 1c mov %i4, %o1
40009fc4: da 07 bf f8 ld [ %fp + -8 ], %o5
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40009fc8: 80 a2 20 00 cmp %o0, 0
40009fcc: 02 80 00 0c be 40009ffc <_Heap_Walk+0x318>
40009fd0: 9e 0b 60 ff and %o5, 0xff, %o7
40009fd4: 80 a3 e0 00 cmp %o7, 0
40009fd8: 02 80 00 19 be 4000a03c <_Heap_Walk+0x358>
40009fdc: 80 a6 40 13 cmp %i1, %l3
(*printer)(
40009fe0: 15 10 00 5b sethi %hi(0x40016c00), %o2
40009fe4: 90 10 00 16 mov %l6, %o0
40009fe8: 92 10 20 01 mov 1, %o1
40009fec: 94 12 a0 10 or %o2, 0x10, %o2
40009ff0: 96 10 00 19 mov %i1, %o3
40009ff4: 10 80 00 1d b 4000a068 <_Heap_Walk+0x384>
40009ff8: 98 10 00 14 mov %l4, %o4
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
40009ffc: 80 a3 e0 00 cmp %o7, 0
4000a000: 02 80 00 0f be 4000a03c <_Heap_Walk+0x358>
4000a004: 80 a6 40 13 cmp %i1, %l3
4000a008: 80 a5 00 1b cmp %l4, %i3
4000a00c: 1a 80 00 0c bcc 4000a03c <_Heap_Walk+0x358>
4000a010: 80 a6 40 13 cmp %i1, %l3
(*printer)(
4000a014: 90 10 00 16 mov %l6, %o0
4000a018: 92 10 20 01 mov 1, %o1
4000a01c: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000a020: 96 10 00 19 mov %i1, %o3
4000a024: 94 12 a0 40 or %o2, 0x40, %o2
4000a028: 98 10 00 14 mov %l4, %o4
4000a02c: 9f c7 40 00 call %i5
4000a030: 9a 10 00 1b mov %i3, %o5
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
4000a034: 10 80 00 68 b 4000a1d4 <_Heap_Walk+0x4f0>
4000a038: b0 10 20 00 clr %i0
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
4000a03c: 2a 80 00 10 bcs,a 4000a07c <_Heap_Walk+0x398>
4000a040: de 04 e0 04 ld [ %l3 + 4 ], %o7
4000a044: 80 8b 60 ff btst 0xff, %o5
4000a048: 22 80 00 0d be,a 4000a07c <_Heap_Walk+0x398>
4000a04c: de 04 e0 04 ld [ %l3 + 4 ], %o7
(*printer)(
4000a050: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000a054: 90 10 00 16 mov %l6, %o0
4000a058: 92 10 20 01 mov 1, %o1
4000a05c: 94 12 a0 70 or %o2, 0x70, %o2
4000a060: 96 10 00 19 mov %i1, %o3
4000a064: 98 10 00 13 mov %l3, %o4
4000a068: 9f c7 40 00 call %i5
4000a06c: b0 10 20 00 clr %i0
4000a070: b0 0e 20 ff and %i0, 0xff, %i0
4000a074: 81 c7 e0 08 ret
4000a078: 81 e8 00 00 restore
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
4000a07c: 80 8b e0 01 btst 1, %o7
4000a080: 12 80 00 3f bne 4000a17c <_Heap_Walk+0x498>
4000a084: 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 ?
4000a088: 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)(
4000a08c: d8 06 20 08 ld [ %i0 + 8 ], %o4
4000a090: 80 a3 40 0c cmp %o5, %o4
4000a094: 02 80 00 08 be 4000a0b4 <_Heap_Walk+0x3d0>
4000a098: 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)" : ""),
4000a09c: 80 a3 40 18 cmp %o5, %i0
4000a0a0: 12 80 00 07 bne 4000a0bc <_Heap_Walk+0x3d8>
4000a0a4: 96 14 61 18 or %l1, 0x118, %o3
4000a0a8: 17 10 00 5a sethi %hi(0x40016800), %o3
4000a0ac: 10 80 00 04 b 4000a0bc <_Heap_Walk+0x3d8>
4000a0b0: 96 12 e1 60 or %o3, 0x160, %o3 ! 40016960 <__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)(
4000a0b4: 03 10 00 5a sethi %hi(0x40016800), %g1
4000a0b8: 96 10 61 50 or %g1, 0x150, %o3 ! 40016950 <__log2table+0x120>
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
4000a0bc: 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)(
4000a0c0: 80 a3 00 0f cmp %o4, %o7
4000a0c4: 02 80 00 06 be 4000a0dc <_Heap_Walk+0x3f8>
4000a0c8: 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)" : "")
4000a0cc: 12 80 00 06 bne 4000a0e4 <_Heap_Walk+0x400>
4000a0d0: 9e 14 61 18 or %l1, 0x118, %o7
4000a0d4: 10 80 00 04 b 4000a0e4 <_Heap_Walk+0x400>
4000a0d8: 9e 15 e1 80 or %l7, 0x180, %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)(
4000a0dc: 03 10 00 5a sethi %hi(0x40016800), %g1
4000a0e0: 9e 10 61 70 or %g1, 0x170, %o7 ! 40016970 <__log2table+0x140>
4000a0e4: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
4000a0e8: d8 23 a0 60 st %o4, [ %sp + 0x60 ]
4000a0ec: de 23 a0 64 st %o7, [ %sp + 0x64 ]
4000a0f0: 90 10 00 16 mov %l6, %o0
4000a0f4: 92 10 20 00 clr %o1
4000a0f8: 94 10 00 15 mov %l5, %o2
4000a0fc: 96 10 00 19 mov %i1, %o3
4000a100: 9f c7 40 00 call %i5
4000a104: 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 ) {
4000a108: da 04 c0 00 ld [ %l3 ], %o5
4000a10c: 80 a5 00 0d cmp %l4, %o5
4000a110: 02 80 00 0c be 4000a140 <_Heap_Walk+0x45c>
4000a114: 80 a4 a0 00 cmp %l2, 0
(*printer)(
4000a118: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
4000a11c: 90 10 00 16 mov %l6, %o0
4000a120: 92 10 20 01 mov 1, %o1
4000a124: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000a128: 96 10 00 19 mov %i1, %o3
4000a12c: 94 12 a0 e0 or %o2, 0xe0, %o2
4000a130: 9f c7 40 00 call %i5
4000a134: 98 10 00 14 mov %l4, %o4
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
4000a138: 10 bf ff ce b 4000a070 <_Heap_Walk+0x38c>
4000a13c: b0 10 20 00 clr %i0
);
return false;
}
if ( !prev_used ) {
4000a140: 32 80 00 0a bne,a 4000a168 <_Heap_Walk+0x484>
4000a144: c6 06 20 08 ld [ %i0 + 8 ], %g3
(*printer)(
4000a148: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000a14c: 90 10 00 16 mov %l6, %o0
4000a150: 92 10 20 01 mov 1, %o1
4000a154: 10 80 00 26 b 4000a1ec <_Heap_Walk+0x508>
4000a158: 94 12 a1 20 or %o2, 0x120, %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 ) {
4000a15c: 22 80 00 19 be,a 4000a1c0 <_Heap_Walk+0x4dc>
4000a160: b2 10 00 13 mov %l3, %i1
return true;
}
free_block = free_block->next;
4000a164: 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 ) {
4000a168: 80 a0 c0 18 cmp %g3, %i0
4000a16c: 12 bf ff fc bne 4000a15c <_Heap_Walk+0x478>
4000a170: 80 a0 c0 19 cmp %g3, %i1
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
4000a174: 10 80 00 1b b 4000a1e0 <_Heap_Walk+0x4fc>
4000a178: 15 10 00 5b sethi %hi(0x40016c00), %o2
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
4000a17c: 80 a4 a0 00 cmp %l2, 0
4000a180: 02 80 00 09 be 4000a1a4 <_Heap_Walk+0x4c0>
4000a184: 92 10 20 00 clr %o1
(*printer)(
4000a188: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000a18c: 96 10 00 19 mov %i1, %o3
4000a190: 94 12 a1 50 or %o2, 0x150, %o2
4000a194: 9f c7 40 00 call %i5
4000a198: 98 10 00 14 mov %l4, %o4
4000a19c: 10 80 00 09 b 4000a1c0 <_Heap_Walk+0x4dc>
4000a1a0: b2 10 00 13 mov %l3, %i1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4000a1a4: da 06 40 00 ld [ %i1 ], %o5
4000a1a8: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000a1ac: 96 10 00 19 mov %i1, %o3
4000a1b0: 94 12 a1 68 or %o2, 0x168, %o2
4000a1b4: 9f c7 40 00 call %i5
4000a1b8: 98 10 00 14 mov %l4, %o4
4000a1bc: b2 10 00 13 mov %l3, %i1
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
4000a1c0: 80 a4 c0 1a cmp %l3, %i2
4000a1c4: 32 bf ff 68 bne,a 40009f64 <_Heap_Walk+0x280>
4000a1c8: e4 06 60 04 ld [ %i1 + 4 ], %l2
4000a1cc: 10 80 00 02 b 4000a1d4 <_Heap_Walk+0x4f0>
4000a1d0: b0 10 20 01 mov 1, %i0
4000a1d4: b0 0e 20 ff and %i0, 0xff, %i0
4000a1d8: 81 c7 e0 08 ret
4000a1dc: 81 e8 00 00 restore
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
4000a1e0: 90 10 00 16 mov %l6, %o0
4000a1e4: 92 10 20 01 mov 1, %o1
4000a1e8: 94 12 a1 90 or %o2, 0x190, %o2
4000a1ec: 96 10 00 19 mov %i1, %o3
4000a1f0: 9f c7 40 00 call %i5
4000a1f4: b0 10 20 00 clr %i0
4000a1f8: b0 0e 20 ff and %i0, 0xff, %i0
4000a1fc: 81 c7 e0 08 ret
4000a200: 81 e8 00 00 restore
40009420 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
40009420: 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 );
40009424: 13 10 00 2c sethi %hi(0x4000b000), %o1
40009428: 90 07 bf f4 add %fp, -12, %o0
4000942c: 92 12 63 a8 or %o1, 0x3a8, %o1
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
40009430: f0 27 bf f4 st %i0, [ %fp + -12 ]
40009434: f2 2f bf f8 stb %i1, [ %fp + -8 ]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
40009438: 40 00 07 e7 call 4000b3d4 <_User_extensions_Iterate>
4000943c: 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;
40009440: 05 10 00 7e sethi %hi(0x4001f800), %g2 <== NOT EXECUTED
40009444: 82 10 a1 7c or %g2, 0x17c, %g1 ! 4001f97c <_Internal_errors_What_happened><== NOT EXECUTED
40009448: f0 20 a1 7c st %i0, [ %g2 + 0x17c ] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
4000944c: f2 28 60 04 stb %i1, [ %g1 + 4 ] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
40009450: 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;
40009454: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
40009458: 03 10 00 7e sethi %hi(0x4001f800), %g1 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
4000945c: 7f ff e3 fb call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
40009460: c4 20 61 88 st %g2, [ %g1 + 0x188 ] ! 4001f988 <_System_state_Current><== NOT EXECUTED
40009464: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
40009468: 30 80 00 00 b,a 40009468 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
400094d4 <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
400094d4: 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 )
400094d8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400094dc: 80 a0 60 00 cmp %g1, 0
400094e0: 12 80 00 04 bne 400094f0 <_Objects_Allocate+0x1c> <== ALWAYS TAKEN
400094e4: ba 10 00 18 mov %i0, %i5
return NULL;
400094e8: 81 c7 e0 08 ret
400094ec: 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 );
400094f0: b8 06 20 20 add %i0, 0x20, %i4
400094f4: 7f ff fd 85 call 40008b08 <_Chain_Get>
400094f8: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
400094fc: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
40009500: 80 a0 60 00 cmp %g1, 0
40009504: 02 80 00 1d be 40009578 <_Objects_Allocate+0xa4>
40009508: 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 ) {
4000950c: 80 a2 20 00 cmp %o0, 0
40009510: 32 80 00 0a bne,a 40009538 <_Objects_Allocate+0x64>
40009514: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Objects_Extend_information( information );
40009518: 40 00 00 21 call 4000959c <_Objects_Extend_information>
4000951c: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
40009520: 7f ff fd 7a call 40008b08 <_Chain_Get>
40009524: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
40009528: b0 92 20 00 orcc %o0, 0, %i0
4000952c: 02 bf ff ef be 400094e8 <_Objects_Allocate+0x14>
40009530: 01 00 00 00 nop
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40009534: c4 07 60 08 ld [ %i5 + 8 ], %g2
40009538: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
4000953c: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40009540: 03 00 00 3f sethi %hi(0xfc00), %g1
40009544: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40009548: 90 0a 00 01 and %o0, %g1, %o0
4000954c: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
40009550: 40 00 3d d4 call 40018ca0 <.udiv>
40009554: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
40009558: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
4000955c: 91 2a 20 02 sll %o0, 2, %o0
40009560: c4 00 40 08 ld [ %g1 + %o0 ], %g2
40009564: 84 00 bf ff add %g2, -1, %g2
40009568: c4 20 40 08 st %g2, [ %g1 + %o0 ]
information->inactive--;
4000956c: c2 17 60 2c lduh [ %i5 + 0x2c ], %g1
40009570: 82 00 7f ff add %g1, -1, %g1
40009574: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
40009578: 81 c7 e0 08 ret
4000957c: 81 e8 00 00 restore
40009904 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
40009904: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
40009908: 80 a6 60 00 cmp %i1, 0
4000990c: 12 80 00 04 bne 4000991c <_Objects_Get_information+0x18>
40009910: 01 00 00 00 nop
return NULL;
40009914: 81 c7 e0 08 ret
40009918: 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 );
4000991c: 40 00 11 64 call 4000deac <_Objects_API_maximum_class>
40009920: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
40009924: 80 a2 20 00 cmp %o0, 0
40009928: 02 bf ff fb be 40009914 <_Objects_Get_information+0x10>
4000992c: 80 a6 40 08 cmp %i1, %o0
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
40009930: 18 bf ff f9 bgu 40009914 <_Objects_Get_information+0x10>
40009934: 03 10 00 7c sethi %hi(0x4001f000), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
40009938: b1 2e 20 02 sll %i0, 2, %i0
4000993c: 82 10 63 e4 or %g1, 0x3e4, %g1
40009940: c2 00 40 18 ld [ %g1 + %i0 ], %g1
40009944: 80 a0 60 00 cmp %g1, 0
40009948: 02 bf ff f3 be 40009914 <_Objects_Get_information+0x10> <== NEVER TAKEN
4000994c: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
40009950: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
40009954: 80 a6 20 00 cmp %i0, 0
40009958: 02 bf ff ef be 40009914 <_Objects_Get_information+0x10> <== NEVER TAKEN
4000995c: 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 )
40009960: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
40009964: 80 a0 60 00 cmp %g1, 0
40009968: 02 bf ff eb be 40009914 <_Objects_Get_information+0x10>
4000996c: 01 00 00 00 nop
return NULL;
#endif
return info;
}
40009970: 81 c7 e0 08 ret
40009974: 81 e8 00 00 restore
4001bcfc <_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;
4001bcfc: c2 02 20 08 ld [ %o0 + 8 ], %g1
4001bd00: 92 22 40 01 sub %o1, %g1, %o1
if ( information->maximum >= index ) {
4001bd04: 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;
4001bd08: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
4001bd0c: 80 a0 40 09 cmp %g1, %o1
4001bd10: 0a 80 00 09 bcs 4001bd34 <_Objects_Get_no_protection+0x38>
4001bd14: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
4001bd18: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4001bd1c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
4001bd20: 80 a2 20 00 cmp %o0, 0
4001bd24: 02 80 00 05 be 4001bd38 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
4001bd28: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
4001bd2c: 81 c3 e0 08 retl
4001bd30: 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;
4001bd34: 82 10 20 01 mov 1, %g1
return NULL;
4001bd38: 90 10 20 00 clr %o0
}
4001bd3c: 81 c3 e0 08 retl
4001bd40: c2 22 80 00 st %g1, [ %o2 ]
4000da28 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
4000da28: 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;
4000da2c: 80 a6 20 00 cmp %i0, 0
4000da30: 12 80 00 06 bne 4000da48 <_Objects_Id_to_name+0x20>
4000da34: 83 36 20 18 srl %i0, 0x18, %g1
4000da38: 03 10 00 bf sethi %hi(0x4002fc00), %g1
4000da3c: c2 00 62 b0 ld [ %g1 + 0x2b0 ], %g1 ! 4002feb0 <_Per_CPU_Information+0x10>
4000da40: f0 00 60 08 ld [ %g1 + 8 ], %i0
4000da44: 83 36 20 18 srl %i0, 0x18, %g1
4000da48: 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 )
4000da4c: 84 00 7f ff add %g1, -1, %g2
4000da50: 80 a0 a0 02 cmp %g2, 2
4000da54: 08 80 00 18 bleu 4000dab4 <_Objects_Id_to_name+0x8c>
4000da58: 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;
4000da5c: 81 c7 e0 08 ret
4000da60: 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 ];
4000da64: 85 28 a0 02 sll %g2, 2, %g2
4000da68: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
4000da6c: 80 a2 20 00 cmp %o0, 0
4000da70: 02 bf ff fb be 4000da5c <_Objects_Id_to_name+0x34> <== NEVER TAKEN
4000da74: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
4000da78: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
4000da7c: 80 a0 60 00 cmp %g1, 0
4000da80: 12 bf ff f7 bne 4000da5c <_Objects_Id_to_name+0x34> <== NEVER TAKEN
4000da84: 92 10 00 18 mov %i0, %o1
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
4000da88: 7f ff ff cb call 4000d9b4 <_Objects_Get>
4000da8c: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
4000da90: 80 a2 20 00 cmp %o0, 0
4000da94: 02 bf ff f2 be 4000da5c <_Objects_Id_to_name+0x34>
4000da98: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
4000da9c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
4000daa0: 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();
4000daa4: 40 00 03 99 call 4000e908 <_Thread_Enable_dispatch>
4000daa8: c2 26 40 00 st %g1, [ %i1 ]
4000daac: 81 c7 e0 08 ret
4000dab0: 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 ] )
4000dab4: 05 10 00 be sethi %hi(0x4002f800), %g2
4000dab8: 84 10 a0 b4 or %g2, 0xb4, %g2 ! 4002f8b4 <_Objects_Information_table>
4000dabc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000dac0: 80 a0 60 00 cmp %g1, 0
4000dac4: 12 bf ff e8 bne 4000da64 <_Objects_Id_to_name+0x3c>
4000dac8: 85 36 20 1b srl %i0, 0x1b, %g2
4000dacc: 30 bf ff e4 b,a 4000da5c <_Objects_Id_to_name+0x34>
4000f338 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4000f338: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4000f33c: 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 ];
4000f340: 39 00 00 3f sethi %hi(0xfc00), %i4
4000f344: b5 30 60 18 srl %g1, 0x18, %i2
4000f348: b8 17 23 ff or %i4, 0x3ff, %i4
4000f34c: b4 0e a0 07 and %i2, 7, %i2
4000f350: b8 08 40 1c and %g1, %i4, %i4
4000f354: b4 06 a0 04 add %i2, 4, %i2
4000f358: 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;
4000f35c: 37 10 00 7e sethi %hi(0x4001f800), %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 ];
4000f360: 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;
4000f364: 82 16 e0 5c or %i3, 0x5c, %g1
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4000f368: ba 10 20 01 mov 1, %i5
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
4000f36c: 84 10 20 01 mov 1, %g2
for ( index = 1 ; index <= max ; ++index ) {
4000f370: 10 80 00 18 b 4000f3d0 <_POSIX_Keys_Run_destructors+0x98>
4000f374: f2 10 60 10 lduh [ %g1 + 0x10 ], %i1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
4000f378: 86 16 e0 5c or %i3, 0x5c, %g3
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
4000f37c: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4000f380: 83 28 60 02 sll %g1, 2, %g1
4000f384: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
4000f388: 80 a0 60 00 cmp %g1, 0
4000f38c: 22 80 00 11 be,a 4000f3d0 <_POSIX_Keys_Run_destructors+0x98>
4000f390: ba 07 60 01 inc %i5
4000f394: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000f398: 80 a0 e0 00 cmp %g3, 0
4000f39c: 02 80 00 0c be 4000f3cc <_POSIX_Keys_Run_destructors+0x94>
4000f3a0: 86 00 40 1a add %g1, %i2, %g3
void *value = key->Values [ thread_api ][ thread_index ];
4000f3a4: c6 00 e0 04 ld [ %g3 + 4 ], %g3
4000f3a8: d0 00 c0 1c ld [ %g3 + %i4 ], %o0
if ( value != NULL ) {
4000f3ac: 80 a2 20 00 cmp %o0, 0
4000f3b0: 22 80 00 08 be,a 4000f3d0 <_POSIX_Keys_Run_destructors+0x98><== ALWAYS TAKEN
4000f3b4: ba 07 60 01 inc %i5
key->Values [ thread_api ][ thread_index ] = NULL;
4000f3b8: c0 20 c0 1c clr [ %g3 + %i4 ] <== NOT EXECUTED
(*key->destructor)( value );
4000f3bc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
4000f3c0: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000f3c4: 01 00 00 00 nop <== NOT EXECUTED
done = false;
4000f3c8: 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 ) {
4000f3cc: ba 07 60 01 inc %i5
4000f3d0: 83 2f 60 10 sll %i5, 0x10, %g1
4000f3d4: 83 30 60 10 srl %g1, 0x10, %g1
4000f3d8: 80 a0 40 19 cmp %g1, %i1
4000f3dc: 08 bf ff e7 bleu 4000f378 <_POSIX_Keys_Run_destructors+0x40>
4000f3e0: 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 ) {
4000f3e4: 02 bf ff e1 be 4000f368 <_POSIX_Keys_Run_destructors+0x30><== NEVER TAKEN
4000f3e8: 82 16 e0 5c or %i3, 0x5c, %g1
done = false;
}
}
}
}
}
4000f3ec: 81 c7 e0 08 ret
4000f3f0: 81 e8 00 00 restore
4000ce74 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
4000ce74: 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(
4000ce78: 11 10 00 a5 sethi %hi(0x40029400), %o0
4000ce7c: 92 10 00 18 mov %i0, %o1
4000ce80: 90 12 20 30 or %o0, 0x30, %o0
4000ce84: 40 00 0c c3 call 40010190 <_Objects_Get>
4000ce88: 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 ) {
4000ce8c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000ce90: 80 a0 60 00 cmp %g1, 0
4000ce94: 12 80 00 40 bne 4000cf94 <_POSIX_Message_queue_Receive_support+0x120>
4000ce98: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
4000ce9c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000cea0: 84 08 60 03 and %g1, 3, %g2
4000cea4: 80 a0 a0 01 cmp %g2, 1
4000cea8: 32 80 00 05 bne,a 4000cebc <_POSIX_Message_queue_Receive_support+0x48>
4000ceac: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
_Thread_Enable_dispatch();
4000ceb0: 40 00 10 5f call 4001102c <_Thread_Enable_dispatch>
4000ceb4: 01 00 00 00 nop
4000ceb8: 30 80 00 37 b,a 4000cf94 <_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 ) {
4000cebc: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
4000cec0: 80 a6 80 02 cmp %i2, %g2
4000cec4: 1a 80 00 08 bcc 4000cee4 <_POSIX_Message_queue_Receive_support+0x70>
4000cec8: 84 10 3f ff mov -1, %g2
_Thread_Enable_dispatch();
4000cecc: 40 00 10 58 call 4001102c <_Thread_Enable_dispatch>
4000ced0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4000ced4: 40 00 26 b4 call 400169a4 <__errno>
4000ced8: 01 00 00 00 nop
4000cedc: 10 80 00 31 b 4000cfa0 <_POSIX_Message_queue_Receive_support+0x12c>
4000cee0: 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;
4000cee4: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4000cee8: 80 a7 20 00 cmp %i4, 0
4000ceec: 02 80 00 05 be 4000cf00 <_POSIX_Message_queue_Receive_support+0x8c>
4000cef0: 98 10 20 00 clr %o4
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
4000cef4: 99 30 60 0e srl %g1, 0xe, %o4
4000cef8: 98 1b 20 01 xor %o4, 1, %o4
4000cefc: 98 0b 20 01 and %o4, 1, %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
4000cf00: 90 02 20 1c add %o0, 0x1c, %o0
4000cf04: 92 10 00 18 mov %i0, %o1
4000cf08: 94 10 00 19 mov %i1, %o2
4000cf0c: 96 07 bf fc add %fp, -4, %o3
4000cf10: 98 0b 20 01 and %o4, 1, %o4
4000cf14: 40 00 08 6c call 4000f0c4 <_CORE_message_queue_Seize>
4000cf18: 9a 10 00 1d mov %i5, %o5
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
4000cf1c: 40 00 10 44 call 4001102c <_Thread_Enable_dispatch>
4000cf20: 01 00 00 00 nop
if (msg_prio) {
4000cf24: 80 a6 e0 00 cmp %i3, 0
4000cf28: 02 80 00 08 be 4000cf48 <_POSIX_Message_queue_Receive_support+0xd4><== NEVER TAKEN
4000cf2c: 03 10 00 a5 sethi %hi(0x40029400), %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
4000cf30: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 ! 400294c0 <_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);
4000cf34: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000cf38: 83 38 a0 1f sra %g2, 0x1f, %g1
4000cf3c: 84 18 40 02 xor %g1, %g2, %g2
4000cf40: 82 20 80 01 sub %g2, %g1, %g1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
4000cf44: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
4000cf48: 3b 10 00 a5 sethi %hi(0x40029400), %i5
4000cf4c: ba 17 60 b0 or %i5, 0xb0, %i5 ! 400294b0 <_Per_CPU_Information>
4000cf50: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000cf54: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
4000cf58: 80 a0 60 00 cmp %g1, 0
4000cf5c: 12 80 00 05 bne 4000cf70 <_POSIX_Message_queue_Receive_support+0xfc>
4000cf60: 01 00 00 00 nop
return length_out;
4000cf64: f0 07 bf fc ld [ %fp + -4 ], %i0
4000cf68: 81 c7 e0 08 ret
4000cf6c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(
4000cf70: 40 00 26 8d call 400169a4 <__errno>
4000cf74: b0 10 3f ff mov -1, %i0
4000cf78: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000cf7c: b8 10 00 08 mov %o0, %i4
4000cf80: 40 00 00 96 call 4000d1d8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4000cf84: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
4000cf88: d0 27 00 00 st %o0, [ %i4 ]
4000cf8c: 81 c7 e0 08 ret
4000cf90: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
4000cf94: 40 00 26 84 call 400169a4 <__errno>
4000cf98: 01 00 00 00 nop
4000cf9c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4000cfa0: c2 22 00 00 st %g1, [ %o0 ]
4000cfa4: b0 10 3f ff mov -1, %i0
}
4000cfa8: 81 c7 e0 08 ret
4000cfac: 81 e8 00 00 restore
4000f3d8 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
4000f3d8: 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)
4000f3dc: 80 a6 a0 00 cmp %i2, 0
4000f3e0: 22 80 00 06 be,a 4000f3f8 <_POSIX_Semaphore_Create_support+0x20>
4000f3e4: 03 10 00 8f sethi %hi(0x40023c00), %g1
rtems_set_errno_and_return_minus_one( ENOSYS );
4000f3e8: 40 00 09 88 call 40011a08 <__errno>
4000f3ec: 01 00 00 00 nop
4000f3f0: 10 80 00 10 b 4000f430 <_POSIX_Semaphore_Create_support+0x58>
4000f3f4: 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;
4000f3f8: c4 00 62 80 ld [ %g1 + 0x280 ], %g2
++level;
4000f3fc: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4000f400: c4 20 62 80 st %g2, [ %g1 + 0x280 ]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
4000f404: 21 10 00 90 sethi %hi(0x40024000), %l0
4000f408: 7f ff ef 4a call 4000b130 <_Objects_Allocate>
4000f40c: 90 14 21 44 or %l0, 0x144, %o0 ! 40024144 <_POSIX_Semaphore_Information>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
4000f410: ba 92 20 00 orcc %o0, 0, %i5
4000f414: 12 80 00 0a bne 4000f43c <_POSIX_Semaphore_Create_support+0x64>
4000f418: 80 a6 20 00 cmp %i0, 0
_Thread_Enable_dispatch();
4000f41c: 7f ff f4 45 call 4000c530 <_Thread_Enable_dispatch>
4000f420: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSPC );
4000f424: 40 00 09 79 call 40011a08 <__errno>
4000f428: 01 00 00 00 nop
4000f42c: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
4000f430: c2 22 00 00 st %g1, [ %o0 ]
4000f434: 81 c7 e0 08 ret
4000f438: 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 ) {
4000f43c: 02 80 00 10 be 4000f47c <_POSIX_Semaphore_Create_support+0xa4>
4000f440: 90 10 00 18 mov %i0, %o0
name = _Workspace_String_duplicate( name_arg, name_len );
4000f444: 40 00 03 ca call 4001036c <_Workspace_String_duplicate>
4000f448: 92 10 00 19 mov %i1, %o1
if ( !name ) {
4000f44c: b4 92 20 00 orcc %o0, 0, %i2
4000f450: 12 80 00 0d bne 4000f484 <_POSIX_Semaphore_Create_support+0xac><== ALWAYS TAKEN
4000f454: 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 );
4000f458: 90 14 21 44 or %l0, 0x144, %o0 <== NOT EXECUTED
4000f45c: 7f ff f0 14 call 4000b4ac <_Objects_Free> <== NOT EXECUTED
4000f460: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
4000f464: 7f ff f4 33 call 4000c530 <_Thread_Enable_dispatch> <== NOT EXECUTED
4000f468: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000f46c: 40 00 09 67 call 40011a08 <__errno> <== NOT EXECUTED
4000f470: 01 00 00 00 nop <== NOT EXECUTED
4000f474: 10 bf ff ef b 4000f430 <_POSIX_Semaphore_Create_support+0x58><== NOT EXECUTED
4000f478: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
}
} else {
name = NULL;
4000f47c: b4 10 20 00 clr %i2
}
the_semaphore->process_shared = pshared;
if ( name ) {
4000f480: 80 a6 a0 00 cmp %i2, 0
4000f484: 02 80 00 08 be 4000f4a4 <_POSIX_Semaphore_Create_support+0xcc>
4000f488: c0 27 60 10 clr [ %i5 + 0x10 ]
the_semaphore->named = true;
4000f48c: 82 10 20 01 mov 1, %g1
4000f490: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
4000f494: 82 10 20 01 mov 1, %g1
4000f498: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
4000f49c: 10 80 00 05 b 4000f4b0 <_POSIX_Semaphore_Create_support+0xd8>
4000f4a0: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
} else {
the_semaphore->named = false;
4000f4a4: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
4000f4a8: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
4000f4ac: 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;
4000f4b0: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000f4b4: 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;
4000f4b8: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000f4bc: 92 07 60 5c add %i5, 0x5c, %o1
4000f4c0: 94 10 00 1b mov %i3, %o2
4000f4c4: 7f ff ed 90 call 4000ab04 <_CORE_semaphore_Initialize>
4000f4c8: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
4000f4cc: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000f4d0: 05 10 00 90 sethi %hi(0x40024000), %g2
4000f4d4: c4 00 a1 60 ld [ %g2 + 0x160 ], %g2 ! 40024160 <_POSIX_Semaphore_Information+0x1c>
4000f4d8: 83 28 60 02 sll %g1, 2, %g1
4000f4dc: 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;
4000f4e0: f4 27 60 0c st %i2, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
4000f4e4: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
4000f4e8: 7f ff f4 12 call 4000c530 <_Thread_Enable_dispatch>
4000f4ec: b0 10 20 00 clr %i0
return 0;
}
4000f4f0: 81 c7 e0 08 ret
4000f4f4: 81 e8 00 00 restore
4000cae0 <_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 ];
4000cae0: c2 02 21 50 ld [ %o0 + 0x150 ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4000cae4: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
4000cae8: 80 a0 a0 00 cmp %g2, 0
4000caec: 12 80 00 12 bne 4000cb34 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54><== NEVER TAKEN
4000caf0: 01 00 00 00 nop
4000caf4: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
4000caf8: 80 a0 a0 01 cmp %g2, 1
4000cafc: 12 80 00 0e bne 4000cb34 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
4000cb00: 01 00 00 00 nop
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4000cb04: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
4000cb08: 80 a0 60 00 cmp %g1, 0
4000cb0c: 02 80 00 0a be 4000cb34 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
4000cb10: 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;
4000cb14: 03 10 00 60 sethi %hi(0x40018000), %g1
4000cb18: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 40018250 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4000cb1c: 92 10 3f ff mov -1, %o1
--level;
4000cb20: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000cb24: c4 20 62 50 st %g2, [ %g1 + 0x250 ]
4000cb28: 82 13 c0 00 mov %o7, %g1
4000cb2c: 40 00 01 b5 call 4000d200 <_POSIX_Thread_Exit>
4000cb30: 9e 10 40 00 mov %g1, %o7
} else
_Thread_Enable_dispatch();
4000cb34: 82 13 c0 00 mov %o7, %g1
4000cb38: 7f ff f6 b3 call 4000a604 <_Thread_Enable_dispatch>
4000cb3c: 9e 10 40 00 mov %g1, %o7
4000de90 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4000de90: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4000de94: 7f ff ff f4 call 4000de64 <_POSIX_Priority_Is_valid>
4000de98: d0 06 40 00 ld [ %i1 ], %o0
4000de9c: 80 8a 20 ff btst 0xff, %o0
4000dea0: 32 80 00 04 bne,a 4000deb0 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
4000dea4: c0 26 80 00 clr [ %i2 ]
return EINVAL;
4000dea8: 81 c7 e0 08 ret
4000deac: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
4000deb0: 80 a6 20 00 cmp %i0, 0
4000deb4: 12 80 00 06 bne 4000decc <_POSIX_Thread_Translate_sched_param+0x3c>
4000deb8: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000debc: 82 10 20 01 mov 1, %g1
4000dec0: c2 26 80 00 st %g1, [ %i2 ]
return 0;
4000dec4: 81 c7 e0 08 ret
4000dec8: 81 e8 00 00 restore
}
if ( policy == SCHED_FIFO ) {
4000decc: 80 a6 20 01 cmp %i0, 1
4000ded0: 02 80 00 29 be 4000df74 <_POSIX_Thread_Translate_sched_param+0xe4>
4000ded4: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4000ded8: 12 80 00 04 bne 4000dee8 <_POSIX_Thread_Translate_sched_param+0x58>
4000dedc: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4000dee0: 10 80 00 25 b 4000df74 <_POSIX_Thread_Translate_sched_param+0xe4>
4000dee4: f0 26 80 00 st %i0, [ %i2 ]
return 0;
}
if ( policy == SCHED_SPORADIC ) {
4000dee8: 12 bf ff f0 bne 4000dea8 <_POSIX_Thread_Translate_sched_param+0x18>
4000deec: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4000def0: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000def4: 80 a0 60 00 cmp %g1, 0
4000def8: 32 80 00 07 bne,a 4000df14 <_POSIX_Thread_Translate_sched_param+0x84>
4000defc: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000df00: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000df04: 80 a0 60 00 cmp %g1, 0
4000df08: 02 bf ff e8 be 4000dea8 <_POSIX_Thread_Translate_sched_param+0x18>
4000df0c: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4000df10: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000df14: 80 a0 60 00 cmp %g1, 0
4000df18: 12 80 00 06 bne 4000df30 <_POSIX_Thread_Translate_sched_param+0xa0>
4000df1c: 01 00 00 00 nop
4000df20: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000df24: 80 a0 60 00 cmp %g1, 0
4000df28: 02 bf ff e0 be 4000dea8 <_POSIX_Thread_Translate_sched_param+0x18>
4000df2c: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4000df30: 7f ff f7 b4 call 4000be00 <_Timespec_To_ticks>
4000df34: 90 06 60 08 add %i1, 8, %o0
4000df38: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4000df3c: 7f ff f7 b1 call 4000be00 <_Timespec_To_ticks>
4000df40: 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 ) <
4000df44: 80 a7 40 08 cmp %i5, %o0
4000df48: 0a bf ff d8 bcs 4000dea8 <_POSIX_Thread_Translate_sched_param+0x18>
4000df4c: 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 ) )
4000df50: 7f ff ff c5 call 4000de64 <_POSIX_Priority_Is_valid>
4000df54: d0 06 60 04 ld [ %i1 + 4 ], %o0
4000df58: 80 8a 20 ff btst 0xff, %o0
4000df5c: 02 bf ff d3 be 4000dea8 <_POSIX_Thread_Translate_sched_param+0x18>
4000df60: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4000df64: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4000df68: 03 10 00 20 sethi %hi(0x40008000), %g1
4000df6c: 82 10 62 18 or %g1, 0x218, %g1 ! 40008218 <_POSIX_Threads_Sporadic_budget_callout>
4000df70: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
return EINVAL;
}
4000df74: 81 c7 e0 08 ret
4000df78: 91 e8 20 00 restore %g0, 0, %o0
4000d228 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
4000d228: 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 ];
4000d22c: f0 06 61 50 ld [ %i1 + 0x150 ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
4000d230: 40 00 08 28 call 4000f2d0 <_POSIX_Threads_cancel_run>
4000d234: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
4000d238: 90 10 00 19 mov %i1, %o0
4000d23c: 40 00 08 3f call 4000f338 <_POSIX_Keys_Run_destructors>
4000d240: 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 )) )
4000d244: 10 80 00 03 b 4000d250 <_POSIX_Threads_Delete_extension+0x28>
4000d248: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
4000d24c: 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 )) )
4000d250: 7f ff f6 6a call 4000abf8 <_Thread_queue_Dequeue>
4000d254: 90 10 00 1d mov %i5, %o0
4000d258: 80 a2 20 00 cmp %o0, 0
4000d25c: 32 bf ff fc bne,a 4000d24c <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
4000d260: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
4000d264: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4000d268: 80 a0 60 04 cmp %g1, 4
4000d26c: 32 80 00 05 bne,a 4000d280 <_POSIX_Threads_Delete_extension+0x58>
4000d270: c0 26 61 50 clr [ %i1 + 0x150 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
4000d274: 7f ff f8 f0 call 4000b634 <_Watchdog_Remove>
4000d278: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4000d27c: c0 26 61 50 clr [ %i1 + 0x150 ]
_Workspace_Free( api );
4000d280: 7f ff f9 8e call 4000b8b8 <_Workspace_Free>
4000d284: 81 e8 00 00 restore
40007f74 <_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)
{
40007f74: 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;
40007f78: 03 10 00 7c sethi %hi(0x4001f000), %g1
40007f7c: 82 10 61 34 or %g1, 0x134, %g1 ! 4001f134 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
40007f80: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
40007f84: 80 a6 e0 00 cmp %i3, 0
40007f88: 02 80 00 1d be 40007ffc <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
40007f8c: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
40007f90: 80 a7 60 00 cmp %i5, 0
40007f94: 02 80 00 1a be 40007ffc <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
40007f98: 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 );
40007f9c: 40 00 17 f8 call 4000df7c <pthread_attr_init>
40007fa0: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
40007fa4: 92 10 20 02 mov 2, %o1
40007fa8: 40 00 18 01 call 4000dfac <pthread_attr_setinheritsched>
40007fac: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
40007fb0: d2 07 60 04 ld [ %i5 + 4 ], %o1
40007fb4: 40 00 18 0d call 4000dfe8 <pthread_attr_setstacksize>
40007fb8: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
40007fbc: d4 07 40 00 ld [ %i5 ], %o2
40007fc0: 90 07 bf bc add %fp, -68, %o0
40007fc4: 92 07 bf c0 add %fp, -64, %o1
40007fc8: 96 10 20 00 clr %o3
40007fcc: 7f ff ff 18 call 40007c2c <pthread_create>
40007fd0: ba 07 60 08 add %i5, 8, %i5
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
40007fd4: 80 a2 20 00 cmp %o0, 0
40007fd8: 02 80 00 05 be 40007fec <_POSIX_Threads_Initialize_user_threads_body+0x78>
40007fdc: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
40007fe0: 90 10 20 02 mov 2, %o0
40007fe4: 40 00 07 f8 call 40009fc4 <_Internal_error_Occurred>
40007fe8: 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++ ) {
40007fec: b8 07 20 01 inc %i4
40007ff0: 80 a7 00 1b cmp %i4, %i3
40007ff4: 12 bf ff ea bne 40007f9c <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
40007ff8: 01 00 00 00 nop
40007ffc: 81 c7 e0 08 ret
40008000: 81 e8 00 00 restore
4000d37c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4000d37c: 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 ];
4000d380: 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 );
4000d384: 40 00 03 82 call 4000e18c <_Timespec_To_ticks>
4000d388: 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);
4000d38c: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000d390: d2 08 62 ac ldub [ %g1 + 0x2ac ], %o1 ! 4001e6ac <rtems_maximum_priority>
4000d394: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->cpu_time_budget = ticks;
4000d398: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
4000d39c: 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 ) {
4000d3a0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4000d3a4: 80 a0 60 00 cmp %g1, 0
4000d3a8: 12 80 00 09 bne 4000d3cc <_POSIX_Threads_Sporadic_budget_TSR+0x50><== NEVER TAKEN
4000d3ac: 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 ) {
4000d3b0: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000d3b4: 80 a0 40 09 cmp %g1, %o1
4000d3b8: 08 80 00 06 bleu 4000d3d0 <_POSIX_Threads_Sporadic_budget_TSR+0x54>
4000d3bc: 90 07 60 90 add %i5, 0x90, %o0
_Thread_Change_priority( the_thread, new_priority, true );
4000d3c0: 90 10 00 19 mov %i1, %o0
4000d3c4: 7f ff f4 1b call 4000a430 <_Thread_Change_priority>
4000d3c8: 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 );
4000d3cc: 90 07 60 90 add %i5, 0x90, %o0
4000d3d0: 40 00 03 6f call 4000e18c <_Timespec_To_ticks>
4000d3d4: 31 10 00 7d sethi %hi(0x4001f400), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000d3d8: b0 16 21 18 or %i0, 0x118, %i0 ! 4001f518 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000d3dc: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000d3e0: 7f ff f8 3d call 4000b4d4 <_Watchdog_Insert>
4000d3e4: 93 ef 60 a8 restore %i5, 0xa8, %o1
4000d3e8 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000d3e8: 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 */
4000d3ec: 86 10 3f ff mov -1, %g3
4000d3f0: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2
4000d3f4: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
4000d3f8: 07 10 00 79 sethi %hi(0x4001e400), %g3
4000d3fc: d2 08 e2 ac ldub [ %g3 + 0x2ac ], %o1 ! 4001e6ac <rtems_maximum_priority>
4000d400: 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 ) {
4000d404: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
4000d408: 80 a0 a0 00 cmp %g2, 0
4000d40c: 12 80 00 09 bne 4000d430 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
4000d410: 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 ) {
4000d414: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000d418: 80 a0 40 09 cmp %g1, %o1
4000d41c: 1a 80 00 05 bcc 4000d430 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
4000d420: 94 10 20 01 mov 1, %o2
_Thread_Change_priority( the_thread, new_priority, true );
4000d424: 82 13 c0 00 mov %o7, %g1
4000d428: 7f ff f4 02 call 4000a430 <_Thread_Change_priority>
4000d42c: 9e 10 40 00 mov %g1, %o7
4000d430: 81 c3 e0 08 retl <== NOT EXECUTED
40007d2c <_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)
{
40007d2c: 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;
40007d30: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
40007d34: 82 00 60 01 inc %g1
40007d38: c2 26 60 68 st %g1, [ %i1 + 0x68 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
40007d3c: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
40007d40: 80 a0 60 00 cmp %g1, 0
40007d44: 32 80 00 07 bne,a 40007d60 <_POSIX_Timer_TSR+0x34>
40007d48: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
40007d4c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
40007d50: 80 a0 60 00 cmp %g1, 0
40007d54: 02 80 00 1f be 40007dd0 <_POSIX_Timer_TSR+0xa4> <== NEVER TAKEN
40007d58: 82 10 20 04 mov 4, %g1
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
40007d5c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
40007d60: d4 06 60 08 ld [ %i1 + 8 ], %o2
40007d64: 90 06 60 10 add %i1, 0x10, %o0
40007d68: 17 10 00 1f sethi %hi(0x40007c00), %o3
40007d6c: 98 10 00 19 mov %i1, %o4
40007d70: 40 00 17 ca call 4000dc98 <_POSIX_Timer_Insert_helper>
40007d74: 96 12 e1 2c or %o3, 0x12c, %o3
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
40007d78: 80 8a 20 ff btst 0xff, %o0
40007d7c: 02 80 00 1a be 40007de4 <_POSIX_Timer_TSR+0xb8> <== NEVER TAKEN
40007d80: 90 07 bf f8 add %fp, -8, %o0
40007d84: 13 10 00 7f sethi %hi(0x4001fc00), %o1
40007d88: 40 00 05 ed call 4000953c <_TOD_Get_with_nanoseconds>
40007d8c: 92 12 62 28 or %o1, 0x228, %o1 ! 4001fe28 <_TOD>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
40007d90: 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);
40007d94: 94 10 20 00 clr %o2
40007d98: 90 10 00 1c mov %i4, %o0
40007d9c: 92 10 00 1d mov %i5, %o1
40007da0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007da4: 40 00 48 0b call 40019dd0 <__divdi3>
40007da8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007dac: 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);
40007db0: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007db4: 94 10 20 00 clr %o2
40007db8: 92 10 00 1d mov %i5, %o1
40007dbc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007dc0: 40 00 48 ef call 4001a17c <__moddi3>
40007dc4: 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;
40007dc8: 82 10 20 03 mov 3, %g1
40007dcc: 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 ) ) {
40007dd0: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
40007dd4: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
40007dd8: 40 00 16 9f call 4000d854 <pthread_kill>
40007ddc: 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;
40007de0: c0 26 60 68 clr [ %i1 + 0x68 ]
40007de4: 81 c7 e0 08 ret
40007de8: 81 e8 00 00 restore
4000f3f4 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4000f3f4: 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,
4000f3f8: 98 10 20 01 mov 1, %o4
4000f3fc: 90 10 00 18 mov %i0, %o0
4000f400: 92 10 00 19 mov %i1, %o1
4000f404: 94 07 bf cc add %fp, -52, %o2
4000f408: 40 00 00 2e call 4000f4c0 <_POSIX_signals_Clear_signals>
4000f40c: 96 10 00 1a mov %i2, %o3
4000f410: 80 8a 20 ff btst 0xff, %o0
4000f414: 02 80 00 28 be 4000f4b4 <_POSIX_signals_Check_signal+0xc0>
4000f418: 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 )
4000f41c: 85 2e 60 02 sll %i1, 2, %g2
4000f420: 35 10 00 7e sethi %hi(0x4001f800), %i2
4000f424: b7 2e 60 04 sll %i1, 4, %i3
4000f428: b4 16 a1 f0 or %i2, 0x1f0, %i2
4000f42c: b6 26 c0 02 sub %i3, %g2, %i3
4000f430: 84 06 80 1b add %i2, %i3, %g2
4000f434: fa 00 a0 08 ld [ %g2 + 8 ], %i5
4000f438: 80 a7 60 01 cmp %i5, 1
4000f43c: 02 80 00 1e be 4000f4b4 <_POSIX_signals_Check_signal+0xc0><== NEVER TAKEN
4000f440: 90 07 bf d8 add %fp, -40, %o0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
4000f444: f8 06 20 d0 ld [ %i0 + 0xd0 ], %i4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4000f448: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000f44c: 82 10 40 1c or %g1, %i4, %g1
4000f450: 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,
4000f454: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000f458: d2 00 61 a0 ld [ %g1 + 0x1a0 ], %o1 ! 4001f9a0 <_Per_CPU_Information+0x10>
4000f45c: 94 10 20 28 mov 0x28, %o2
4000f460: 40 00 03 f2 call 40010428 <memcpy>
4000f464: 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 ) {
4000f468: c2 06 80 1b ld [ %i2 + %i3 ], %g1
4000f46c: 80 a0 60 02 cmp %g1, 2
4000f470: 12 80 00 07 bne 4000f48c <_POSIX_signals_Check_signal+0x98>
4000f474: 90 10 00 19 mov %i1, %o0
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
4000f478: 92 07 bf cc add %fp, -52, %o1
4000f47c: 9f c7 40 00 call %i5
4000f480: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4000f484: 10 80 00 05 b 4000f498 <_POSIX_signals_Check_signal+0xa4>
4000f488: 03 10 00 7e sethi %hi(0x4001f800), %g1
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
4000f48c: 9f c7 40 00 call %i5
4000f490: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
4000f494: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000f498: d0 00 61 a0 ld [ %g1 + 0x1a0 ], %o0 ! 4001f9a0 <_Per_CPU_Information+0x10>
4000f49c: 92 07 bf d8 add %fp, -40, %o1
4000f4a0: 90 02 20 20 add %o0, 0x20, %o0
4000f4a4: 40 00 03 e1 call 40010428 <memcpy>
4000f4a8: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4000f4ac: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
4000f4b0: f8 26 20 d0 st %i4, [ %i0 + 0xd0 ]
return true;
}
4000f4b4: b0 08 60 01 and %g1, 1, %i0
4000f4b8: 81 c7 e0 08 ret
4000f4bc: 81 e8 00 00 restore
4000fa40 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
4000fa40: 9d e3 bf a0 save %sp, -96, %sp
4000fa44: 82 06 3f ff add %i0, -1, %g1
4000fa48: ba 10 20 01 mov 1, %i5
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4000fa4c: 7f ff ca 7f call 40002448 <sparc_disable_interrupts>
4000fa50: bb 2f 40 01 sll %i5, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4000fa54: 05 10 00 7e sethi %hi(0x4001f800), %g2
4000fa58: 83 2e 20 02 sll %i0, 2, %g1
4000fa5c: 84 10 a1 f0 or %g2, 0x1f0, %g2
4000fa60: b1 2e 20 04 sll %i0, 4, %i0
4000fa64: 82 26 00 01 sub %i0, %g1, %g1
4000fa68: c4 00 80 01 ld [ %g2 + %g1 ], %g2
4000fa6c: 80 a0 a0 02 cmp %g2, 2
4000fa70: 32 80 00 0c bne,a 4000faa0 <_POSIX_signals_Clear_process_signals+0x60>
4000fa74: 03 10 00 7e sethi %hi(0x4001f800), %g1
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4000fa78: 05 10 00 7e sethi %hi(0x4001f800), %g2
4000fa7c: 84 10 a3 e8 or %g2, 0x3e8, %g2 ! 4001fbe8 <_POSIX_signals_Siginfo>
4000fa80: 86 00 40 02 add %g1, %g2, %g3
4000fa84: 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 );
4000fa88: 86 00 e0 04 add %g3, 4, %g3
4000fa8c: 80 a0 40 03 cmp %g1, %g3
4000fa90: 02 80 00 04 be 4000faa0 <_POSIX_signals_Clear_process_signals+0x60><== ALWAYS TAKEN
4000fa94: 03 10 00 7e sethi %hi(0x4001f800), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
4000fa98: 7f ff ca 70 call 40002458 <sparc_enable_interrupts>
4000fa9c: 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;
4000faa0: c4 00 63 e4 ld [ %g1 + 0x3e4 ], %g2
4000faa4: ba 28 80 1d andn %g2, %i5, %i5
4000faa8: 10 bf ff fc b 4000fa98 <_POSIX_signals_Clear_process_signals+0x58>
4000faac: fa 20 63 e4 st %i5, [ %g1 + 0x3e4 ]
40008824 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40008824: 82 10 20 1b mov 0x1b, %g1
40008828: 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(
4000882c: 86 00 7f ff add %g1, -1, %g3
40008830: 87 28 80 03 sll %g2, %g3, %g3
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
40008834: 80 88 c0 08 btst %g3, %o0
40008838: 12 80 00 11 bne 4000887c <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
4000883c: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40008840: 82 00 60 01 inc %g1
40008844: 80 a0 60 20 cmp %g1, 0x20
40008848: 12 bf ff fa bne 40008830 <_POSIX_signals_Get_lowest+0xc>
4000884c: 86 00 7f ff add %g1, -1, %g3
40008850: 82 10 20 01 mov 1, %g1
40008854: 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(
40008858: 86 00 7f ff add %g1, -1, %g3
4000885c: 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 ) ) {
40008860: 80 88 c0 08 btst %g3, %o0
40008864: 12 80 00 06 bne 4000887c <_POSIX_signals_Get_lowest+0x58>
40008868: 01 00 00 00 nop
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
4000886c: 82 00 60 01 inc %g1
40008870: 80 a0 60 1b cmp %g1, 0x1b
40008874: 12 bf ff fa bne 4000885c <_POSIX_signals_Get_lowest+0x38> <== ALWAYS TAKEN
40008878: 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;
}
4000887c: 81 c3 e0 08 retl
40008880: 90 10 00 01 mov %g1, %o0
4000cfb4 <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
4000cfb4: 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;
4000cfb8: 03 10 00 7e sethi %hi(0x4001f800), %g1
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000cfbc: 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;
4000cfc0: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
4000cfc4: 80 a7 60 00 cmp %i5, 0
4000cfc8: 02 80 00 11 be 4000d00c <_POSIX_signals_Post_switch_hook+0x58><== NEVER TAKEN
4000cfcc: 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)) ) {
4000cfd0: 35 10 00 7e sethi %hi(0x4001f800), %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 );
4000cfd4: 7f ff d5 1d call 40002448 <sparc_disable_interrupts>
4000cfd8: 01 00 00 00 nop
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000cfdc: c4 06 a3 e4 ld [ %i2 + 0x3e4 ], %g2
4000cfe0: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
4000cfe4: 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 &
4000cfe8: c4 07 60 d0 ld [ %i5 + 0xd0 ], %g2
4000cfec: 80 a8 40 02 andncc %g1, %g2, %g0
4000cff0: 12 80 00 09 bne 4000d014 <_POSIX_signals_Post_switch_hook+0x60>
4000cff4: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
4000cff8: 7f ff d5 18 call 40002458 <sparc_enable_interrupts>
4000cffc: 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;
4000d000: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000d004: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 ! 4001f9a0 <_Per_CPU_Information+0x10>
4000d008: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
4000d00c: 81 c7 e0 08 ret
4000d010: 81 e8 00 00 restore
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
4000d014: 7f ff d5 11 call 40002458 <sparc_enable_interrupts>
4000d018: b8 10 20 1b mov 0x1b, %i4
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4000d01c: 92 10 00 1c mov %i4, %o1
4000d020: 94 10 20 00 clr %o2
4000d024: 40 00 08 f4 call 4000f3f4 <_POSIX_signals_Check_signal>
4000d028: 90 10 00 1d mov %i5, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000d02c: 92 10 00 1c mov %i4, %o1
4000d030: 90 10 00 1d mov %i5, %o0
4000d034: 40 00 08 f0 call 4000f3f4 <_POSIX_signals_Check_signal>
4000d038: 94 10 20 01 mov 1, %o2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4000d03c: b8 07 20 01 inc %i4
4000d040: 80 a7 20 20 cmp %i4, 0x20
4000d044: 12 bf ff f7 bne 4000d020 <_POSIX_signals_Post_switch_hook+0x6c>
4000d048: 92 10 00 1c mov %i4, %o1
4000d04c: 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 );
4000d050: 92 10 00 1c mov %i4, %o1
4000d054: 94 10 20 00 clr %o2
4000d058: 40 00 08 e7 call 4000f3f4 <_POSIX_signals_Check_signal>
4000d05c: 90 10 00 1d mov %i5, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000d060: 92 10 00 1c mov %i4, %o1
4000d064: 90 10 00 1d mov %i5, %o0
4000d068: 40 00 08 e3 call 4000f3f4 <_POSIX_signals_Check_signal>
4000d06c: 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++ ) {
4000d070: b8 07 20 01 inc %i4
4000d074: 80 a7 20 1b cmp %i4, 0x1b
4000d078: 12 bf ff f7 bne 4000d054 <_POSIX_signals_Post_switch_hook+0xa0>
4000d07c: 92 10 00 1c mov %i4, %o1
4000d080: 30 bf ff d5 b,a 4000cfd4 <_POSIX_signals_Post_switch_hook+0x20>
4001c0c8 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
4001c0c8: 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 ) ) {
4001c0cc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001c0d0: 3b 04 00 20 sethi %hi(0x10008000), %i5
4001c0d4: 84 06 7f ff add %i1, -1, %g2
4001c0d8: 86 10 20 01 mov 1, %g3
4001c0dc: 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 ];
4001c0e0: 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 ) ) {
4001c0e4: 80 a7 00 1d cmp %i4, %i5
4001c0e8: 12 80 00 1e bne 4001c160 <_POSIX_signals_Unblock_thread+0x98>
4001c0ec: 85 28 c0 02 sll %g3, %g2, %g2
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
4001c0f0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4001c0f4: 80 88 80 01 btst %g2, %g1
4001c0f8: 12 80 00 08 bne 4001c118 <_POSIX_signals_Unblock_thread+0x50>
4001c0fc: 82 10 20 04 mov 4, %g1
4001c100: c2 01 20 d0 ld [ %g4 + 0xd0 ], %g1
4001c104: 80 a8 80 01 andncc %g2, %g1, %g0
4001c108: 32 80 00 04 bne,a 4001c118 <_POSIX_signals_Unblock_thread+0x50>
4001c10c: 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;
4001c110: 10 80 00 3d b 4001c204 <_POSIX_signals_Unblock_thread+0x13c>
4001c114: 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;
4001c118: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
4001c11c: 80 a6 a0 00 cmp %i2, 0
4001c120: 12 80 00 07 bne 4001c13c <_POSIX_signals_Unblock_thread+0x74>
4001c124: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
4001c128: 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;
4001c12c: f2 22 00 00 st %i1, [ %o0 ]
the_info->si_code = SI_USER;
4001c130: c2 22 20 04 st %g1, [ %o0 + 4 ]
the_info->si_value.sival_int = 0;
4001c134: 10 80 00 05 b 4001c148 <_POSIX_signals_Unblock_thread+0x80>
4001c138: c0 22 20 08 clr [ %o0 + 8 ]
} else {
*the_info = *info;
4001c13c: 92 10 00 1a mov %i2, %o1
4001c140: 7f ff d0 ba call 40010428 <memcpy>
4001c144: 94 10 20 0c mov 0xc, %o2
}
_Thread_queue_Extract_with_proxy( the_thread );
4001c148: 90 10 00 18 mov %i0, %o0
4001c14c: 7f ff bb 98 call 4000afac <_Thread_queue_Extract_with_proxy>
4001c150: b0 10 20 01 mov 1, %i0
4001c154: b0 0e 20 01 and %i0, 1, %i0
4001c158: 81 c7 e0 08 ret
4001c15c: 81 e8 00 00 restore
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
4001c160: c8 01 20 d0 ld [ %g4 + 0xd0 ], %g4
4001c164: 80 a8 80 04 andncc %g2, %g4, %g0
4001c168: 02 80 00 26 be 4001c200 <_POSIX_signals_Unblock_thread+0x138>
4001c16c: 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 ) ) {
4001c170: 80 88 40 02 btst %g1, %g2
4001c174: 02 80 00 17 be 4001c1d0 <_POSIX_signals_Unblock_thread+0x108>
4001c178: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
4001c17c: 84 10 20 04 mov 4, %g2
4001c180: 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) )
4001c184: 05 00 00 ef sethi %hi(0x3bc00), %g2
4001c188: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
4001c18c: 80 88 40 02 btst %g1, %g2
4001c190: 02 80 00 06 be 4001c1a8 <_POSIX_signals_Unblock_thread+0xe0>
4001c194: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
4001c198: 7f ff bb 85 call 4000afac <_Thread_queue_Extract_with_proxy>
4001c19c: 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;
4001c1a0: 10 80 00 19 b 4001c204 <_POSIX_signals_Unblock_thread+0x13c>
4001c1a4: 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) ) {
4001c1a8: 22 80 00 17 be,a 4001c204 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
4001c1ac: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4001c1b0: 7f ff bd 21 call 4000b634 <_Watchdog_Remove>
4001c1b4: 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 );
4001c1b8: 90 10 00 18 mov %i0, %o0
4001c1bc: 13 04 01 ff sethi %hi(0x1007fc00), %o1
4001c1c0: 7f ff b8 e0 call 4000a540 <_Thread_Clear_state>
4001c1c4: 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;
4001c1c8: 10 80 00 0f b 4001c204 <_POSIX_signals_Unblock_thread+0x13c>
4001c1cc: 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 ) {
4001c1d0: 32 80 00 0d bne,a 4001c204 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
4001c1d4: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001c1d8: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001c1dc: 82 10 61 90 or %g1, 0x190, %g1 ! 4001f990 <_Per_CPU_Information>
4001c1e0: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001c1e4: 80 a0 a0 00 cmp %g2, 0
4001c1e8: 22 80 00 07 be,a 4001c204 <_POSIX_signals_Unblock_thread+0x13c>
4001c1ec: b0 10 20 00 clr %i0
4001c1f0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001c1f4: 80 a6 00 02 cmp %i0, %g2
4001c1f8: 22 80 00 02 be,a 4001c200 <_POSIX_signals_Unblock_thread+0x138><== ALWAYS TAKEN
4001c1fc: c6 28 60 0c stb %g3, [ %g1 + 0xc ]
_Thread_Dispatch_necessary = true;
}
}
return false;
4001c200: b0 10 20 00 clr %i0
}
4001c204: b0 0e 20 01 and %i0, 1, %i0
4001c208: 81 c7 e0 08 ret
4001c20c: 81 e8 00 00 restore
4000a750 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4000a750: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
4000a754: 80 a6 60 00 cmp %i1, 0
4000a758: 02 80 00 69 be 4000a8fc <_RBTree_Extract_unprotected+0x1ac>
4000a75c: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
4000a760: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000a764: 80 a6 40 01 cmp %i1, %g1
4000a768: 32 80 00 07 bne,a 4000a784 <_RBTree_Extract_unprotected+0x34>
4000a76c: 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 );
4000a770: 90 10 00 19 mov %i1, %o0
4000a774: 40 00 01 31 call 4000ac38 <_RBTree_Next_unprotected>
4000a778: 92 10 20 01 mov 1, %o1
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
4000a77c: 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]) {
4000a780: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000a784: 80 a6 40 01 cmp %i1, %g1
4000a788: 32 80 00 07 bne,a 4000a7a4 <_RBTree_Extract_unprotected+0x54>
4000a78c: 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 );
4000a790: 90 10 00 19 mov %i1, %o0
4000a794: 40 00 01 29 call 4000ac38 <_RBTree_Next_unprotected>
4000a798: 92 10 20 00 clr %o1
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
4000a79c: 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]) {
4000a7a0: fa 06 60 04 ld [ %i1 + 4 ], %i5
4000a7a4: 80 a7 60 00 cmp %i5, 0
4000a7a8: 02 80 00 36 be 4000a880 <_RBTree_Extract_unprotected+0x130>
4000a7ac: f8 06 60 08 ld [ %i1 + 8 ], %i4
4000a7b0: 80 a7 20 00 cmp %i4, 0
4000a7b4: 32 80 00 05 bne,a 4000a7c8 <_RBTree_Extract_unprotected+0x78>
4000a7b8: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000a7bc: 10 80 00 35 b 4000a890 <_RBTree_Extract_unprotected+0x140>
4000a7c0: 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];
4000a7c4: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000a7c8: 80 a0 60 00 cmp %g1, 0
4000a7cc: 32 bf ff fe bne,a 4000a7c4 <_RBTree_Extract_unprotected+0x74>
4000a7d0: 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];
4000a7d4: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
4000a7d8: 80 a7 20 00 cmp %i4, 0
4000a7dc: 02 80 00 05 be 4000a7f0 <_RBTree_Extract_unprotected+0xa0>
4000a7e0: 01 00 00 00 nop
leaf->parent = target->parent;
4000a7e4: c2 07 40 00 ld [ %i5 ], %g1
4000a7e8: 10 80 00 04 b 4000a7f8 <_RBTree_Extract_unprotected+0xa8>
4000a7ec: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
4000a7f0: 7f ff ff 73 call 4000a5bc <_RBTree_Extract_validate_unprotected>
4000a7f4: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
4000a7f8: 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;
4000a7fc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
dir = target != target->parent->child[0];
4000a800: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000a804: 86 1f 40 03 xor %i5, %g3, %g3
4000a808: 80 a0 00 03 cmp %g0, %g3
4000a80c: 86 40 20 00 addx %g0, 0, %g3
target->parent->child[dir] = leaf;
4000a810: 87 28 e0 02 sll %g3, 2, %g3
4000a814: 84 00 80 03 add %g2, %g3, %g2
4000a818: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4000a81c: c4 06 40 00 ld [ %i1 ], %g2
4000a820: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000a824: 86 1e 40 03 xor %i1, %g3, %g3
4000a828: 80 a0 00 03 cmp %g0, %g3
4000a82c: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = target;
4000a830: 87 28 e0 02 sll %g3, 2, %g3
4000a834: 84 00 80 03 add %g2, %g3, %g2
4000a838: 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];
4000a83c: c4 06 60 08 ld [ %i1 + 8 ], %g2
4000a840: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
4000a844: c4 06 60 08 ld [ %i1 + 8 ], %g2
4000a848: 80 a0 a0 00 cmp %g2, 0
4000a84c: 32 80 00 02 bne,a 4000a854 <_RBTree_Extract_unprotected+0x104><== ALWAYS TAKEN
4000a850: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
4000a854: c4 06 60 04 ld [ %i1 + 4 ], %g2
4000a858: c4 27 60 04 st %g2, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
4000a85c: c4 06 60 04 ld [ %i1 + 4 ], %g2
4000a860: 80 a0 a0 00 cmp %g2, 0
4000a864: 32 80 00 02 bne,a 4000a86c <_RBTree_Extract_unprotected+0x11c>
4000a868: 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;
4000a86c: c4 06 40 00 ld [ %i1 ], %g2
4000a870: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
4000a874: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4000a878: 10 80 00 14 b 4000a8c8 <_RBTree_Extract_unprotected+0x178>
4000a87c: 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 ) {
4000a880: 80 a7 20 00 cmp %i4, 0
4000a884: 32 80 00 04 bne,a 4000a894 <_RBTree_Extract_unprotected+0x144>
4000a888: c2 06 40 00 ld [ %i1 ], %g1
4000a88c: 30 80 00 04 b,a 4000a89c <_RBTree_Extract_unprotected+0x14c>
leaf->parent = the_node->parent;
4000a890: c2 06 40 00 ld [ %i1 ], %g1
4000a894: 10 80 00 04 b 4000a8a4 <_RBTree_Extract_unprotected+0x154>
4000a898: 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);
4000a89c: 7f ff ff 48 call 4000a5bc <_RBTree_Extract_validate_unprotected>
4000a8a0: 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];
4000a8a4: 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;
4000a8a8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4000a8ac: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000a8b0: 86 1e 40 03 xor %i1, %g3, %g3
4000a8b4: 80 a0 00 03 cmp %g0, %g3
4000a8b8: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = leaf;
4000a8bc: 87 28 e0 02 sll %g3, 2, %g3
4000a8c0: 84 00 80 03 add %g2, %g3, %g2
4000a8c4: 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 */
4000a8c8: 80 a0 60 00 cmp %g1, 0
4000a8cc: 32 80 00 06 bne,a 4000a8e4 <_RBTree_Extract_unprotected+0x194>
4000a8d0: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
4000a8d4: 80 a7 20 00 cmp %i4, 0
4000a8d8: 32 80 00 02 bne,a 4000a8e0 <_RBTree_Extract_unprotected+0x190>
4000a8dc: 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;
4000a8e0: 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;
4000a8e4: c0 26 60 08 clr [ %i1 + 8 ]
4000a8e8: c0 26 60 04 clr [ %i1 + 4 ]
4000a8ec: 80 a0 60 00 cmp %g1, 0
4000a8f0: 02 80 00 03 be 4000a8fc <_RBTree_Extract_unprotected+0x1ac>
4000a8f4: c0 26 40 00 clr [ %i1 ]
4000a8f8: c0 20 60 0c clr [ %g1 + 0xc ]
4000a8fc: 81 c7 e0 08 ret
4000a900: 81 e8 00 00 restore
4000bbd0 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
4000bbd0: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
4000bbd4: 80 a6 20 00 cmp %i0, 0
4000bbd8: 02 80 00 10 be 4000bc18 <_RBTree_Initialize+0x48> <== NEVER TAKEN
4000bbdc: 01 00 00 00 nop
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
4000bbe0: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
4000bbe4: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
4000bbe8: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
4000bbec: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
4000bbf0: 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-- ) {
4000bbf4: 10 80 00 06 b 4000bc0c <_RBTree_Initialize+0x3c>
4000bbf8: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
4000bbfc: 90 10 00 18 mov %i0, %o0
4000bc00: 7f ff ff 2e call 4000b8b8 <_RBTree_Insert_unprotected>
4000bc04: b4 06 80 1c add %i2, %i4, %i2
4000bc08: 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-- ) {
4000bc0c: 80 a6 e0 00 cmp %i3, 0
4000bc10: 12 bf ff fb bne 4000bbfc <_RBTree_Initialize+0x2c>
4000bc14: 92 10 00 1a mov %i2, %o1
4000bc18: 81 c7 e0 08 ret
4000bc1c: 81 e8 00 00 restore
4000a9a4 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4000a9a4: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
4000a9a8: 80 a6 60 00 cmp %i1, 0
4000a9ac: 02 80 00 7c be 4000ab9c <_RBTree_Insert_unprotected+0x1f8>
4000a9b0: ba 10 00 18 mov %i0, %i5
RBTree_Node *iter_node = the_rbtree->root;
4000a9b4: f0 06 20 04 ld [ %i0 + 4 ], %i0
int compare_result;
if (!iter_node) { /* special case: first node inserted */
4000a9b8: b6 96 20 00 orcc %i0, 0, %i3
4000a9bc: 32 80 00 0c bne,a 4000a9ec <_RBTree_Insert_unprotected+0x48>
4000a9c0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
the_node->color = RBT_BLACK;
4000a9c4: c0 26 60 0c clr [ %i1 + 0xc ]
the_rbtree->root = the_node;
4000a9c8: f2 27 60 04 st %i1, [ %i5 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
4000a9cc: f2 27 60 0c st %i1, [ %i5 + 0xc ]
4000a9d0: f2 27 60 08 st %i1, [ %i5 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
4000a9d4: fa 26 40 00 st %i5, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
4000a9d8: c0 26 60 08 clr [ %i1 + 8 ]
4000a9dc: c0 26 60 04 clr [ %i1 + 4 ]
4000a9e0: 81 c7 e0 08 ret
4000a9e4: 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);
4000a9e8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000a9ec: 90 10 00 19 mov %i1, %o0
4000a9f0: 9f c0 40 00 call %g1
4000a9f4: 92 10 00 18 mov %i0, %o1
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000a9f8: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
4000a9fc: 80 a0 60 00 cmp %g1, 0
4000aa00: 02 80 00 05 be 4000aa14 <_RBTree_Insert_unprotected+0x70>
4000aa04: b8 38 00 08 xnor %g0, %o0, %i4
4000aa08: 80 a2 20 00 cmp %o0, 0
4000aa0c: 02 80 00 65 be 4000aba0 <_RBTree_Insert_unprotected+0x1fc>
4000aa10: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
4000aa14: b9 37 20 1f srl %i4, 0x1f, %i4
if (!iter_node->child[dir]) {
4000aa18: 83 2f 20 02 sll %i4, 2, %g1
4000aa1c: 82 06 00 01 add %i0, %g1, %g1
4000aa20: f0 00 60 04 ld [ %g1 + 4 ], %i0
4000aa24: 80 a6 20 00 cmp %i0, 0
4000aa28: 32 bf ff f0 bne,a 4000a9e8 <_RBTree_Insert_unprotected+0x44>
4000aa2c: b6 10 00 18 mov %i0, %i3
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
4000aa30: c0 26 60 08 clr [ %i1 + 8 ]
4000aa34: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
4000aa38: 84 10 20 01 mov 1, %g2
iter_node->child[dir] = the_node;
4000aa3c: 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;
4000aa40: c4 26 60 0c st %g2, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
4000aa44: f6 26 40 00 st %i3, [ %i1 ]
/* update min/max */
compare_result = the_rbtree->compare_function(
4000aa48: 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];
4000aa4c: b6 07 20 02 add %i4, 2, %i3
4000aa50: 85 2e e0 02 sll %i3, 2, %g2
4000aa54: d2 07 40 02 ld [ %i5 + %g2 ], %o1
4000aa58: 9f c0 40 00 call %g1
4000aa5c: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
4000aa60: 80 a7 20 00 cmp %i4, 0
4000aa64: 12 80 00 06 bne 4000aa7c <_RBTree_Insert_unprotected+0xd8>
4000aa68: 80 a2 20 00 cmp %o0, 0
4000aa6c: 36 80 00 3c bge,a 4000ab5c <_RBTree_Insert_unprotected+0x1b8>
4000aa70: d0 06 40 00 ld [ %i1 ], %o0
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
4000aa74: 10 80 00 04 b 4000aa84 <_RBTree_Insert_unprotected+0xe0>
4000aa78: 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)) ) {
4000aa7c: 04 80 00 37 ble 4000ab58 <_RBTree_Insert_unprotected+0x1b4>
4000aa80: b7 2e e0 02 sll %i3, 2, %i3
the_rbtree->first[dir] = the_node;
4000aa84: 10 80 00 35 b 4000ab58 <_RBTree_Insert_unprotected+0x1b4>
4000aa88: 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;
4000aa8c: 02 80 00 13 be 4000aad8 <_RBTree_Insert_unprotected+0x134><== NEVER TAKEN
4000aa90: 82 10 20 00 clr %g1
if(!(the_node->parent->parent->parent)) return NULL;
4000aa94: c2 07 40 00 ld [ %i5 ], %g1
4000aa98: 80 a0 60 00 cmp %g1, 0
4000aa9c: 02 80 00 0f be 4000aad8 <_RBTree_Insert_unprotected+0x134><== NEVER TAKEN
4000aaa0: 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])
4000aaa4: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000aaa8: 80 a2 00 01 cmp %o0, %g1
4000aaac: 22 80 00 02 be,a 4000aab4 <_RBTree_Insert_unprotected+0x110>
4000aab0: 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);
4000aab4: 80 a0 60 00 cmp %g1, 0
4000aab8: 02 80 00 09 be 4000aadc <_RBTree_Insert_unprotected+0x138>
4000aabc: 84 10 20 00 clr %g2
4000aac0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000aac4: 80 a0 a0 01 cmp %g2, 1
4000aac8: 32 80 00 05 bne,a 4000aadc <_RBTree_Insert_unprotected+0x138>
4000aacc: 84 10 20 00 clr %g2
4000aad0: 10 80 00 03 b 4000aadc <_RBTree_Insert_unprotected+0x138>
4000aad4: 84 10 20 01 mov 1, %g2
4000aad8: 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)) {
4000aadc: 80 a0 a0 00 cmp %g2, 0
4000aae0: 22 80 00 08 be,a 4000ab00 <_RBTree_Insert_unprotected+0x15c>
4000aae4: c2 07 60 04 ld [ %i5 + 4 ], %g1
the_node->parent->color = RBT_BLACK;
4000aae8: c0 22 20 0c clr [ %o0 + 0xc ]
u->color = RBT_BLACK;
4000aaec: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
4000aaf0: b2 10 00 1d mov %i5, %i1
4000aaf4: 82 10 20 01 mov 1, %g1
4000aaf8: 10 80 00 18 b 4000ab58 <_RBTree_Insert_unprotected+0x1b4>
4000aafc: 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];
4000ab00: 82 1a 00 01 xor %o0, %g1, %g1
4000ab04: 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];
4000ab08: c2 02 20 04 ld [ %o0 + 4 ], %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
4000ab0c: 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];
4000ab10: 82 1e 40 01 xor %i1, %g1, %g1
4000ab14: 80 a0 00 01 cmp %g0, %g1
4000ab18: 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) {
4000ab1c: 80 a0 40 1c cmp %g1, %i4
4000ab20: 22 80 00 08 be,a 4000ab40 <_RBTree_Insert_unprotected+0x19c>
4000ab24: c2 06 40 00 ld [ %i1 ], %g1
_RBTree_Rotate(the_node->parent, pdir);
4000ab28: 7f ff ff 80 call 4000a928 <_RBTree_Rotate>
4000ab2c: 92 10 00 1c mov %i4, %o1
the_node = the_node->child[pdir];
4000ab30: 83 2f 20 02 sll %i4, 2, %g1
4000ab34: b2 06 40 01 add %i1, %g1, %i1
4000ab38: f2 06 60 04 ld [ %i1 + 4 ], %i1
}
the_node->parent->color = RBT_BLACK;
4000ab3c: c2 06 40 00 ld [ %i1 ], %g1
g->color = RBT_RED;
4000ab40: 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;
4000ab44: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
4000ab48: d2 27 60 0c st %o1, [ %i5 + 0xc ]
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4000ab4c: 90 10 00 1d mov %i5, %o0
4000ab50: 7f ff ff 76 call 4000a928 <_RBTree_Rotate>
4000ab54: 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;
4000ab58: d0 06 40 00 ld [ %i1 ], %o0
4000ab5c: fa 02 00 00 ld [ %o0 ], %i5
4000ab60: 80 a7 60 00 cmp %i5, 0
4000ab64: 22 80 00 06 be,a 4000ab7c <_RBTree_Insert_unprotected+0x1d8>
4000ab68: 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);
4000ab6c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000ab70: 82 18 60 01 xor %g1, 1, %g1
4000ab74: 80 a0 00 01 cmp %g0, %g1
4000ab78: 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))) {
4000ab7c: 80 a0 60 00 cmp %g1, 0
4000ab80: 12 bf ff c3 bne 4000aa8c <_RBTree_Insert_unprotected+0xe8>
4000ab84: 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;
4000ab88: 12 80 00 06 bne 4000aba0 <_RBTree_Insert_unprotected+0x1fc>
4000ab8c: 01 00 00 00 nop
4000ab90: c0 26 60 0c clr [ %i1 + 0xc ]
4000ab94: 81 c7 e0 08 ret
4000ab98: 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;
4000ab9c: b0 10 3f ff mov -1, %i0
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
4000aba0: 81 c7 e0 08 ret
4000aba4: 81 e8 00 00 restore
4000abd8 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
4000abd8: 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;
4000abdc: b8 10 20 00 clr %i4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
4000abe0: 80 a0 00 19 cmp %g0, %i1
4000abe4: 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];
4000abe8: 82 00 60 02 add %g1, 2, %g1
4000abec: 83 28 60 02 sll %g1, 2, %g1
while ( !stop && current != NULL ) {
4000abf0: 10 80 00 0a b 4000ac18 <_RBTree_Iterate_unprotected+0x40>
4000abf4: fa 06 00 01 ld [ %i0 + %g1 ], %i5
stop = (*visitor)( current, dir, visitor_arg );
4000abf8: 92 10 00 19 mov %i1, %o1
4000abfc: 9f c6 80 00 call %i2
4000ac00: 94 10 00 1b mov %i3, %o2
current = _RBTree_Next_unprotected( current, dir );
4000ac04: 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 );
4000ac08: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
4000ac0c: 40 00 00 0b call 4000ac38 <_RBTree_Next_unprotected>
4000ac10: 90 10 00 1d mov %i5, %o0
4000ac14: 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 ) {
4000ac18: 80 a7 60 00 cmp %i5, 0
4000ac1c: 02 80 00 05 be 4000ac30 <_RBTree_Iterate_unprotected+0x58>
4000ac20: b8 1f 20 01 xor %i4, 1, %i4
4000ac24: 80 8f 20 ff btst 0xff, %i4
4000ac28: 12 bf ff f4 bne 4000abf8 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
4000ac2c: 90 10 00 1d mov %i5, %o0
4000ac30: 81 c7 e0 08 ret
4000ac34: 81 e8 00 00 restore
4000a540 <_RBTree_Rotate>:
RBTree_Node *the_node,
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
4000a540: 80 a2 20 00 cmp %o0, 0
4000a544: 02 80 00 1c be 4000a5b4 <_RBTree_Rotate+0x74> <== NEVER TAKEN
4000a548: 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);
4000a54c: 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;
4000a550: 87 28 e0 02 sll %g3, 2, %g3
4000a554: 86 02 00 03 add %o0, %g3, %g3
4000a558: c2 00 e0 04 ld [ %g3 + 4 ], %g1
4000a55c: 80 a0 60 00 cmp %g1, 0
4000a560: 02 80 00 15 be 4000a5b4 <_RBTree_Rotate+0x74> <== NEVER TAKEN
4000a564: 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];
4000a568: 84 00 40 09 add %g1, %o1, %g2
4000a56c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000a570: c8 20 e0 04 st %g4, [ %g3 + 4 ]
if (c->child[dir])
4000a574: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000a578: 80 a0 a0 00 cmp %g2, 0
4000a57c: 32 80 00 02 bne,a 4000a584 <_RBTree_Rotate+0x44>
4000a580: 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;
4000a584: 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;
4000a588: 92 00 40 09 add %g1, %o1, %o1
4000a58c: d0 22 60 04 st %o0, [ %o1 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a590: c6 00 a0 04 ld [ %g2 + 4 ], %g3
c->parent = the_node->parent;
4000a594: 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;
4000a598: 86 1a 00 03 xor %o0, %g3, %g3
c->parent = the_node->parent;
the_node->parent = c;
4000a59c: 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;
4000a5a0: 80 a0 00 03 cmp %g0, %g3
4000a5a4: 86 40 20 00 addx %g0, 0, %g3
4000a5a8: 87 28 e0 02 sll %g3, 2, %g3
4000a5ac: 86 00 80 03 add %g2, %g3, %g3
4000a5b0: c2 20 e0 04 st %g1, [ %g3 + 4 ]
4000a5b4: 81 c3 e0 08 retl
4000a4f0 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
4000a4f0: 80 a2 20 00 cmp %o0, 0
4000a4f4: 02 80 00 10 be 4000a534 <_RBTree_Sibling+0x44> <== NEVER TAKEN
4000a4f8: 82 10 20 00 clr %g1
if(!(the_node->parent)) return NULL;
4000a4fc: c4 02 00 00 ld [ %o0 ], %g2
4000a500: 80 a0 a0 00 cmp %g2, 0
4000a504: 22 80 00 0d be,a 4000a538 <_RBTree_Sibling+0x48> <== NEVER TAKEN
4000a508: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
if(!(the_node->parent->parent)) return NULL;
4000a50c: c2 00 80 00 ld [ %g2 ], %g1
4000a510: 80 a0 60 00 cmp %g1, 0
4000a514: 02 80 00 08 be 4000a534 <_RBTree_Sibling+0x44>
4000a518: 82 10 20 00 clr %g1
if(the_node == the_node->parent->child[RBT_LEFT])
4000a51c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000a520: 80 a2 00 01 cmp %o0, %g1
4000a524: 22 80 00 04 be,a 4000a534 <_RBTree_Sibling+0x44>
4000a528: c2 00 a0 08 ld [ %g2 + 8 ], %g1
return the_node->parent->child[RBT_RIGHT];
4000a52c: 81 c3 e0 08 retl
4000a530: 90 10 00 01 mov %g1, %o0
else
return the_node->parent->child[RBT_LEFT];
}
4000a534: 90 10 00 01 mov %g1, %o0
4000a538: 81 c3 e0 08 retl
40009144 <_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 )
{
40009144: 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 ];
40009148: fa 06 21 4c ld [ %i0 + 0x14c ], %i5
if ( !api )
4000914c: 80 a7 60 00 cmp %i5, 0
40009150: 02 80 00 1c be 400091c0 <_RTEMS_signal_Post_switch_hook+0x7c><== NEVER TAKEN
40009154: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
40009158: 7f ff e8 9d call 400033cc <sparc_disable_interrupts>
4000915c: 01 00 00 00 nop
signal_set = asr->signals_posted;
40009160: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
40009164: c0 27 60 14 clr [ %i5 + 0x14 ]
_ISR_Enable( level );
40009168: 7f ff e8 9d call 400033dc <sparc_enable_interrupts>
4000916c: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
40009170: 80 a7 20 00 cmp %i4, 0
40009174: 02 80 00 13 be 400091c0 <_RTEMS_signal_Post_switch_hook+0x7c>
40009178: 94 07 bf fc add %fp, -4, %o2
return;
asr->nest_level += 1;
4000917c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40009180: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
40009184: 82 00 60 01 inc %g1
40009188: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000918c: 37 00 00 3f sethi %hi(0xfc00), %i3
40009190: 40 00 01 03 call 4000959c <rtems_task_mode>
40009194: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <PROM_START+0xffff>
(*asr->handler)( signal_set );
40009198: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000919c: 9f c0 40 00 call %g1
400091a0: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
400091a4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
400091a8: 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;
400091ac: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
400091b0: 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;
400091b4: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
400091b8: 40 00 00 f9 call 4000959c <rtems_task_mode>
400091bc: 94 07 bf fc add %fp, -4, %o2
400091c0: 81 c7 e0 08 ret
400091c4: 81 e8 00 00 restore
40033688 <_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
)
{
40033688: 9d e3 bf 98 save %sp, -104, %sp
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
4003368c: 13 10 01 90 sethi %hi(0x40064000), %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
40033690: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
40033694: 90 07 bf f8 add %fp, -8, %o0
40033698: 7f ff 54 a7 call 40008934 <_TOD_Get_with_nanoseconds>
4003369c: 92 12 63 80 or %o1, 0x380, %o1
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
400336a0: c4 1f bf f8 ldd [ %fp + -8 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
400336a4: 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) {
400336a8: 09 10 01 92 sethi %hi(0x40064800), %g4
400336ac: ba a0 c0 1d subcc %g3, %i5, %i5
400336b0: 88 11 21 40 or %g4, 0x140, %g4
400336b4: b8 60 80 1c subx %g2, %i4, %i4
400336b8: f8 3e 40 00 std %i4, [ %i1 ]
400336bc: fa 01 20 10 ld [ %g4 + 0x10 ], %i5
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
400336c0: d8 1e e0 80 ldd [ %i3 + 0x80 ], %o4
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
400336c4: 80 a6 c0 1d cmp %i3, %i5
400336c8: 12 80 00 15 bne 4003371c <_Rate_monotonic_Get_status+0x94>
400336cc: 82 10 20 01 mov 1, %g1
400336d0: f8 19 20 20 ldd [ %g4 + 0x20 ], %i4
400336d4: 86 a0 c0 1d subcc %g3, %i5, %g3
400336d8: 84 60 80 1c subx %g2, %i4, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
400336dc: ba 83 40 03 addcc %o5, %g3, %i5
400336e0: b8 43 00 02 addx %o4, %g2, %i4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400336e4: 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))
400336e8: 80 a0 80 1c cmp %g2, %i4
400336ec: 34 80 00 0c bg,a 4003371c <_Rate_monotonic_Get_status+0x94><== NEVER TAKEN
400336f0: 82 10 20 00 clr %g1 <== NOT EXECUTED
400336f4: 32 80 00 06 bne,a 4003370c <_Rate_monotonic_Get_status+0x84>
400336f8: 86 a7 40 03 subcc %i5, %g3, %g3
400336fc: 80 a0 c0 1d cmp %g3, %i5
40033700: 18 80 00 06 bgu 40033718 <_Rate_monotonic_Get_status+0x90>
40033704: 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;
40033708: 82 10 20 01 mov 1, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4003370c: 84 67 00 02 subx %i4, %g2, %g2
40033710: 10 80 00 03 b 4003371c <_Rate_monotonic_Get_status+0x94>
40033714: 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;
40033718: 82 10 20 00 clr %g1
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
4003371c: b0 08 60 01 and %g1, 1, %i0
40033720: 81 c7 e0 08 ret
40033724: 81 e8 00 00 restore
40033a90 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
40033a90: 9d e3 bf 98 save %sp, -104, %sp
40033a94: 11 10 01 93 sethi %hi(0x40064c00), %o0
40033a98: 92 10 00 18 mov %i0, %o1
40033a9c: 90 12 23 08 or %o0, 0x308, %o0
40033aa0: 7f ff 56 4c call 400093d0 <_Objects_Get>
40033aa4: 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 ) {
40033aa8: c2 07 bf fc ld [ %fp + -4 ], %g1
40033aac: 80 a0 60 00 cmp %g1, 0
40033ab0: 12 80 00 24 bne 40033b40 <_Rate_monotonic_Timeout+0xb0> <== NEVER TAKEN
40033ab4: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
40033ab8: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40033abc: 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);
40033ac0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40033ac4: 80 88 80 01 btst %g2, %g1
40033ac8: 22 80 00 0b be,a 40033af4 <_Rate_monotonic_Timeout+0x64>
40033acc: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40033ad0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
40033ad4: c2 07 60 08 ld [ %i5 + 8 ], %g1
40033ad8: 80 a0 80 01 cmp %g2, %g1
40033adc: 32 80 00 06 bne,a 40033af4 <_Rate_monotonic_Timeout+0x64>
40033ae0: 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 );
40033ae4: 13 04 01 ff sethi %hi(0x1007fc00), %o1
40033ae8: 7f ff 58 e5 call 40009e7c <_Thread_Clear_state>
40033aec: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
40033af0: 30 80 00 06 b,a 40033b08 <_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 ) {
40033af4: 80 a0 60 01 cmp %g1, 1
40033af8: 12 80 00 0d bne 40033b2c <_Rate_monotonic_Timeout+0x9c>
40033afc: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
40033b00: 82 10 20 03 mov 3, %g1
40033b04: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
40033b08: 7f ff ff 51 call 4003384c <_Rate_monotonic_Initiate_statistics>
40033b0c: 90 10 00 1d mov %i5, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40033b10: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40033b14: 11 10 01 91 sethi %hi(0x40064400), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40033b18: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40033b1c: 90 12 20 c8 or %o0, 0xc8, %o0
40033b20: 7f ff 5c bc call 4000ae10 <_Watchdog_Insert>
40033b24: 92 07 60 10 add %i5, 0x10, %o1
40033b28: 30 80 00 02 b,a 40033b30 <_Rate_monotonic_Timeout+0xa0>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
40033b2c: 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;
40033b30: 03 10 01 91 sethi %hi(0x40064400), %g1
40033b34: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 40064430 <_Thread_Dispatch_disable_level>
--level;
40033b38: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40033b3c: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
40033b40: 81 c7 e0 08 ret
40033b44: 81 e8 00 00 restore
40033728 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
40033728: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
4003372c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
40033730: 82 00 60 01 inc %g1
40033734: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
40033738: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4003373c: 80 a0 60 04 cmp %g1, 4
40033740: 12 80 00 05 bne 40033754 <_Rate_monotonic_Update_statistics+0x2c>
40033744: 90 10 00 18 mov %i0, %o0
stats->missed_count++;
40033748: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4003374c: 82 00 60 01 inc %g1
40033750: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
/*
* Grab status for time statistics.
*/
valid_status =
40033754: 92 07 bf f8 add %fp, -8, %o1
40033758: 7f ff ff cc call 40033688 <_Rate_monotonic_Get_status>
4003375c: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
40033760: 80 8a 20 ff btst 0xff, %o0
40033764: 02 80 00 38 be 40033844 <_Rate_monotonic_Update_statistics+0x11c>
40033768: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
4003376c: 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 ) )
40033770: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
40033774: b6 87 40 03 addcc %i5, %g3, %i3
40033778: b4 47 00 02 addx %i4, %g2, %i2
4003377c: 80 a0 40 02 cmp %g1, %g2
40033780: 14 80 00 09 bg 400337a4 <_Rate_monotonic_Update_statistics+0x7c>
40033784: f4 3e 20 70 std %i2, [ %i0 + 0x70 ]
40033788: 80 a0 40 02 cmp %g1, %g2
4003378c: 32 80 00 08 bne,a 400337ac <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
40033790: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
40033794: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
40033798: 80 a0 40 03 cmp %g1, %g3
4003379c: 28 80 00 04 bleu,a 400337ac <_Rate_monotonic_Update_statistics+0x84>
400337a0: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
400337a4: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
400337a8: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
400337ac: 80 a0 40 02 cmp %g1, %g2
400337b0: 26 80 00 0a bl,a 400337d8 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
400337b4: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
400337b8: 80 a0 40 02 cmp %g1, %g2
400337bc: 32 80 00 08 bne,a 400337dc <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
400337c0: c4 1f bf f8 ldd [ %fp + -8 ], %g2 <== NOT EXECUTED
400337c4: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
400337c8: 80 a0 40 03 cmp %g1, %g3
400337cc: 3a 80 00 04 bcc,a 400337dc <_Rate_monotonic_Update_statistics+0xb4>
400337d0: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
400337d4: 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 );
400337d8: c4 1f bf f8 ldd [ %fp + -8 ], %g2
400337dc: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
400337e0: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
400337e4: b6 87 40 03 addcc %i5, %g3, %i3
400337e8: b4 47 00 02 addx %i4, %g2, %i2
400337ec: 80 a0 40 02 cmp %g1, %g2
400337f0: 14 80 00 09 bg 40033814 <_Rate_monotonic_Update_statistics+0xec>
400337f4: f4 3e 20 88 std %i2, [ %i0 + 0x88 ]
400337f8: 80 a0 40 02 cmp %g1, %g2
400337fc: 32 80 00 08 bne,a 4003381c <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
40033800: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40033804: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
40033808: 80 a0 40 03 cmp %g1, %g3
4003380c: 28 80 00 04 bleu,a 4003381c <_Rate_monotonic_Update_statistics+0xf4>
40033810: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
40033814: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
40033818: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
4003381c: 80 a0 40 02 cmp %g1, %g2
40033820: 26 80 00 09 bl,a 40033844 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
40033824: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
40033828: 80 a0 40 02 cmp %g1, %g2
4003382c: 12 80 00 06 bne 40033844 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
40033830: 01 00 00 00 nop
40033834: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40033838: 80 a0 40 03 cmp %g1, %g3
4003383c: 2a 80 00 02 bcs,a 40033844 <_Rate_monotonic_Update_statistics+0x11c>
40033840: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
40033844: 81 c7 e0 08 ret
40033848: 81 e8 00 00 restore
4000a8a0 <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
4000a8a0: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
4000a8a4: 40 00 06 8d call 4000c2d8 <_Workspace_Allocate>
4000a8a8: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
4000a8ac: 80 a2 20 00 cmp %o0, 0
4000a8b0: 02 80 00 06 be 4000a8c8 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
4000a8b4: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
4000a8b8: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
4000a8bc: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
4000a8c0: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
4000a8c4: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
4000a8c8: 81 c7 e0 08 ret
4000a8cc: 91 e8 00 08 restore %g0, %o0, %o0
4000bbe0 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
4000bbe0: 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;
4000bbe4: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000bbe8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000bbec: 80 a0 40 09 cmp %g1, %o1
4000bbf0: 32 80 00 02 bne,a 4000bbf8 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
4000bbf4: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
4000bbf8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000bbfc: 80 a0 40 09 cmp %g1, %o1
4000bc00: 02 80 00 04 be 4000bc10 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
4000bc04: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
4000bc08: 40 00 01 83 call 4000c214 <_Thread_Change_priority>
4000bc0c: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
4000bc10: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
4000bc14: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000bc18: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000bc1c: 80 a0 a0 00 cmp %g2, 0
4000bc20: 02 80 00 09 be 4000bc44 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
4000bc24: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
4000bc28: d0 00 40 00 ld [ %g1 ], %o0
4000bc2c: 7f ff ff d7 call 4000bb88 <_Scheduler_CBS_Get_server_id>
4000bc30: 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 );
4000bc34: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000bc38: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000bc3c: 9f c0 40 00 call %g1
4000bc40: d0 07 bf fc ld [ %fp + -4 ], %o0
4000bc44: 81 c7 e0 08 ret
4000bc48: 81 e8 00 00 restore
4000b7e8 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
4000b7e8: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
4000b7ec: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000b7f0: 80 a0 60 00 cmp %g1, 0
4000b7f4: 04 80 00 1d ble 4000b868 <_Scheduler_CBS_Create_server+0x80>
4000b7f8: 01 00 00 00 nop
4000b7fc: c2 06 00 00 ld [ %i0 ], %g1
4000b800: 80 a0 60 00 cmp %g1, 0
4000b804: 04 80 00 19 ble 4000b868 <_Scheduler_CBS_Create_server+0x80>
4000b808: 03 10 00 87 sethi %hi(0x40021c00), %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++ ) {
4000b80c: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 40021e00 <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list[i] )
4000b810: 03 10 00 8c sethi %hi(0x40023000), %g1
4000b814: c6 00 61 08 ld [ %g1 + 0x108 ], %g3 ! 40023108 <_Scheduler_CBS_Server_list>
4000b818: 10 80 00 07 b 4000b834 <_Scheduler_CBS_Create_server+0x4c>
4000b81c: 82 10 20 00 clr %g1
4000b820: c8 00 c0 1c ld [ %g3 + %i4 ], %g4
4000b824: 80 a1 20 00 cmp %g4, 0
4000b828: 02 80 00 14 be 4000b878 <_Scheduler_CBS_Create_server+0x90>
4000b82c: 3b 10 00 8c sethi %hi(0x40023000), %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++ ) {
4000b830: 82 00 60 01 inc %g1
4000b834: 80 a0 40 02 cmp %g1, %g2
4000b838: 12 bf ff fa bne 4000b820 <_Scheduler_CBS_Create_server+0x38>
4000b83c: 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;
4000b840: 81 c7 e0 08 ret
4000b844: 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;
4000b848: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000b84c: c4 06 20 04 ld [ %i0 + 4 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
4000b850: 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;
4000b854: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
4000b858: 84 10 3f ff mov -1, %g2
4000b85c: c4 20 40 00 st %g2, [ %g1 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
4000b860: 81 c7 e0 08 ret
4000b864: 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;
4000b868: 81 c7 e0 08 ret
4000b86c: 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;
4000b870: 81 c7 e0 08 ret <== NOT EXECUTED
4000b874: 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 *)
4000b878: f6 07 61 08 ld [ %i5 + 0x108 ], %i3
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
4000b87c: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
4000b880: 40 00 07 7f call 4000d67c <_Workspace_Allocate>
4000b884: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
4000b888: 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 *)
4000b88c: d0 26 c0 1c st %o0, [ %i3 + %i4 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
4000b890: c4 07 61 08 ld [ %i5 + 0x108 ], %g2
4000b894: 83 28 60 02 sll %g1, 2, %g1
4000b898: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
4000b89c: 80 a0 60 00 cmp %g1, 0
4000b8a0: 32 bf ff ea bne,a 4000b848 <_Scheduler_CBS_Create_server+0x60><== ALWAYS TAKEN
4000b8a4: c4 06 00 00 ld [ %i0 ], %g2
4000b8a8: 30 bf ff f2 b,a 4000b870 <_Scheduler_CBS_Create_server+0x88><== NOT EXECUTED
4000b920 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
4000b920: 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);
4000b924: 90 10 00 19 mov %i1, %o0
4000b928: 40 00 03 61 call 4000c6ac <_Thread_Get>
4000b92c: 92 07 bf fc add %fp, -4, %o1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
4000b930: ba 92 20 00 orcc %o0, 0, %i5
4000b934: 02 80 00 05 be 4000b948 <_Scheduler_CBS_Detach_thread+0x28>
4000b938: 03 10 00 87 sethi %hi(0x40021c00), %g1
_Thread_Enable_dispatch();
4000b93c: 40 00 03 50 call 4000c67c <_Thread_Enable_dispatch>
4000b940: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000b944: 03 10 00 87 sethi %hi(0x40021c00), %g1
4000b948: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 40021e00 <_Scheduler_CBS_Maximum_servers>
4000b94c: 80 a6 00 01 cmp %i0, %g1
4000b950: 1a 80 00 1b bcc 4000b9bc <_Scheduler_CBS_Detach_thread+0x9c>
4000b954: 80 a7 60 00 cmp %i5, 0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
4000b958: 02 80 00 19 be 4000b9bc <_Scheduler_CBS_Detach_thread+0x9c>
4000b95c: 03 10 00 8c sethi %hi(0x40023000), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
4000b960: c2 00 61 08 ld [ %g1 + 0x108 ], %g1 ! 40023108 <_Scheduler_CBS_Server_list>
4000b964: b1 2e 20 02 sll %i0, 2, %i0
4000b968: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000b96c: 80 a0 60 00 cmp %g1, 0
4000b970: 02 80 00 11 be 4000b9b4 <_Scheduler_CBS_Detach_thread+0x94>
4000b974: 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 )
4000b978: c4 00 40 00 ld [ %g1 ], %g2
4000b97c: 80 a0 80 19 cmp %g2, %i1
4000b980: 12 80 00 0f bne 4000b9bc <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
4000b984: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
4000b988: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
4000b98c: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
4000b990: c0 20 60 18 clr [ %g1 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000b994: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
4000b998: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
4000b99c: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
4000b9a0: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000b9a4: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
4000b9a8: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
4000b9ac: 81 c7 e0 08 ret
4000b9b0: 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;
4000b9b4: 81 c7 e0 08 ret
4000b9b8: 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;
}
4000b9bc: 81 c7 e0 08 ret
4000b9c0: 91 e8 3f ee restore %g0, -18, %o0
4000bc4c <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
4000bc4c: 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*) );
4000bc50: 3b 10 00 87 sethi %hi(0x40021c00), %i5
4000bc54: d0 07 62 00 ld [ %i5 + 0x200 ], %o0 ! 40021e00 <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
4000bc58: 40 00 06 89 call 4000d67c <_Workspace_Allocate>
4000bc5c: 91 2a 20 02 sll %o0, 2, %o0
4000bc60: 05 10 00 8c sethi %hi(0x40023000), %g2
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
4000bc64: 80 a2 20 00 cmp %o0, 0
4000bc68: 02 80 00 0d be 4000bc9c <_Scheduler_CBS_Initialize+0x50> <== NEVER TAKEN
4000bc6c: d0 20 a1 08 st %o0, [ %g2 + 0x108 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000bc70: c6 07 62 00 ld [ %i5 + 0x200 ], %g3
4000bc74: 10 80 00 05 b 4000bc88 <_Scheduler_CBS_Initialize+0x3c>
4000bc78: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
4000bc7c: 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++) {
4000bc80: 82 00 60 01 inc %g1
_Scheduler_CBS_Server_list[i] = NULL;
4000bc84: 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++) {
4000bc88: 80 a0 40 03 cmp %g1, %g3
4000bc8c: 12 bf ff fc bne 4000bc7c <_Scheduler_CBS_Initialize+0x30>
4000bc90: fa 00 a1 08 ld [ %g2 + 0x108 ], %i5
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
4000bc94: 81 c7 e0 08 ret
4000bc98: 91 e8 20 00 restore %g0, 0, %o0
}
4000bc9c: 81 c7 e0 08 ret <== NOT EXECUTED
4000bca0: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
4000a8d0 <_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;
4000a8d0: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
4000a8d4: 80 a2 60 00 cmp %o1, 0
4000a8d8: 02 80 00 10 be 4000a918 <_Scheduler_CBS_Release_job+0x48>
4000a8dc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
4000a8e0: 80 a0 60 00 cmp %g1, 0
4000a8e4: 02 80 00 08 be 4000a904 <_Scheduler_CBS_Release_job+0x34>
4000a8e8: 05 10 00 84 sethi %hi(0x40021000), %g2
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
4000a8ec: d2 00 a1 68 ld [ %g2 + 0x168 ], %o1 ! 40021168 <_Watchdog_Ticks_since_boot>
4000a8f0: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000a8f4: 92 02 40 02 add %o1, %g2, %o1
4000a8f8: 05 20 00 00 sethi %hi(0x80000000), %g2
4000a8fc: 10 80 00 0a b 4000a924 <_Scheduler_CBS_Release_job+0x54>
4000a900: 92 2a 40 02 andn %o1, %g2, %o1
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
4000a904: c2 00 a1 68 ld [ %g2 + 0x168 ], %g1
4000a908: 92 02 40 01 add %o1, %g1, %o1
4000a90c: 03 20 00 00 sethi %hi(0x80000000), %g1
4000a910: 10 80 00 07 b 4000a92c <_Scheduler_CBS_Release_job+0x5c>
4000a914: 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)
4000a918: 80 a0 60 00 cmp %g1, 0
4000a91c: 02 80 00 04 be 4000a92c <_Scheduler_CBS_Release_job+0x5c> <== NEVER TAKEN
4000a920: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
4000a924: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000a928: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
4000a92c: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
4000a930: 94 10 20 01 mov 1, %o2
4000a934: 82 13 c0 00 mov %o7, %g1
4000a938: 40 00 01 26 call 4000add0 <_Thread_Change_priority>
4000a93c: 9e 10 40 00 mov %g1, %o7
4000a940 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
4000a940: 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);
4000a944: 40 00 00 4c call 4000aa74 <_Scheduler_EDF_Enqueue>
4000a948: 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;
4000a94c: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
4000a950: 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) {
4000a954: 80 a7 60 00 cmp %i5, 0
4000a958: 02 80 00 18 be 4000a9b8 <_Scheduler_CBS_Unblock+0x78>
4000a95c: 03 10 00 84 sethi %hi(0x40021000), %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 ) {
4000a960: 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 -
4000a964: d0 00 61 68 ld [ %g1 + 0x168 ], %o0
4000a968: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
4000a96c: 40 00 3e fa call 4001a554 <.umul>
4000a970: 90 27 00 08 sub %i4, %o0, %o0
4000a974: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
4000a978: b6 10 00 08 mov %o0, %i3
4000a97c: 40 00 3e f6 call 4001a554 <.umul>
4000a980: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000a984: 80 a6 c0 08 cmp %i3, %o0
4000a988: 24 80 00 0d ble,a 4000a9bc <_Scheduler_CBS_Unblock+0x7c>
4000a98c: 3b 10 00 85 sethi %hi(0x40021400), %i5
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
4000a990: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000a994: 80 a7 00 09 cmp %i4, %o1
4000a998: 32 80 00 02 bne,a 4000a9a0 <_Scheduler_CBS_Unblock+0x60>
4000a99c: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
4000a9a0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000a9a4: 80 a0 40 09 cmp %g1, %o1
4000a9a8: 02 80 00 04 be 4000a9b8 <_Scheduler_CBS_Unblock+0x78>
4000a9ac: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
4000a9b0: 40 00 01 08 call 4000add0 <_Thread_Change_priority>
4000a9b4: 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,
4000a9b8: 3b 10 00 85 sethi %hi(0x40021400), %i5
4000a9bc: ba 17 61 90 or %i5, 0x190, %i5 ! 40021590 <_Per_CPU_Information>
4000a9c0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4000a9c4: 03 10 00 80 sethi %hi(0x40020000), %g1
4000a9c8: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
4000a9cc: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1
4000a9d0: 9f c0 40 00 call %g1
4000a9d4: d2 00 a0 14 ld [ %g2 + 0x14 ], %o1
4000a9d8: 80 a2 20 00 cmp %o0, 0
4000a9dc: 04 80 00 0f ble 4000aa18 <_Scheduler_CBS_Unblock+0xd8>
4000a9e0: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
4000a9e4: 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;
4000a9e8: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
4000a9ec: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
4000a9f0: 80 a0 60 00 cmp %g1, 0
4000a9f4: 12 80 00 06 bne 4000aa0c <_Scheduler_CBS_Unblock+0xcc>
4000a9f8: 84 10 20 01 mov 1, %g2
4000a9fc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000aa00: 80 a0 60 00 cmp %g1, 0
4000aa04: 12 80 00 05 bne 4000aa18 <_Scheduler_CBS_Unblock+0xd8> <== ALWAYS TAKEN
4000aa08: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000aa0c: 03 10 00 85 sethi %hi(0x40021400), %g1
4000aa10: 82 10 61 90 or %g1, 0x190, %g1 ! 40021590 <_Per_CPU_Information>
4000aa14: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
4000aa18: 81 c7 e0 08 ret
4000aa1c: 81 e8 00 00 restore
4000a8a0 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
4000a8a0: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
4000a8a4: 40 00 06 62 call 4000c22c <_Workspace_Allocate>
4000a8a8: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
4000a8ac: 80 a2 20 00 cmp %o0, 0
4000a8b0: 02 80 00 05 be 4000a8c4 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
4000a8b4: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
4000a8b8: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
4000a8bc: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
4000a8c0: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
4000a8c4: 81 c7 e0 08 ret
4000a8c8: 91 e8 00 08 restore %g0, %o0, %o0
4000aa68 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
4000aa68: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
4000aa6c: 7f ff ff ad call 4000a920 <_Scheduler_EDF_Enqueue>
4000aa70: 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(
4000aa74: 3b 10 00 85 sethi %hi(0x40021400), %i5
4000aa78: ba 17 60 e0 or %i5, 0xe0, %i5 ! 400214e0 <_Per_CPU_Information>
4000aa7c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4000aa80: 03 10 00 80 sethi %hi(0x40020000), %g1
4000aa84: d0 00 a0 14 ld [ %g2 + 0x14 ], %o0
4000aa88: c2 00 62 34 ld [ %g1 + 0x234 ], %g1
4000aa8c: 9f c0 40 00 call %g1
4000aa90: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
4000aa94: 80 a2 20 00 cmp %o0, 0
4000aa98: 16 80 00 0f bge 4000aad4 <_Scheduler_EDF_Unblock+0x6c>
4000aa9c: 01 00 00 00 nop
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
4000aaa0: 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;
4000aaa4: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
4000aaa8: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
4000aaac: 80 a0 60 00 cmp %g1, 0
4000aab0: 12 80 00 06 bne 4000aac8 <_Scheduler_EDF_Unblock+0x60>
4000aab4: 84 10 20 01 mov 1, %g2
4000aab8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000aabc: 80 a0 60 00 cmp %g1, 0
4000aac0: 12 80 00 05 bne 4000aad4 <_Scheduler_EDF_Unblock+0x6c> <== ALWAYS TAKEN
4000aac4: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000aac8: 03 10 00 85 sethi %hi(0x40021400), %g1
4000aacc: 82 10 60 e0 or %g1, 0xe0, %g1 ! 400214e0 <_Per_CPU_Information>
4000aad0: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
4000aad4: 81 c7 e0 08 ret
4000aad8: 81 e8 00 00 restore
4000a174 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
4000a174: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing;
executing = _Thread_Executing;
4000a178: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000a17c: fa 00 61 a0 ld [ %g1 + 0x1a0 ], %i5 ! 4001f9a0 <_Per_CPU_Information+0x10>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
4000a180: c2 0f 60 70 ldub [ %i5 + 0x70 ], %g1
4000a184: 80 a0 60 00 cmp %g1, 0
4000a188: 02 80 00 25 be 4000a21c <_Scheduler_priority_Tick+0xa8>
4000a18c: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
4000a190: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000a194: 80 a0 60 00 cmp %g1, 0
4000a198: 12 80 00 21 bne 4000a21c <_Scheduler_priority_Tick+0xa8>
4000a19c: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
4000a1a0: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
4000a1a4: 80 a0 60 01 cmp %g1, 1
4000a1a8: 0a 80 00 14 bcs 4000a1f8 <_Scheduler_priority_Tick+0x84>
4000a1ac: 80 a0 60 02 cmp %g1, 2
4000a1b0: 28 80 00 07 bleu,a 4000a1cc <_Scheduler_priority_Tick+0x58>
4000a1b4: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
4000a1b8: 80 a0 60 03 cmp %g1, 3
4000a1bc: 12 80 00 18 bne 4000a21c <_Scheduler_priority_Tick+0xa8> <== NEVER TAKEN
4000a1c0: 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 )
4000a1c4: 10 80 00 0f b 4000a200 <_Scheduler_priority_Tick+0x8c>
4000a1c8: 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 ) {
4000a1cc: 82 00 7f ff add %g1, -1, %g1
4000a1d0: 80 a0 60 00 cmp %g1, 0
4000a1d4: 14 80 00 09 bg 4000a1f8 <_Scheduler_priority_Tick+0x84>
4000a1d8: 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();
4000a1dc: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000a1e0: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 4001e740 <_Scheduler+0xc>
4000a1e4: 9f c0 40 00 call %g1
4000a1e8: 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;
4000a1ec: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000a1f0: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 4001f3e0 <_Thread_Ticks_per_timeslice>
4000a1f4: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
4000a1f8: 81 c7 e0 08 ret
4000a1fc: 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 )
4000a200: 82 00 7f ff add %g1, -1, %g1
4000a204: 80 a0 60 00 cmp %g1, 0
4000a208: 12 bf ff fc bne 4000a1f8 <_Scheduler_priority_Tick+0x84>
4000a20c: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*executing->budget_callout)( executing );
4000a210: c2 07 60 7c ld [ %i5 + 0x7c ], %g1
4000a214: 9f c0 40 00 call %g1
4000a218: 90 10 00 1d mov %i5, %o0
4000a21c: 81 c7 e0 08 ret
4000a220: 81 e8 00 00 restore
40008db4 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
40008db4: 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 /
40008db8: 03 10 00 7a sethi %hi(0x4001e800), %g1
40008dbc: d2 00 62 5c ld [ %g1 + 0x25c ], %o1 ! 4001ea5c <Configuration+0xc>
40008dc0: 11 00 03 d0 sethi %hi(0xf4000), %o0
40008dc4: 40 00 48 2b call 4001ae70 <.udiv>
40008dc8: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
40008dcc: 80 a6 20 00 cmp %i0, 0
40008dd0: 02 80 00 28 be 40008e70 <_TOD_Validate+0xbc> <== NEVER TAKEN
40008dd4: 84 10 20 00 clr %g2
40008dd8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40008ddc: 80 a0 40 08 cmp %g1, %o0
40008de0: 3a 80 00 25 bcc,a 40008e74 <_TOD_Validate+0xc0>
40008de4: b0 08 a0 01 and %g2, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
40008de8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40008dec: 80 a0 60 3b cmp %g1, 0x3b
40008df0: 38 80 00 21 bgu,a 40008e74 <_TOD_Validate+0xc0>
40008df4: b0 08 a0 01 and %g2, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
40008df8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40008dfc: 80 a0 60 3b cmp %g1, 0x3b
40008e00: 38 80 00 1d bgu,a 40008e74 <_TOD_Validate+0xc0>
40008e04: b0 08 a0 01 and %g2, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
40008e08: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40008e0c: 80 a0 60 17 cmp %g1, 0x17
40008e10: 38 80 00 19 bgu,a 40008e74 <_TOD_Validate+0xc0>
40008e14: b0 08 a0 01 and %g2, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
40008e18: 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) ||
40008e1c: 80 a0 60 00 cmp %g1, 0
40008e20: 02 80 00 14 be 40008e70 <_TOD_Validate+0xbc> <== NEVER TAKEN
40008e24: 80 a0 60 0c cmp %g1, 0xc
(the_tod->month == 0) ||
40008e28: 38 80 00 13 bgu,a 40008e74 <_TOD_Validate+0xc0>
40008e2c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
40008e30: 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) ||
40008e34: 80 a1 27 c3 cmp %g4, 0x7c3
40008e38: 28 80 00 0f bleu,a 40008e74 <_TOD_Validate+0xc0>
40008e3c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
40008e40: 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) ||
40008e44: 80 a0 e0 00 cmp %g3, 0
40008e48: 02 80 00 0a be 40008e70 <_TOD_Validate+0xbc> <== NEVER TAKEN
40008e4c: 80 89 20 03 btst 3, %g4
40008e50: 05 10 00 7e sethi %hi(0x4001f800), %g2
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
40008e54: 12 80 00 03 bne 40008e60 <_TOD_Validate+0xac>
40008e58: 84 10 a3 58 or %g2, 0x358, %g2 ! 4001fb58 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
40008e5c: 82 00 60 0d add %g1, 0xd, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
40008e60: 83 28 60 02 sll %g1, 2, %g1
40008e64: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
40008e68: 80 a0 40 03 cmp %g1, %g3
40008e6c: 84 60 3f ff subx %g0, -1, %g2
return false;
return true;
}
40008e70: b0 08 a0 01 and %g2, 1, %i0
40008e74: 81 c7 e0 08 ret
40008e78: 81 e8 00 00 restore
4000a430 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
4000a430: 9d e3 bf a0 save %sp, -96, %sp
4000a434: ba 10 00 18 mov %i0, %i5
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
4000a438: 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 );
4000a43c: 40 00 03 51 call 4000b180 <_Thread_Set_transient>
4000a440: 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 )
4000a444: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000a448: 80 a0 40 19 cmp %g1, %i1
4000a44c: 02 80 00 04 be 4000a45c <_Thread_Change_priority+0x2c>
4000a450: 90 10 00 1d mov %i5, %o0
_Thread_Set_priority( the_thread, new_priority );
4000a454: 40 00 03 32 call 4000b11c <_Thread_Set_priority>
4000a458: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
4000a45c: 7f ff df fb call 40002448 <sparc_disable_interrupts>
4000a460: 01 00 00 00 nop
4000a464: 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;
4000a468: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
4000a46c: 80 a7 20 04 cmp %i4, 4
4000a470: 02 80 00 10 be 4000a4b0 <_Thread_Change_priority+0x80>
4000a474: 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 ) )
4000a478: 80 a0 60 00 cmp %g1, 0
4000a47c: 12 80 00 03 bne 4000a488 <_Thread_Change_priority+0x58> <== NEVER TAKEN
4000a480: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
4000a484: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
4000a488: 7f ff df f4 call 40002458 <sparc_enable_interrupts>
4000a48c: 90 10 00 1b mov %i3, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
4000a490: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000a494: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
4000a498: 80 8f 00 01 btst %i4, %g1
4000a49c: 02 80 00 27 be 4000a538 <_Thread_Change_priority+0x108>
4000a4a0: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
4000a4a4: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
4000a4a8: 40 00 02 f0 call 4000b068 <_Thread_queue_Requeue>
4000a4ac: 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 ) ) {
4000a4b0: 80 a0 60 00 cmp %g1, 0
4000a4b4: 12 80 00 0b bne 4000a4e0 <_Thread_Change_priority+0xb0> <== NEVER TAKEN
4000a4b8: 03 10 00 79 sethi %hi(0x4001e400), %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 );
4000a4bc: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( prepend_it )
4000a4c0: 80 a6 a0 00 cmp %i2, 0
4000a4c4: 02 80 00 04 be 4000a4d4 <_Thread_Change_priority+0xa4>
4000a4c8: 82 10 63 34 or %g1, 0x334, %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
4000a4cc: 10 80 00 03 b 4000a4d8 <_Thread_Change_priority+0xa8>
4000a4d0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
4000a4d4: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
4000a4d8: 9f c0 40 00 call %g1
4000a4dc: 90 10 00 1d mov %i5, %o0
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
4000a4e0: 7f ff df de call 40002458 <sparc_enable_interrupts>
4000a4e4: 90 10 00 1b mov %i3, %o0
4000a4e8: 7f ff df d8 call 40002448 <sparc_disable_interrupts>
4000a4ec: 01 00 00 00 nop
4000a4f0: 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();
4000a4f4: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000a4f8: c2 00 63 3c ld [ %g1 + 0x33c ], %g1 ! 4001e73c <_Scheduler+0x8>
4000a4fc: 9f c0 40 00 call %g1
4000a500: 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 );
4000a504: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000a508: 82 10 61 90 or %g1, 0x190, %g1 ! 4001f990 <_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() &&
4000a50c: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
4000a510: 80 a0 80 03 cmp %g2, %g3
4000a514: 02 80 00 07 be 4000a530 <_Thread_Change_priority+0x100>
4000a518: 01 00 00 00 nop
4000a51c: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
4000a520: 80 a0 a0 00 cmp %g2, 0
4000a524: 02 80 00 03 be 4000a530 <_Thread_Change_priority+0x100>
4000a528: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
4000a52c: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
_ISR_Enable( level );
4000a530: 7f ff df ca call 40002458 <sparc_enable_interrupts>
4000a534: 81 e8 00 00 restore
4000a538: 81 c7 e0 08 ret
4000a53c: 81 e8 00 00 restore
4000a700 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4000a700: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000a704: 90 10 00 18 mov %i0, %o0
4000a708: 40 00 00 70 call 4000a8c8 <_Thread_Get>
4000a70c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000a710: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a714: 80 a0 60 00 cmp %g1, 0
4000a718: 12 80 00 08 bne 4000a738 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
4000a71c: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
4000a720: 7f ff ff 88 call 4000a540 <_Thread_Clear_state>
4000a724: 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;
4000a728: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000a72c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 4001f480 <_Thread_Dispatch_disable_level>
--level;
4000a730: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000a734: c4 20 60 80 st %g2, [ %g1 + 0x80 ]
4000a738: 81 c7 e0 08 ret
4000a73c: 81 e8 00 00 restore
4000a740 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
4000a740: 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;
4000a744: 35 10 00 7e sethi %hi(0x4001f800), %i2
4000a748: 82 16 a1 90 or %i2, 0x190, %g1 ! 4001f990 <_Per_CPU_Information>
_ISR_Disable( level );
4000a74c: 7f ff df 3f call 40002448 <sparc_disable_interrupts>
4000a750: f6 00 60 10 ld [ %g1 + 0x10 ], %i3
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
4000a754: 21 10 00 7c sethi %hi(0x4001f000), %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 ) {
4000a758: 27 10 00 7a sethi %hi(0x4001e800), %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;
4000a75c: 33 10 00 7d sethi %hi(0x4001f400), %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;
4000a760: 31 10 00 7c sethi %hi(0x4001f000), %i0
4000a764: a0 14 23 d0 or %l0, 0x3d0, %l0
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
4000a768: 23 10 00 7d sethi %hi(0x4001f400), %l1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000a76c: 25 10 00 7a sethi %hi(0x4001e800), %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 ) {
4000a770: 10 80 00 3b b 4000a85c <_Thread_Dispatch+0x11c>
4000a774: a6 14 e0 64 or %l3, 0x64, %l3
4000a778: 84 10 20 01 mov 1, %g2
4000a77c: c4 26 60 80 st %g2, [ %i1 + 0x80 ]
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
4000a780: 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 )
4000a784: 80 a5 00 1b cmp %l4, %i3
4000a788: 12 80 00 0a bne 4000a7b0 <_Thread_Dispatch+0x70>
4000a78c: e8 20 60 10 st %l4, [ %g1 + 0x10 ]
4000a790: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000a794: c0 20 60 80 clr [ %g1 + 0x80 ] ! 4001f480 <_Thread_Dispatch_disable_level>
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
4000a798: 7f ff df 30 call 40002458 <sparc_enable_interrupts>
4000a79c: 39 10 00 7d sethi %hi(0x4001f400), %i4
4000a7a0: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000a7a4: fa 00 60 f0 ld [ %g1 + 0xf0 ], %i5 ! 4001f4f0 <_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 ) {
4000a7a8: 10 80 00 37 b 4000a884 <_Thread_Dispatch+0x144>
4000a7ac: b8 17 20 f4 or %i4, 0xf4, %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 )
4000a7b0: c2 05 20 78 ld [ %l4 + 0x78 ], %g1
4000a7b4: 80 a0 60 01 cmp %g1, 1
4000a7b8: 12 80 00 03 bne 4000a7c4 <_Thread_Dispatch+0x84>
4000a7bc: c2 06 23 e0 ld [ %i0 + 0x3e0 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000a7c0: c2 25 20 74 st %g1, [ %l4 + 0x74 ]
_ISR_Enable( level );
4000a7c4: 7f ff df 25 call 40002458 <sparc_enable_interrupts>
4000a7c8: 01 00 00 00 nop
4000a7cc: 90 07 bf f8 add %fp, -8, %o0
4000a7d0: 7f ff f9 e0 call 40008f50 <_TOD_Get_with_nanoseconds>
4000a7d4: 92 10 00 10 mov %l0, %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
4000a7d8: c4 1f bf f8 ldd [ %fp + -8 ], %g2
4000a7dc: 82 16 a1 90 or %i2, 0x190, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4000a7e0: f8 18 60 20 ldd [ %g1 + 0x20 ], %i4
4000a7e4: 96 a0 c0 1d subcc %g3, %i5, %o3
4000a7e8: 94 60 80 1c subx %g2, %i4, %o2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
4000a7ec: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
4000a7f0: 9a 87 40 0b addcc %i5, %o3, %o5
4000a7f4: 98 47 00 0a addx %i4, %o2, %o4
4000a7f8: 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;
4000a7fc: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
4000a800: c2 04 60 ec ld [ %l1 + 0xec ], %g1
4000a804: 80 a0 60 00 cmp %g1, 0
4000a808: 22 80 00 0c be,a 4000a838 <_Thread_Dispatch+0xf8> <== NEVER TAKEN
4000a80c: fa 04 a0 60 ld [ %l2 + 0x60 ], %i5 <== NOT EXECUTED
executing->libc_reent = *_Thread_libc_reent;
4000a810: c4 00 40 00 ld [ %g1 ], %g2
4000a814: c4 26 e1 48 st %g2, [ %i3 + 0x148 ]
*_Thread_libc_reent = heir->libc_reent;
4000a818: c4 05 21 48 ld [ %l4 + 0x148 ], %g2
4000a81c: c4 20 40 00 st %g2, [ %g1 ]
4000a820: 10 80 00 06 b 4000a838 <_Thread_Dispatch+0xf8>
4000a824: fa 04 a0 60 ld [ %l2 + 0x60 ], %i5
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
4000a828: 90 10 00 1b mov %i3, %o0
4000a82c: 9f c0 40 00 call %g1
4000a830: 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;
4000a834: 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 ) {
4000a838: 80 a7 40 13 cmp %i5, %l3
4000a83c: 32 bf ff fb bne,a 4000a828 <_Thread_Dispatch+0xe8>
4000a840: 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 );
4000a844: 90 06 e0 c0 add %i3, 0xc0, %o0
4000a848: 40 00 04 30 call 4000b908 <_CPU_Context_switch>
4000a84c: 92 05 20 c0 add %l4, 0xc0, %o1
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
4000a850: 82 16 a1 90 or %i2, 0x190, %g1
_ISR_Disable( level );
4000a854: 7f ff de fd call 40002448 <sparc_disable_interrupts>
4000a858: 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 ) {
4000a85c: 82 16 a1 90 or %i2, 0x190, %g1
4000a860: c4 08 60 0c ldub [ %g1 + 0xc ], %g2
4000a864: 80 a0 a0 00 cmp %g2, 0
4000a868: 32 bf ff c4 bne,a 4000a778 <_Thread_Dispatch+0x38>
4000a86c: e8 00 60 14 ld [ %g1 + 0x14 ], %l4
4000a870: 10 bf ff c9 b 4000a794 <_Thread_Dispatch+0x54>
4000a874: 03 10 00 7d sethi %hi(0x4001f400), %g1
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
4000a878: 9f c0 40 00 call %g1
4000a87c: 90 10 00 1b mov %i3, %o0
4000a880: 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 ) {
4000a884: 80 a7 40 1c cmp %i5, %i4
4000a888: 32 bf ff fc bne,a 4000a878 <_Thread_Dispatch+0x138>
4000a88c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
4000a890: 81 c7 e0 08 ret
4000a894: 81 e8 00 00 restore
4000f8c0 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
4000f8c0: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
4000f8c4: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000f8c8: fa 00 61 a0 ld [ %g1 + 0x1a0 ], %i5 ! 4001f9a0 <_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();
4000f8cc: 3f 10 00 3e sethi %hi(0x4000f800), %i7
4000f8d0: be 17 e0 c0 or %i7, 0xc0, %i7 ! 4000f8c0 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4000f8d4: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
4000f8d8: 7f ff ca e0 call 40002458 <sparc_enable_interrupts>
4000f8dc: 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;
4000f8e0: 03 10 00 7c sethi %hi(0x4001f000), %g1
doneConstructors = true;
4000f8e4: 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;
4000f8e8: f8 08 60 10 ldub [ %g1 + 0x10 ], %i4
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
4000f8ec: 90 10 00 1d mov %i5, %o0
4000f8f0: 13 10 00 2c sethi %hi(0x4000b000), %o1
4000f8f4: 92 12 63 60 or %o1, 0x360, %o1 ! 4000b360 <_User_extensions_Thread_begin_visitor>
4000f8f8: 7f ff ee b7 call 4000b3d4 <_User_extensions_Iterate>
4000f8fc: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4000f900: 7f ff eb e6 call 4000a898 <_Thread_Enable_dispatch>
4000f904: 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) */ {
4000f908: 80 8f 20 ff btst 0xff, %i4
4000f90c: 32 80 00 05 bne,a 4000f920 <_Thread_Handler+0x60>
4000f910: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
INIT_NAME ();
4000f914: 40 00 3b 55 call 4001e668 <_init>
4000f918: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4000f91c: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
4000f920: 80 a0 60 00 cmp %g1, 0
4000f924: 12 80 00 05 bne 4000f938 <_Thread_Handler+0x78>
4000f928: 80 a0 60 01 cmp %g1, 1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4000f92c: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
4000f930: 10 80 00 06 b 4000f948 <_Thread_Handler+0x88>
4000f934: 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 ) {
4000f938: 12 80 00 08 bne 4000f958 <_Thread_Handler+0x98> <== NEVER TAKEN
4000f93c: 90 10 00 1d mov %i5, %o0
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
4000f940: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
4000f944: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
4000f948: 9f c0 40 00 call %g1
4000f94c: 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 =
4000f950: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
4000f954: 90 10 00 1d mov %i5, %o0
4000f958: 13 10 00 2c sethi %hi(0x4000b000), %o1
4000f95c: 7f ff ee 9e call 4000b3d4 <_User_extensions_Iterate>
4000f960: 92 12 63 84 or %o1, 0x384, %o1 ! 4000b384 <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
4000f964: 90 10 20 00 clr %o0
4000f968: 92 10 20 01 mov 1, %o1
4000f96c: 7f ff e6 ad call 40009420 <_Internal_error_Occurred>
4000f970: 94 10 20 05 mov 5, %o2
4000ab50 <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
4000ab50: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
4000ab54: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000ab58: 82 10 63 d8 or %g1, 0x3d8, %g1 ! 4001c7d8 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000ab5c: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
4000ab60: fa 00 60 14 ld [ %g1 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
4000ab64: 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 ||
4000ab68: 80 a0 e0 00 cmp %g3, 0
4000ab6c: 02 80 00 06 be 4000ab84 <_Thread_Handler_initialization+0x34><== NEVER TAKEN
4000ab70: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000ab74: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
4000ab78: 80 a0 e0 00 cmp %g3, 0
4000ab7c: 12 80 00 06 bne 4000ab94 <_Thread_Handler_initialization+0x44>
4000ab80: 80 a0 a0 00 cmp %g2, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
4000ab84: 90 10 20 00 clr %o0
4000ab88: 92 10 20 01 mov 1, %o1
4000ab8c: 7f ff fa 25 call 40009420 <_Internal_error_Occurred>
4000ab90: 94 10 20 0e mov 0xe, %o2
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
4000ab94: 22 80 00 05 be,a 4000aba8 <_Thread_Handler_initialization+0x58>
4000ab98: 03 10 00 7e sethi %hi(0x4001f800), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000ab9c: 9f c0 80 00 call %g2
4000aba0: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 4001f804 <_POSIX_Barrier_Information>
_Thread_Dispatch_necessary = false;
4000aba4: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000aba8: 82 10 61 90 or %g1, 0x190, %g1 ! 4001f990 <_Per_CPU_Information>
4000abac: c0 28 60 0c clrb [ %g1 + 0xc ]
_Thread_Executing = NULL;
4000abb0: c0 20 60 10 clr [ %g1 + 0x10 ]
_Thread_Heir = NULL;
4000abb4: 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;
4000abb8: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000abbc: f8 20 60 fc st %i4, [ %g1 + 0xfc ] ! 4001f4fc <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
4000abc0: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000abc4: fa 20 63 e0 st %i5, [ %g1 + 0x3e0 ] ! 4001f3e0 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
4000abc8: 82 10 20 08 mov 8, %g1
4000abcc: 11 10 00 7d sethi %hi(0x4001f400), %o0
4000abd0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000abd4: 90 12 21 70 or %o0, 0x170, %o0
4000abd8: 92 10 20 01 mov 1, %o1
4000abdc: 94 10 20 01 mov 1, %o2
4000abe0: 96 10 20 01 mov 1, %o3
4000abe4: 98 10 21 60 mov 0x160, %o4
4000abe8: 7f ff fb 9e call 40009a60 <_Objects_Initialize_information>
4000abec: 9a 10 20 00 clr %o5
4000abf0: 81 c7 e0 08 ret
4000abf4: 81 e8 00 00 restore
4000a978 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
4000a978: 9d e3 bf 98 save %sp, -104, %sp
4000a97c: 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;
4000a980: c0 26 61 4c clr [ %i1 + 0x14c ]
4000a984: c0 26 61 50 clr [ %i1 + 0x150 ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
4000a988: 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
)
{
4000a98c: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
4000a990: 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 ) {
4000a994: 80 a6 a0 00 cmp %i2, 0
4000a998: 12 80 00 0d bne 4000a9cc <_Thread_Initialize+0x54>
4000a99c: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
4000a9a0: 90 10 00 19 mov %i1, %o0
4000a9a4: 40 00 02 06 call 4000b1bc <_Thread_Stack_Allocate>
4000a9a8: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
4000a9ac: 80 a2 00 1b cmp %o0, %i3
4000a9b0: 0a 80 00 64 bcs 4000ab40 <_Thread_Initialize+0x1c8>
4000a9b4: 80 a2 20 00 cmp %o0, 0
4000a9b8: 02 80 00 62 be 4000ab40 <_Thread_Initialize+0x1c8> <== NEVER TAKEN
4000a9bc: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
4000a9c0: f4 06 60 bc ld [ %i1 + 0xbc ], %i2
the_thread->Start.core_allocated_stack = true;
4000a9c4: 10 80 00 04 b 4000a9d4 <_Thread_Initialize+0x5c>
4000a9c8: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
4000a9cc: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
4000a9d0: 90 10 00 1b mov %i3, %o0
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
the_stack->size = size;
4000a9d4: d0 26 60 b4 st %o0, [ %i1 + 0xb4 ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
4000a9d8: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000a9dc: d0 00 60 fc ld [ %g1 + 0xfc ], %o0 ! 4001f4fc <_Thread_Maximum_extensions>
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
4000a9e0: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4000a9e4: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
4000a9e8: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
4000a9ec: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
4000a9f0: c0 26 60 6c clr [ %i1 + 0x6c ]
4000a9f4: 80 a2 20 00 cmp %o0, 0
4000a9f8: 02 80 00 08 be 4000aa18 <_Thread_Initialize+0xa0>
4000a9fc: b8 10 20 00 clr %i4
extensions_area = _Workspace_Allocate(
4000aa00: 90 02 20 01 inc %o0
4000aa04: 40 00 03 a5 call 4000b898 <_Workspace_Allocate>
4000aa08: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
4000aa0c: b8 92 20 00 orcc %o0, 0, %i4
4000aa10: 02 80 00 40 be 4000ab10 <_Thread_Initialize+0x198>
4000aa14: 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 ) {
4000aa18: 80 a7 20 00 cmp %i4, 0
4000aa1c: 12 80 00 0a bne 4000aa44 <_Thread_Initialize+0xcc>
4000aa20: 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;
4000aa24: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
4000aa28: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
4000aa2c: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
4000aa30: 80 a4 20 02 cmp %l0, 2
4000aa34: 12 80 00 12 bne 4000aa7c <_Thread_Initialize+0x104>
4000aa38: 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;
4000aa3c: 10 80 00 0e b 4000aa74 <_Thread_Initialize+0xfc>
4000aa40: 03 10 00 7c sethi %hi(0x4001f000), %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++ )
4000aa44: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000aa48: c4 00 60 fc ld [ %g1 + 0xfc ], %g2 ! 4001f4fc <_Thread_Maximum_extensions>
4000aa4c: 10 80 00 05 b 4000aa60 <_Thread_Initialize+0xe8>
4000aa50: 82 10 20 00 clr %g1
the_thread->extensions[i] = NULL;
4000aa54: 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++ )
4000aa58: 82 00 60 01 inc %g1
the_thread->extensions[i] = NULL;
4000aa5c: 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++ )
4000aa60: 80 a0 40 02 cmp %g1, %g2
4000aa64: 28 bf ff fc bleu,a 4000aa54 <_Thread_Initialize+0xdc>
4000aa68: 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;
4000aa6c: 10 bf ff ef b 4000aa28 <_Thread_Initialize+0xb0>
4000aa70: 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;
4000aa74: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1
4000aa78: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
4000aa7c: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->current_state = STATES_DORMANT;
4000aa80: b4 10 20 01 mov 1, %i2
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
4000aa84: c2 26 60 a8 st %g1, [ %i1 + 0xa8 ]
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
4000aa88: 03 10 00 79 sethi %hi(0x4001e400), %g1
4000aa8c: c2 00 63 4c ld [ %g1 + 0x34c ], %g1 ! 4001e74c <_Scheduler+0x18>
the_thread->current_state = STATES_DORMANT;
4000aa90: f4 26 60 10 st %i2, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
4000aa94: c0 26 60 44 clr [ %i1 + 0x44 ]
the_thread->resource_count = 0;
4000aa98: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
4000aa9c: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
4000aaa0: fa 26 60 ac st %i5, [ %i1 + 0xac ]
4000aaa4: 9f c0 40 00 call %g1
4000aaa8: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
4000aaac: b6 92 20 00 orcc %o0, 0, %i3
4000aab0: 02 80 00 18 be 4000ab10 <_Thread_Initialize+0x198>
4000aab4: 90 10 00 19 mov %i1, %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
4000aab8: 40 00 01 99 call 4000b11c <_Thread_Set_priority>
4000aabc: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000aac0: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
4000aac4: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
4000aac8: c0 26 60 80 clr [ %i1 + 0x80 ]
4000aacc: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000aad0: 83 28 60 02 sll %g1, 2, %g1
4000aad4: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000aad8: 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 };
4000aadc: f2 27 bf f8 st %i1, [ %fp + -8 ]
4000aae0: f4 2f bf fc stb %i2, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
4000aae4: 90 07 bf f8 add %fp, -8, %o0
4000aae8: 13 10 00 2c sethi %hi(0x4000b000), %o1
4000aaec: 40 00 02 3a call 4000b3d4 <_User_extensions_Iterate>
4000aaf0: 92 12 62 b0 or %o1, 0x2b0, %o1 ! 4000b2b0 <_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 )
4000aaf4: c2 0f bf fc ldub [ %fp + -4 ], %g1
4000aaf8: 80 a0 60 00 cmp %g1, 0
4000aafc: 02 80 00 05 be 4000ab10 <_Thread_Initialize+0x198>
4000ab00: b0 10 20 01 mov 1, %i0
4000ab04: b0 0e 20 01 and %i0, 1, %i0
4000ab08: 81 c7 e0 08 ret
4000ab0c: 81 e8 00 00 restore
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
4000ab10: 40 00 03 6a call 4000b8b8 <_Workspace_Free>
4000ab14: d0 06 61 48 ld [ %i1 + 0x148 ], %o0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
4000ab18: 40 00 03 68 call 4000b8b8 <_Workspace_Free>
4000ab1c: d0 06 61 4c ld [ %i1 + 0x14c ], %o0
4000ab20: 40 00 03 66 call 4000b8b8 <_Workspace_Free>
4000ab24: d0 06 61 50 ld [ %i1 + 0x150 ], %o0
_Workspace_Free( extensions_area );
4000ab28: 40 00 03 64 call 4000b8b8 <_Workspace_Free>
4000ab2c: 90 10 00 1c mov %i4, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
#endif
_Workspace_Free( sched );
4000ab30: 40 00 03 62 call 4000b8b8 <_Workspace_Free>
4000ab34: 90 10 00 1b mov %i3, %o0
_Thread_Stack_Free( the_thread );
4000ab38: 40 00 01 b1 call 4000b1fc <_Thread_Stack_Free>
4000ab3c: 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 */
4000ab40: b0 10 20 00 clr %i0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
4000ab44: b0 0e 20 01 and %i0, 1, %i0
4000ab48: 81 c7 e0 08 ret
4000ab4c: 81 e8 00 00 restore
4000b1fc <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000b1fc: 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 )
4000b200: c4 0e 20 b0 ldub [ %i0 + 0xb0 ], %g2
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
4000b204: 03 10 00 72 sethi %hi(0x4001c800), %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 )
4000b208: 80 a0 a0 00 cmp %g2, 0
4000b20c: 02 80 00 04 be 4000b21c <_Thread_Stack_Free+0x20> <== NEVER TAKEN
4000b210: c2 00 60 04 ld [ %g1 + 4 ], %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 );
4000b214: 9f c0 40 00 call %g1
4000b218: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
4000b21c: 81 c7 e0 08 ret
4000b220: 81 e8 00 00 restore
4000f978 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4000f978: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
4000f97c: 7f ff ca b3 call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
4000f980: 01 00 00 00 nop <== NOT EXECUTED
4000f984: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000f988: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000f98c: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
4000f990: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
4000f994: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
4000f998: 32 80 00 04 bne,a 4000f9a8 <_Thread_queue_Extract_fifo+0x30><== NOT EXECUTED
4000f99c: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED
_ISR_Enable( level );
4000f9a0: 7f ff ca ae call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
4000f9a4: 81 e8 00 00 restore <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000f9a8: c4 06 40 00 ld [ %i1 ], %g2 <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
4000f9ac: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000f9b0: 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 ) ) {
4000f9b4: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED
4000f9b8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
4000f9bc: 02 80 00 06 be 4000f9d4 <_Thread_queue_Extract_fifo+0x5c> <== NOT EXECUTED
4000f9c0: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED
_ISR_Enable( level );
4000f9c4: 7f ff ca a5 call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
4000f9c8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
4000f9cc: 10 80 00 09 b 4000f9f0 <_Thread_queue_Extract_fifo+0x78> <== NOT EXECUTED
4000f9d0: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
4000f9d4: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
4000f9d8: c2 26 60 50 st %g1, [ %i1 + 0x50 ] <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4000f9dc: 7f ff ca 9f call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
4000f9e0: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4000f9e4: 7f ff ef 14 call 4000b634 <_Watchdog_Remove> <== NOT EXECUTED
4000f9e8: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED
4000f9ec: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
4000f9f0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4000f9f4: 7f ff ea d3 call 4000a540 <_Thread_Clear_state> <== NOT EXECUTED
4000f9f8: 81 e8 00 00 restore <== NOT EXECUTED
4000b068 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
4000b068: 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 )
4000b06c: 80 a6 20 00 cmp %i0, 0
4000b070: 02 80 00 19 be 4000b0d4 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
4000b074: 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 ) {
4000b078: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
4000b07c: 80 a7 60 01 cmp %i5, 1
4000b080: 12 80 00 15 bne 4000b0d4 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
4000b084: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
4000b088: 7f ff dc f0 call 40002448 <sparc_disable_interrupts>
4000b08c: 01 00 00 00 nop
4000b090: b8 10 00 08 mov %o0, %i4
4000b094: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000b098: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000b09c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
4000b0a0: 80 88 80 01 btst %g2, %g1
4000b0a4: 02 80 00 0a be 4000b0cc <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
4000b0a8: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
4000b0ac: 92 10 00 19 mov %i1, %o1
4000b0b0: 94 10 20 01 mov 1, %o2
4000b0b4: 40 00 0b db call 4000e020 <_Thread_queue_Extract_priority_helper>
4000b0b8: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000b0bc: 90 10 00 18 mov %i0, %o0
4000b0c0: 92 10 00 19 mov %i1, %o1
4000b0c4: 7f ff ff 50 call 4000ae04 <_Thread_queue_Enqueue_priority>
4000b0c8: 94 07 bf fc add %fp, -4, %o2
}
_ISR_Enable( level );
4000b0cc: 7f ff dc e3 call 40002458 <sparc_enable_interrupts>
4000b0d0: 90 10 00 1c mov %i4, %o0
4000b0d4: 81 c7 e0 08 ret
4000b0d8: 81 e8 00 00 restore
4000b0dc <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4000b0dc: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000b0e0: 90 10 00 18 mov %i0, %o0
4000b0e4: 7f ff fd f9 call 4000a8c8 <_Thread_Get>
4000b0e8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000b0ec: c2 07 bf fc ld [ %fp + -4 ], %g1
4000b0f0: 80 a0 60 00 cmp %g1, 0
4000b0f4: 12 80 00 08 bne 4000b114 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
4000b0f8: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000b0fc: 40 00 0c 00 call 4000e0fc <_Thread_queue_Process_timeout>
4000b100: 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;
4000b104: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000b108: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 4001f480 <_Thread_Dispatch_disable_level>
--level;
4000b10c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000b110: c4 20 60 80 st %g2, [ %g1 + 0x80 ]
4000b114: 81 c7 e0 08 ret
4000b118: 81 e8 00 00 restore
40019300 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
40019300: 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;
40019304: 27 10 00 fa sethi %hi(0x4003e800), %l3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40019308: a4 07 bf e8 add %fp, -24, %l2
4001930c: aa 07 bf ec add %fp, -20, %l5
40019310: b8 07 bf f4 add %fp, -12, %i4
40019314: b2 07 bf f8 add %fp, -8, %i1
40019318: ea 27 bf e8 st %l5, [ %fp + -24 ]
head->previous = NULL;
4001931c: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
40019320: 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;
40019324: f2 27 bf f4 st %i1, [ %fp + -12 ]
head->previous = NULL;
40019328: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
4001932c: 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 );
40019330: 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();
40019334: 29 10 00 f9 sethi %hi(0x4003e400), %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 );
40019338: 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 );
4001933c: 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 );
40019340: 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;
40019344: 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;
40019348: c2 04 e0 f8 ld [ %l3 + 0xf8 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
4001934c: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40019350: 90 10 00 1a mov %i2, %o0
40019354: 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;
40019358: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
4001935c: 40 00 11 79 call 4001d940 <_Watchdog_Adjust_to_chain>
40019360: 94 10 00 1c mov %i4, %o2
40019364: d0 1d 23 58 ldd [ %l4 + 0x358 ], %o0
40019368: 94 10 20 00 clr %o2
4001936c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40019370: 40 00 4f 75 call 4002d144 <__divdi3>
40019374: 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;
40019378: 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 ) {
4001937c: 80 a2 40 0a cmp %o1, %o2
40019380: 08 80 00 07 bleu 4001939c <_Timer_server_Body+0x9c>
40019384: 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 );
40019388: 92 22 40 0a sub %o1, %o2, %o1
4001938c: 90 10 00 1b mov %i3, %o0
40019390: 40 00 11 6c call 4001d940 <_Watchdog_Adjust_to_chain>
40019394: 94 10 00 1c mov %i4, %o2
40019398: 30 80 00 06 b,a 400193b0 <_Timer_server_Body+0xb0>
} else if ( snapshot < last_snapshot ) {
4001939c: 1a 80 00 05 bcc 400193b0 <_Timer_server_Body+0xb0>
400193a0: 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 );
400193a4: 92 10 20 01 mov 1, %o1
400193a8: 40 00 11 3e call 4001d8a0 <_Watchdog_Adjust>
400193ac: 94 22 80 1d sub %o2, %i5, %o2
}
watchdogs->last_snapshot = snapshot;
400193b0: 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 );
400193b4: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
400193b8: 40 00 02 f4 call 40019f88 <_Chain_Get>
400193bc: 01 00 00 00 nop
if ( timer == NULL ) {
400193c0: 92 92 20 00 orcc %o0, 0, %o1
400193c4: 02 80 00 0c be 400193f4 <_Timer_server_Body+0xf4>
400193c8: 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 ) {
400193cc: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
400193d0: 80 a0 60 01 cmp %g1, 1
400193d4: 02 80 00 05 be 400193e8 <_Timer_server_Body+0xe8>
400193d8: 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 ) {
400193dc: 80 a0 60 03 cmp %g1, 3
400193e0: 12 bf ff f5 bne 400193b4 <_Timer_server_Body+0xb4> <== NEVER TAKEN
400193e4: 90 10 00 1b mov %i3, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
400193e8: 40 00 11 80 call 4001d9e8 <_Watchdog_Insert>
400193ec: 92 02 60 10 add %o1, 0x10, %o1
400193f0: 30 bf ff f1 b,a 400193b4 <_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 );
400193f4: 7f ff dc 70 call 400105b4 <sparc_disable_interrupts>
400193f8: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
400193fc: c2 07 bf e8 ld [ %fp + -24 ], %g1
40019400: 80 a0 40 15 cmp %g1, %l5
40019404: 12 80 00 0a bne 4001942c <_Timer_server_Body+0x12c> <== NEVER TAKEN
40019408: 01 00 00 00 nop
ts->insert_chain = NULL;
4001940c: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
40019410: 7f ff dc 6d call 400105c4 <sparc_enable_interrupts>
40019414: 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 ) ) {
40019418: c2 07 bf f4 ld [ %fp + -12 ], %g1
4001941c: 80 a0 40 19 cmp %g1, %i1
40019420: 12 80 00 06 bne 40019438 <_Timer_server_Body+0x138>
40019424: 01 00 00 00 nop
40019428: 30 80 00 18 b,a 40019488 <_Timer_server_Body+0x188>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
4001942c: 7f ff dc 66 call 400105c4 <sparc_enable_interrupts> <== NOT EXECUTED
40019430: 01 00 00 00 nop <== NOT EXECUTED
40019434: 30 bf ff c5 b,a 40019348 <_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 );
40019438: 7f ff dc 5f call 400105b4 <sparc_disable_interrupts>
4001943c: 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;
40019440: 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))
40019444: 80 a7 40 19 cmp %i5, %i1
40019448: 02 80 00 0d be 4001947c <_Timer_server_Body+0x17c>
4001944c: 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;
40019450: c2 07 40 00 ld [ %i5 ], %g1
head->next = new_first;
new_first->previous = head;
40019454: 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;
40019458: c2 27 bf f4 st %g1, [ %fp + -12 ]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
4001945c: c0 27 60 08 clr [ %i5 + 8 ]
_ISR_Enable( level );
40019460: 7f ff dc 59 call 400105c4 <sparc_enable_interrupts>
40019464: 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 );
40019468: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001946c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
40019470: 9f c0 40 00 call %g1
40019474: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
}
40019478: 30 bf ff f0 b,a 40019438 <_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 );
4001947c: 7f ff dc 52 call 400105c4 <sparc_enable_interrupts>
40019480: 01 00 00 00 nop
40019484: 30 bf ff b0 b,a 40019344 <_Timer_server_Body+0x44>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
40019488: 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;
4001948c: 03 10 00 fa sethi %hi(0x4003e800), %g1
40019490: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4003e810 <_Thread_Dispatch_disable_level>
++level;
40019494: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40019498: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
4001949c: d0 06 00 00 ld [ %i0 ], %o0
400194a0: 40 00 10 1a call 4001d508 <_Thread_Set_state>
400194a4: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
400194a8: 7f ff ff 6e call 40019260 <_Timer_server_Reset_interval_system_watchdog>
400194ac: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
400194b0: 7f ff ff 80 call 400192b0 <_Timer_server_Reset_tod_system_watchdog>
400194b4: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
400194b8: 40 00 0d ce call 4001cbf0 <_Thread_Enable_dispatch>
400194bc: 01 00 00 00 nop
ts->active = true;
400194c0: 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 );
400194c4: 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;
400194c8: 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 );
400194cc: 40 00 11 9f call 4001db48 <_Watchdog_Remove>
400194d0: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
400194d4: 40 00 11 9d call 4001db48 <_Watchdog_Remove>
400194d8: 90 10 00 10 mov %l0, %o0
400194dc: 30 bf ff 9a b,a 40019344 <_Timer_server_Body+0x44>
400194e0 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
400194e0: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
400194e4: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
400194e8: 80 a0 60 00 cmp %g1, 0
400194ec: 12 80 00 51 bne 40019630 <_Timer_server_Schedule_operation_method+0x150>
400194f0: 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;
400194f4: 03 10 00 fa sethi %hi(0x4003e800), %g1
400194f8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4003e810 <_Thread_Dispatch_disable_level>
++level;
400194fc: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40019500: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
40019504: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
40019508: 80 a0 60 01 cmp %g1, 1
4001950c: 12 80 00 1f bne 40019588 <_Timer_server_Schedule_operation_method+0xa8>
40019510: 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 );
40019514: 7f ff dc 28 call 400105b4 <sparc_disable_interrupts>
40019518: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
4001951c: 03 10 00 fa sethi %hi(0x4003e800), %g1
40019520: c4 00 60 f8 ld [ %g1 + 0xf8 ], %g2 ! 4003e8f8 <_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;
40019524: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
40019528: 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 );
4001952c: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
40019530: 80 a0 40 03 cmp %g1, %g3
40019534: 02 80 00 08 be 40019554 <_Timer_server_Schedule_operation_method+0x74>
40019538: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
4001953c: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
40019540: 80 a7 00 04 cmp %i4, %g4
40019544: 08 80 00 03 bleu 40019550 <_Timer_server_Schedule_operation_method+0x70>
40019548: 86 10 20 00 clr %g3
delta_interval -= delta;
4001954c: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
40019550: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
40019554: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
40019558: 7f ff dc 1b call 400105c4 <sparc_enable_interrupts>
4001955c: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
40019560: 90 06 20 30 add %i0, 0x30, %o0
40019564: 40 00 11 21 call 4001d9e8 <_Watchdog_Insert>
40019568: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
4001956c: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
40019570: 80 a0 60 00 cmp %g1, 0
40019574: 12 80 00 2d bne 40019628 <_Timer_server_Schedule_operation_method+0x148>
40019578: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
4001957c: 7f ff ff 39 call 40019260 <_Timer_server_Reset_interval_system_watchdog>
40019580: 90 10 00 18 mov %i0, %o0
40019584: 30 80 00 29 b,a 40019628 <_Timer_server_Schedule_operation_method+0x148>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
40019588: 12 80 00 28 bne 40019628 <_Timer_server_Schedule_operation_method+0x148>
4001958c: 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 );
40019590: 7f ff dc 09 call 400105b4 <sparc_disable_interrupts>
40019594: 01 00 00 00 nop
40019598: b8 10 00 08 mov %o0, %i4
4001959c: 03 10 00 f9 sethi %hi(0x4003e400), %g1
400195a0: d0 18 63 58 ldd [ %g1 + 0x358 ], %o0 ! 4003e758 <_TOD>
400195a4: 94 10 20 00 clr %o2
400195a8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400195ac: 40 00 4e e6 call 4002d144 <__divdi3>
400195b0: 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;
400195b4: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
400195b8: 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 );
400195bc: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
400195c0: 80 a0 40 03 cmp %g1, %g3
400195c4: 02 80 00 0d be 400195f8 <_Timer_server_Schedule_operation_method+0x118>
400195c8: 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 ) {
400195cc: 08 80 00 08 bleu 400195ec <_Timer_server_Schedule_operation_method+0x10c>
400195d0: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
400195d4: 88 22 40 02 sub %o1, %g2, %g4
if (delta_interval > delta) {
400195d8: 80 a0 c0 04 cmp %g3, %g4
400195dc: 08 80 00 06 bleu 400195f4 <_Timer_server_Schedule_operation_method+0x114><== NEVER TAKEN
400195e0: 84 10 20 00 clr %g2
delta_interval -= delta;
400195e4: 10 80 00 04 b 400195f4 <_Timer_server_Schedule_operation_method+0x114>
400195e8: 84 20 c0 04 sub %g3, %g4, %g2
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
400195ec: 84 00 c0 02 add %g3, %g2, %g2
delta_interval += delta;
400195f0: 84 20 80 09 sub %g2, %o1, %g2
}
first_watchdog->delta_interval = delta_interval;
400195f4: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
400195f8: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
400195fc: 7f ff db f2 call 400105c4 <sparc_enable_interrupts>
40019600: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
40019604: 90 06 20 68 add %i0, 0x68, %o0
40019608: 40 00 10 f8 call 4001d9e8 <_Watchdog_Insert>
4001960c: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
40019610: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
40019614: 80 a0 60 00 cmp %g1, 0
40019618: 12 80 00 04 bne 40019628 <_Timer_server_Schedule_operation_method+0x148>
4001961c: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
40019620: 7f ff ff 24 call 400192b0 <_Timer_server_Reset_tod_system_watchdog>
40019624: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
40019628: 40 00 0d 72 call 4001cbf0 <_Thread_Enable_dispatch>
4001962c: 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 );
40019630: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
40019634: 40 00 02 49 call 40019f58 <_Chain_Append>
40019638: 81 e8 00 00 restore
4000cba4 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
4000cba4: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
4000cba8: d4 1e 40 00 ldd [ %i1 ], %o2
4000cbac: 80 92 80 0b orcc %o2, %o3, %g0
4000cbb0: 32 80 00 06 bne,a 4000cbc8 <_Timestamp64_Divide+0x24> <== ALWAYS TAKEN
4000cbb4: d8 1e 00 00 ldd [ %i0 ], %o4
*_ival_percentage = 0;
4000cbb8: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*_fval_percentage = 0;
4000cbbc: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
4000cbc0: 81 c7 e0 08 ret <== NOT EXECUTED
4000cbc4: 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;
4000cbc8: 83 2b 20 02 sll %o4, 2, %g1
4000cbcc: 87 2b 60 02 sll %o5, 2, %g3
4000cbd0: 89 33 60 1e srl %o5, 0x1e, %g4
4000cbd4: bb 28 e0 05 sll %g3, 5, %i5
4000cbd8: 84 11 00 01 or %g4, %g1, %g2
4000cbdc: 83 30 e0 1b srl %g3, 0x1b, %g1
4000cbe0: b9 28 a0 05 sll %g2, 5, %i4
4000cbe4: 86 a7 40 03 subcc %i5, %g3, %g3
4000cbe8: b8 10 40 1c or %g1, %i4, %i4
4000cbec: 84 67 00 02 subx %i4, %g2, %g2
4000cbf0: b2 80 c0 0d addcc %g3, %o5, %i1
4000cbf4: b0 40 80 0c addx %g2, %o4, %i0
4000cbf8: 83 36 60 1e srl %i1, 0x1e, %g1
4000cbfc: 87 2e 60 02 sll %i1, 2, %g3
4000cc00: 85 2e 20 02 sll %i0, 2, %g2
4000cc04: 84 10 40 02 or %g1, %g2, %g2
4000cc08: ba 86 40 03 addcc %i1, %g3, %i5
4000cc0c: b8 46 00 02 addx %i0, %g2, %i4
4000cc10: 83 37 60 1e srl %i5, 0x1e, %g1
4000cc14: 87 2f 60 02 sll %i5, 2, %g3
4000cc18: 85 2f 20 02 sll %i4, 2, %g2
4000cc1c: 84 10 40 02 or %g1, %g2, %g2
4000cc20: 92 87 40 03 addcc %i5, %g3, %o1
4000cc24: 90 47 00 02 addx %i4, %g2, %o0
4000cc28: 87 32 60 1b srl %o1, 0x1b, %g3
4000cc2c: 85 2a 20 05 sll %o0, 5, %g2
4000cc30: 83 2a 60 05 sll %o1, 5, %g1
4000cc34: 90 10 c0 02 or %g3, %g2, %o0
4000cc38: 40 00 39 e6 call 4001b3d0 <__divdi3>
4000cc3c: 92 10 00 01 mov %g1, %o1
*_ival_percentage = answer / 1000;
4000cc40: 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;
4000cc44: b8 10 00 08 mov %o0, %i4
4000cc48: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
4000cc4c: 40 00 39 e1 call 4001b3d0 <__divdi3>
4000cc50: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
4000cc54: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
4000cc58: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
4000cc5c: 94 10 20 00 clr %o2
4000cc60: 92 10 00 1d mov %i5, %o1
4000cc64: 40 00 3a c6 call 4001b77c <__moddi3>
4000cc68: 96 10 23 e8 mov 0x3e8, %o3
4000cc6c: d2 26 c0 00 st %o1, [ %i3 ]
4000cc70: 81 c7 e0 08 ret
4000cc74: 81 e8 00 00 restore
4000b494 <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
4000b494: 9d e3 bf 98 save %sp, -104, %sp
uint32_t number_of_initial_extensions =
4000b498: 03 10 00 72 sethi %hi(0x4001c800), %g1
4000b49c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 ! 4001c818 <Configuration+0x40>
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
4000b4a0: 80 a0 60 00 cmp %g1, 0
4000b4a4: 02 80 00 0a be 4000b4cc <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
4000b4a8: 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 )
4000b4ac: 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 =
4000b4b0: 40 00 01 08 call 4000b8d0 <_Workspace_Allocate_or_fatal_error>
4000b4b4: 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 );
4000b4b8: 13 10 00 2d sethi %hi(0x4000b400), %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 };
4000b4bc: d0 27 bf fc st %o0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000b4c0: 92 12 60 50 or %o1, 0x50, %o1
4000b4c4: 7f ff ff c4 call 4000b3d4 <_User_extensions_Iterate>
4000b4c8: 90 07 bf fc add %fp, -4, %o0
4000b4cc: 81 c7 e0 08 ret
4000b4d0: 81 e8 00 00 restore
4000cedc <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
4000cedc: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
4000cee0: 7f ff d8 ec call 40003290 <sparc_disable_interrupts>
4000cee4: 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;
4000cee8: 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 );
4000ceec: 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 ) ) {
4000cef0: 80 a0 40 1c cmp %g1, %i4
4000cef4: 02 80 00 20 be 4000cf74 <_Watchdog_Adjust+0x98>
4000cef8: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
4000cefc: 02 80 00 1b be 4000cf68 <_Watchdog_Adjust+0x8c>
4000cf00: b6 10 20 01 mov 1, %i3
4000cf04: 80 a6 60 01 cmp %i1, 1
4000cf08: 12 80 00 1b bne 4000cf74 <_Watchdog_Adjust+0x98> <== NEVER TAKEN
4000cf0c: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
4000cf10: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000cf14: 10 80 00 07 b 4000cf30 <_Watchdog_Adjust+0x54>
4000cf18: b4 00 80 1a add %g2, %i2, %i2
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
4000cf1c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000cf20: 80 a6 80 02 cmp %i2, %g2
4000cf24: 3a 80 00 05 bcc,a 4000cf38 <_Watchdog_Adjust+0x5c>
4000cf28: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
4000cf2c: b4 20 80 1a sub %g2, %i2, %i2
break;
4000cf30: 10 80 00 11 b 4000cf74 <_Watchdog_Adjust+0x98>
4000cf34: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
} else {
units -= _Watchdog_First( header )->delta_interval;
4000cf38: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
4000cf3c: 7f ff d8 d9 call 400032a0 <sparc_enable_interrupts>
4000cf40: 01 00 00 00 nop
_Watchdog_Tickle( header );
4000cf44: 40 00 00 90 call 4000d184 <_Watchdog_Tickle>
4000cf48: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
4000cf4c: 7f ff d8 d1 call 40003290 <sparc_disable_interrupts>
4000cf50: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
4000cf54: c2 06 00 00 ld [ %i0 ], %g1
4000cf58: 80 a0 40 1c cmp %g1, %i4
4000cf5c: 12 80 00 04 bne 4000cf6c <_Watchdog_Adjust+0x90>
4000cf60: 80 a6 a0 00 cmp %i2, 0
4000cf64: 30 80 00 04 b,a 4000cf74 <_Watchdog_Adjust+0x98>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
4000cf68: 80 a6 a0 00 cmp %i2, 0
4000cf6c: 32 bf ff ec bne,a 4000cf1c <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
4000cf70: c2 06 00 00 ld [ %i0 ], %g1
}
break;
}
}
_ISR_Enable( level );
4000cf74: 7f ff d8 cb call 400032a0 <sparc_enable_interrupts>
4000cf78: 91 e8 00 08 restore %g0, %o0, %o0
4000b634 <_Watchdog_Remove>:
#include <rtems/score/watchdog.h>
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
4000b634: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
4000b638: 7f ff db 84 call 40002448 <sparc_disable_interrupts>
4000b63c: ba 10 00 18 mov %i0, %i5
previous_state = the_watchdog->state;
4000b640: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
4000b644: 80 a6 20 01 cmp %i0, 1
4000b648: 22 80 00 1e be,a 4000b6c0 <_Watchdog_Remove+0x8c>
4000b64c: c0 27 60 08 clr [ %i5 + 8 ]
4000b650: 0a 80 00 1d bcs 4000b6c4 <_Watchdog_Remove+0x90>
4000b654: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000b658: 80 a6 20 03 cmp %i0, 3
4000b65c: 18 80 00 1a bgu 4000b6c4 <_Watchdog_Remove+0x90> <== NEVER TAKEN
4000b660: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
4000b664: 10 80 00 02 b 4000b66c <_Watchdog_Remove+0x38>
4000b668: c2 07 40 00 ld [ %i5 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
4000b66c: c0 27 60 08 clr [ %i5 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
4000b670: c4 00 40 00 ld [ %g1 ], %g2
4000b674: 80 a0 a0 00 cmp %g2, 0
4000b678: 02 80 00 07 be 4000b694 <_Watchdog_Remove+0x60>
4000b67c: 05 10 00 7d sethi %hi(0x4001f400), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
4000b680: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000b684: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000b688: 84 00 c0 02 add %g3, %g2, %g2
4000b68c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
4000b690: 05 10 00 7d sethi %hi(0x4001f400), %g2
4000b694: c4 00 a1 64 ld [ %g2 + 0x164 ], %g2 ! 4001f564 <_Watchdog_Sync_count>
4000b698: 80 a0 a0 00 cmp %g2, 0
4000b69c: 22 80 00 07 be,a 4000b6b8 <_Watchdog_Remove+0x84>
4000b6a0: c4 07 60 04 ld [ %i5 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
4000b6a4: 05 10 00 7e sethi %hi(0x4001f800), %g2
4000b6a8: c6 00 a1 98 ld [ %g2 + 0x198 ], %g3 ! 4001f998 <_Per_CPU_Information+0x8>
4000b6ac: 05 10 00 7d sethi %hi(0x4001f400), %g2
4000b6b0: c6 20 a1 04 st %g3, [ %g2 + 0x104 ] ! 4001f504 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000b6b4: c4 07 60 04 ld [ %i5 + 4 ], %g2
next->previous = previous;
4000b6b8: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
4000b6bc: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000b6c0: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000b6c4: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 4001f568 <_Watchdog_Ticks_since_boot>
4000b6c8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_ISR_Enable( level );
4000b6cc: 7f ff db 63 call 40002458 <sparc_enable_interrupts>
4000b6d0: 01 00 00 00 nop
return( previous_state );
}
4000b6d4: 81 c7 e0 08 ret
4000b6d8: 81 e8 00 00 restore
4000c888 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
4000c888: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
4000c88c: 7f ff d9 5e call 40002e04 <sparc_disable_interrupts>
4000c890: b8 10 00 18 mov %i0, %i4
4000c894: b0 10 00 08 mov %o0, %i0
printk( "Watchdog Chain: %s %p\n", name, header );
4000c898: 11 10 00 7c sethi %hi(0x4001f000), %o0
4000c89c: 94 10 00 19 mov %i1, %o2
4000c8a0: 90 12 23 d8 or %o0, 0x3d8, %o0
4000c8a4: 7f ff e3 dd call 40005818 <printk>
4000c8a8: 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;
4000c8ac: 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 );
4000c8b0: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
4000c8b4: 80 a7 40 19 cmp %i5, %i1
4000c8b8: 12 80 00 04 bne 4000c8c8 <_Watchdog_Report_chain+0x40>
4000c8bc: 92 10 00 1d mov %i5, %o1
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
4000c8c0: 10 80 00 0d b 4000c8f4 <_Watchdog_Report_chain+0x6c>
4000c8c4: 11 10 00 7d sethi %hi(0x4001f400), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
4000c8c8: 40 00 00 0f call 4000c904 <_Watchdog_Report>
4000c8cc: 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 )
4000c8d0: 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 ) ;
4000c8d4: 80 a7 40 19 cmp %i5, %i1
4000c8d8: 12 bf ff fc bne 4000c8c8 <_Watchdog_Report_chain+0x40> <== NEVER TAKEN
4000c8dc: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
4000c8e0: 11 10 00 7c sethi %hi(0x4001f000), %o0
4000c8e4: 92 10 00 1c mov %i4, %o1
4000c8e8: 7f ff e3 cc call 40005818 <printk>
4000c8ec: 90 12 23 f0 or %o0, 0x3f0, %o0
4000c8f0: 30 80 00 03 b,a 4000c8fc <_Watchdog_Report_chain+0x74>
} else {
printk( "Chain is empty\n" );
4000c8f4: 7f ff e3 c9 call 40005818 <printk>
4000c8f8: 90 12 20 00 mov %o0, %o0
}
_ISR_Enable( level );
4000c8fc: 7f ff d9 46 call 40002e14 <sparc_enable_interrupts>
4000c900: 81 e8 00 00 restore
4000b6dc <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
4000b6dc: 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 );
4000b6e0: 7f ff db 5a call 40002448 <sparc_disable_interrupts>
4000b6e4: b8 10 00 18 mov %i0, %i4
4000b6e8: 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;
4000b6ec: 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 );
4000b6f0: b6 07 20 04 add %i4, 4, %i3
if ( _Chain_Is_empty( header ) )
4000b6f4: 80 a7 40 1b cmp %i5, %i3
4000b6f8: 02 80 00 1f be 4000b774 <_Watchdog_Tickle+0x98>
4000b6fc: 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) {
4000b700: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000b704: 80 a0 60 00 cmp %g1, 0
4000b708: 02 80 00 06 be 4000b720 <_Watchdog_Tickle+0x44> <== NEVER TAKEN
4000b70c: 82 00 7f ff add %g1, -1, %g1
the_watchdog->delta_interval--;
4000b710: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
if ( the_watchdog->delta_interval != 0 )
4000b714: 80 a0 60 00 cmp %g1, 0
4000b718: 12 80 00 17 bne 4000b774 <_Watchdog_Tickle+0x98>
4000b71c: 01 00 00 00 nop
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
4000b720: 7f ff ff c5 call 4000b634 <_Watchdog_Remove>
4000b724: 90 10 00 1d mov %i5, %o0
4000b728: b4 10 00 08 mov %o0, %i2
_ISR_Enable( level );
4000b72c: 7f ff db 4b call 40002458 <sparc_enable_interrupts>
4000b730: 90 10 00 18 mov %i0, %o0
switch( watchdog_state ) {
4000b734: 80 a6 a0 02 cmp %i2, 2
4000b738: 12 80 00 06 bne 4000b750 <_Watchdog_Tickle+0x74>
4000b73c: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
4000b740: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000b744: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000b748: 9f c0 40 00 call %g1
4000b74c: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
4000b750: 7f ff db 3e call 40002448 <sparc_disable_interrupts>
4000b754: 01 00 00 00 nop
4000b758: b0 10 00 08 mov %o0, %i0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000b75c: fa 07 00 00 ld [ %i4 ], %i5
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
4000b760: 80 a7 40 1b cmp %i5, %i3
4000b764: 02 80 00 04 be 4000b774 <_Watchdog_Tickle+0x98>
4000b768: 01 00 00 00 nop
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
4000b76c: 10 bf ff ea b 4000b714 <_Watchdog_Tickle+0x38>
4000b770: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
4000b774: 7f ff db 39 call 40002458 <sparc_enable_interrupts>
4000b778: 81 e8 00 00 restore
4000b77c <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
4000b77c: 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();
4000b780: 05 10 00 71 sethi %hi(0x4001c400), %g2
4000b784: 82 10 a3 d8 or %g2, 0x3d8, %g1 ! 4001c7d8 <Configuration>
4000b788: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
4000b78c: fa 00 a3 d8 ld [ %g2 + 0x3d8 ], %i5
4000b790: 80 a0 e0 00 cmp %g3, 0
4000b794: 12 80 00 03 bne 4000b7a0 <_Workspace_Handler_initialization+0x24>
4000b798: 84 10 20 00 clr %g2
4000b79c: 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;
4000b7a0: 21 10 00 24 sethi %hi(0x40009000), %l0
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000b7a4: 27 10 00 7d sethi %hi(0x4001f400), %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();
4000b7a8: 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) {
4000b7ac: 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;
4000b7b0: a0 14 21 d4 or %l0, 0x1d4, %l0
size_t i;
for (i = 0; i < area_count; ++i) {
Heap_Area *area = &areas [i];
if ( do_zero ) {
4000b7b4: e2 08 60 30 ldub [ %g1 + 0x30 ], %l1
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000b7b8: 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) {
4000b7bc: 10 80 00 2c b 4000b86c <_Workspace_Handler_initialization+0xf0>
4000b7c0: a6 14 e0 90 or %l3, 0x90, %l3
Heap_Area *area = &areas [i];
if ( do_zero ) {
4000b7c4: 22 80 00 07 be,a 4000b7e0 <_Workspace_Handler_initialization+0x64>
4000b7c8: f8 06 20 04 ld [ %i0 + 4 ], %i4
memset( area->begin, 0, area->size );
4000b7cc: d0 06 00 00 ld [ %i0 ], %o0
4000b7d0: d4 06 20 04 ld [ %i0 + 4 ], %o2
4000b7d4: 40 00 13 52 call 4001051c <memset>
4000b7d8: 92 10 20 00 clr %o1
}
if ( area->size > overhead ) {
4000b7dc: f8 06 20 04 ld [ %i0 + 4 ], %i4
4000b7e0: 80 a7 20 16 cmp %i4, 0x16
4000b7e4: 28 80 00 21 bleu,a 4000b868 <_Workspace_Handler_initialization+0xec>
4000b7e8: b6 06 e0 01 inc %i3
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000b7ec: 80 a4 a0 00 cmp %l2, 0
4000b7f0: 32 80 00 0c bne,a 4000b820 <_Workspace_Handler_initialization+0xa4>
4000b7f4: d2 06 00 00 ld [ %i0 ], %o1
size = area->size;
} else {
if ( remaining > 0 ) {
4000b7f8: 80 a7 60 00 cmp %i5, 0
4000b7fc: 22 80 00 08 be,a 4000b81c <_Workspace_Handler_initialization+0xa0><== NEVER TAKEN
4000b800: b8 10 20 00 clr %i4 <== NOT EXECUTED
size = remaining < area->size - overhead ?
4000b804: 82 07 3f ea add %i4, -22, %g1
remaining + overhead : area->size;
4000b808: 80 a7 40 01 cmp %i5, %g1
4000b80c: 2a 80 00 04 bcs,a 4000b81c <_Workspace_Handler_initialization+0xa0><== ALWAYS TAKEN
4000b810: b8 07 60 16 add %i5, 0x16, %i4
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000b814: 10 80 00 03 b 4000b820 <_Workspace_Handler_initialization+0xa4><== NOT EXECUTED
4000b818: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
4000b81c: d2 06 00 00 ld [ %i0 ], %o1
4000b820: 94 10 00 1c mov %i4, %o2
4000b824: 90 10 00 13 mov %l3, %o0
4000b828: 9f c4 00 00 call %l0
4000b82c: 96 10 20 08 mov 8, %o3
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000b830: c2 06 00 00 ld [ %i0 ], %g1
area->size -= size;
if ( space_available < remaining ) {
4000b834: 80 a2 00 1d cmp %o0, %i5
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000b838: 82 00 40 1c add %g1, %i4, %g1
4000b83c: c2 26 00 00 st %g1, [ %i0 ]
area->size -= size;
4000b840: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000b844: b8 20 40 1c sub %g1, %i4, %i4
if ( space_available < remaining ) {
4000b848: 1a 80 00 05 bcc 4000b85c <_Workspace_Handler_initialization+0xe0><== ALWAYS TAKEN
4000b84c: f8 26 20 04 st %i4, [ %i0 + 4 ]
remaining -= space_available;
4000b850: ba 27 40 08 sub %i5, %o0, %i5 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4000b854: 10 80 00 04 b 4000b864 <_Workspace_Handler_initialization+0xe8><== NOT EXECUTED
4000b858: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED
4000b85c: a0 10 00 1a mov %i2, %l0
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
4000b860: 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) {
4000b864: b6 06 e0 01 inc %i3
4000b868: b0 06 20 08 add %i0, 8, %i0
4000b86c: 80 a6 c0 19 cmp %i3, %i1
4000b870: 12 bf ff d5 bne 4000b7c4 <_Workspace_Handler_initialization+0x48>
4000b874: 80 a4 60 00 cmp %l1, 0
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
4000b878: 80 a7 60 00 cmp %i5, 0
4000b87c: 02 80 00 05 be 4000b890 <_Workspace_Handler_initialization+0x114>
4000b880: 90 10 20 00 clr %o0
_Internal_error_Occurred(
4000b884: 92 10 20 01 mov 1, %o1
4000b888: 7f ff f6 e6 call 40009420 <_Internal_error_Occurred>
4000b88c: 94 10 20 02 mov 2, %o2
4000b890: 81 c7 e0 08 ret
4000b894: 81 e8 00 00 restore
4001b8cc <_calloc_r>:
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
4001b8cc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
4001b8d0: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4001b8d4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001b8d8: 7f ff a1 20 call 40003d58 <calloc> <== NOT EXECUTED
4001b8dc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001b954 <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
4001b954: 90 10 00 09 mov %o1, %o0
4001b958: 82 13 c0 00 mov %o7, %g1
4001b95c: 7f ff ff e1 call 4001b8e0 <close>
4001b960: 9e 10 40 00 mov %g1, %o7
4001354c <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
4001354c: 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)
40013550: 10 80 00 17 b 400135ac <_fat_block_read+0x60>
40013554: ba 10 20 00 clr %i5
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40013558: 92 10 00 19 mov %i1, %o1
4001355c: 94 10 20 01 mov 1, %o2
40013560: 7f ff ff cc call 40013490 <fat_buf_access>
40013564: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40013568: 80 a2 20 00 cmp %o0, 0
4001356c: 32 80 00 15 bne,a 400135c0 <_fat_block_read+0x74> <== NEVER TAKEN
40013570: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
40013574: e0 16 00 00 lduh [ %i0 ], %l0
40013578: a0 24 00 1a sub %l0, %i2, %l0
4001357c: 80 a4 00 1b cmp %l0, %i3
40013580: 38 80 00 02 bgu,a 40013588 <_fat_block_read+0x3c>
40013584: a0 10 00 1b mov %i3, %l0
memcpy((buff + cmpltd), (sec_buf + ofs), c);
40013588: d2 07 bf fc ld [ %fp + -4 ], %o1
4001358c: 90 07 00 1d add %i4, %i5, %o0
40013590: 92 02 40 1a add %o1, %i2, %o1
40013594: 94 10 00 10 mov %l0, %o2
40013598: 40 00 23 90 call 4001c3d8 <memcpy>
4001359c: b6 26 c0 10 sub %i3, %l0, %i3
count -= c;
cmpltd += c;
400135a0: ba 04 00 1d add %l0, %i5, %i5
sec_num++;
400135a4: b2 06 60 01 inc %i1
ofs = 0;
400135a8: 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)
400135ac: 80 a6 e0 00 cmp %i3, 0
400135b0: 12 bf ff ea bne 40013558 <_fat_block_read+0xc>
400135b4: 90 10 00 18 mov %i0, %o0
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
400135b8: 81 c7 e0 08 ret
400135bc: 91 e8 00 1d restore %g0, %i5, %o0
400135c0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
400135c4: 81 c7 e0 08 ret <== NOT EXECUTED
400135c8: 81 e8 00 00 restore <== NOT EXECUTED
40004ba4 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40004ba4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40004ba8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40004bac: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40004bb0: 7f ff ff e9 call 40004b54 <lstat> <== NOT EXECUTED
40004bb4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40004ee4 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40004ee4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40004ee8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40004eec: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40004ef0: 7f ff ff e9 call 40004e94 <stat> <== NOT EXECUTED
40004ef4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40007d74 <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
40007d74: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
40007d78: 3b 10 00 65 sethi %hi(0x40019400), %i5
40007d7c: 40 00 04 68 call 40008f1c <pthread_mutex_lock>
40007d80: 90 17 60 cc or %i5, 0xcc, %o0 ! 400194cc <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
40007d84: 90 10 00 18 mov %i0, %o0
40007d88: 40 00 1a 1d call 4000e5fc <fcntl>
40007d8c: 92 10 20 01 mov 1, %o1
40007d90: 80 a2 20 00 cmp %o0, 0
40007d94: 16 80 00 08 bge 40007db4 <aio_cancel+0x40>
40007d98: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
40007d9c: 40 00 04 81 call 40008fa0 <pthread_mutex_unlock>
40007da0: 90 17 60 cc or %i5, 0xcc, %o0
rtems_set_errno_and_return_minus_one (EBADF);
40007da4: 40 00 27 4d call 40011ad8 <__errno>
40007da8: 01 00 00 00 nop
40007dac: 10 80 00 54 b 40007efc <aio_cancel+0x188>
40007db0: 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) {
40007db4: 32 80 00 35 bne,a 40007e88 <aio_cancel+0x114>
40007db8: 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);
40007dbc: 11 10 00 65 sethi %hi(0x40019400), %o0
40007dc0: 92 10 00 18 mov %i0, %o1
40007dc4: 90 12 21 14 or %o0, 0x114, %o0
40007dc8: 40 00 01 71 call 4000838c <rtems_aio_search_fd>
40007dcc: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40007dd0: b8 92 20 00 orcc %o0, 0, %i4
40007dd4: 12 80 00 20 bne 40007e54 <aio_cancel+0xe0>
40007dd8: 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;
40007ddc: ba 17 60 cc or %i5, 0xcc, %i5
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40007de0: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
40007de4: 82 07 60 58 add %i5, 0x58, %g1
40007de8: 80 a0 80 01 cmp %g2, %g1
40007dec: 02 80 00 08 be 40007e0c <aio_cancel+0x98> <== NEVER TAKEN
40007df0: 92 10 00 18 mov %i0, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40007df4: 90 07 60 54 add %i5, 0x54, %o0
40007df8: 40 00 01 65 call 4000838c <rtems_aio_search_fd>
40007dfc: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40007e00: b8 92 20 00 orcc %o0, 0, %i4
40007e04: 12 80 00 08 bne 40007e24 <aio_cancel+0xb0>
40007e08: 01 00 00 00 nop
pthread_mutex_unlock(&aio_request_queue.mutex);
40007e0c: 11 10 00 65 sethi %hi(0x40019400), %o0
return AIO_ALLDONE;
40007e10: 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);
40007e14: 40 00 04 63 call 40008fa0 <pthread_mutex_unlock>
40007e18: 90 12 20 cc or %o0, 0xcc, %o0
return AIO_ALLDONE;
40007e1c: 81 c7 e0 08 ret
40007e20: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40007e24: 40 00 0a cf call 4000a960 <_Chain_Extract>
40007e28: 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);
40007e2c: 40 00 01 80 call 4000842c <rtems_aio_remove_fd>
40007e30: 90 10 00 1c mov %i4, %o0
pthread_mutex_destroy (&r_chain->mutex);
40007e34: 40 00 03 8d call 40008c68 <pthread_mutex_destroy>
40007e38: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->mutex);
40007e3c: 40 00 02 ae call 400088f4 <pthread_cond_destroy>
40007e40: 90 10 00 1b mov %i3, %o0
free (r_chain);
40007e44: 7f ff f1 3d call 40004338 <free>
40007e48: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007e4c: 10 80 00 0b b 40007e78 <aio_cancel+0x104>
40007e50: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
40007e54: 40 00 04 32 call 40008f1c <pthread_mutex_lock>
40007e58: 90 10 00 1b mov %i3, %o0
40007e5c: 40 00 0a c1 call 4000a960 <_Chain_Extract>
40007e60: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
40007e64: 40 00 01 72 call 4000842c <rtems_aio_remove_fd>
40007e68: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
40007e6c: 40 00 04 4d call 40008fa0 <pthread_mutex_unlock>
40007e70: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007e74: 90 17 60 cc or %i5, 0xcc, %o0
40007e78: 40 00 04 4a call 40008fa0 <pthread_mutex_unlock>
40007e7c: b0 10 20 00 clr %i0
return AIO_CANCELED;
40007e80: 81 c7 e0 08 ret
40007e84: 81 e8 00 00 restore
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
40007e88: 80 a7 00 18 cmp %i4, %i0
40007e8c: 12 80 00 17 bne 40007ee8 <aio_cancel+0x174>
40007e90: 90 17 60 cc or %i5, 0xcc, %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);
40007e94: 11 10 00 65 sethi %hi(0x40019400), %o0
40007e98: 92 10 00 1c mov %i4, %o1
40007e9c: 90 12 21 14 or %o0, 0x114, %o0
40007ea0: 40 00 01 3b call 4000838c <rtems_aio_search_fd>
40007ea4: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40007ea8: b6 92 20 00 orcc %o0, 0, %i3
40007eac: 32 80 00 1c bne,a 40007f1c <aio_cancel+0x1a8>
40007eb0: b8 06 e0 1c add %i3, 0x1c, %i4
40007eb4: ba 17 60 cc or %i5, 0xcc, %i5
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40007eb8: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
40007ebc: 82 07 60 58 add %i5, 0x58, %g1
40007ec0: 80 a0 80 01 cmp %g2, %g1
40007ec4: 02 bf ff d2 be 40007e0c <aio_cancel+0x98> <== NEVER TAKEN
40007ec8: 92 10 00 1c mov %i4, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40007ecc: 90 07 60 54 add %i5, 0x54, %o0
40007ed0: 40 00 01 2f call 4000838c <rtems_aio_search_fd>
40007ed4: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40007ed8: 80 a2 20 00 cmp %o0, 0
40007edc: 12 80 00 0b bne 40007f08 <aio_cancel+0x194>
40007ee0: 90 02 20 08 add %o0, 8, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007ee4: 90 10 00 1d mov %i5, %o0
40007ee8: 40 00 04 2e call 40008fa0 <pthread_mutex_unlock>
40007eec: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one (EINVAL);
40007ef0: 40 00 26 fa call 40011ad8 <__errno>
40007ef4: 01 00 00 00 nop
40007ef8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40007efc: c2 22 00 00 st %g1, [ %o0 ]
40007f00: 81 c7 e0 08 ret
40007f04: 91 e8 3f ff restore %g0, -1, %o0
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40007f08: 40 00 01 5d call 4000847c <rtems_aio_remove_req>
40007f0c: 92 10 00 19 mov %i1, %o1
40007f10: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007f14: 10 80 00 0b b 40007f40 <aio_cancel+0x1cc>
40007f18: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
40007f1c: 40 00 04 00 call 40008f1c <pthread_mutex_lock>
40007f20: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40007f24: 92 10 00 19 mov %i1, %o1
40007f28: 40 00 01 55 call 4000847c <rtems_aio_remove_req>
40007f2c: 90 06 e0 08 add %i3, 8, %o0
40007f30: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
40007f34: 40 00 04 1b call 40008fa0 <pthread_mutex_unlock>
40007f38: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007f3c: 90 17 60 cc or %i5, 0xcc, %o0
40007f40: 40 00 04 18 call 40008fa0 <pthread_mutex_unlock>
40007f44: 01 00 00 00 nop
return result;
}
return AIO_ALLDONE;
}
40007f48: 81 c7 e0 08 ret
40007f4c: 81 e8 00 00 restore
40007f58 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
40007f58: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
40007f5c: 03 00 00 08 sethi %hi(0x2000), %g1
40007f60: 80 a6 00 01 cmp %i0, %g1
40007f64: 12 80 00 10 bne 40007fa4 <aio_fsync+0x4c>
40007f68: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40007f6c: d0 06 40 00 ld [ %i1 ], %o0
40007f70: 40 00 19 a3 call 4000e5fc <fcntl>
40007f74: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40007f78: 90 0a 20 03 and %o0, 3, %o0
40007f7c: 90 02 3f ff add %o0, -1, %o0
40007f80: 80 a2 20 01 cmp %o0, 1
40007f84: 18 80 00 08 bgu 40007fa4 <aio_fsync+0x4c>
40007f88: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40007f8c: 7f ff f2 0b call 400047b8 <malloc>
40007f90: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40007f94: b0 92 20 00 orcc %o0, 0, %i0
40007f98: 32 80 00 09 bne,a 40007fbc <aio_fsync+0x64> <== ALWAYS TAKEN
40007f9c: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40007fa0: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40007fa4: 82 10 3f ff mov -1, %g1
40007fa8: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
40007fac: 40 00 26 cb call 40011ad8 <__errno>
40007fb0: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
40007fb4: 10 80 00 06 b 40007fcc <aio_fsync+0x74>
40007fb8: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
40007fbc: 82 10 20 03 mov 3, %g1
40007fc0: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
40007fc4: 40 00 01 4e call 400084fc <rtems_aio_enqueue>
40007fc8: 81 e8 00 00 restore
}
40007fcc: 81 c7 e0 08 ret
40007fd0: 91 e8 3f ff restore %g0, -1, %o0
40008714 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
40008714: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40008718: d0 06 00 00 ld [ %i0 ], %o0
4000871c: 92 10 20 03 mov 3, %o1
40008720: 40 00 17 b7 call 4000e5fc <fcntl>
40008724: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40008728: 80 8a 20 01 btst 1, %o0
4000872c: 12 80 00 11 bne 40008770 <aio_read+0x5c>
40008730: 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)
40008734: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40008738: 80 a0 60 00 cmp %g1, 0
4000873c: 22 80 00 04 be,a 4000874c <aio_read+0x38>
40008740: 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);
40008744: 10 80 00 0b b 40008770 <aio_read+0x5c>
40008748: 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)
4000874c: 80 a0 60 00 cmp %g1, 0
40008750: 06 80 00 08 bl 40008770 <aio_read+0x5c>
40008754: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40008758: 7f ff f0 18 call 400047b8 <malloc>
4000875c: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40008760: b0 92 20 00 orcc %o0, 0, %i0
40008764: 32 80 00 09 bne,a 40008788 <aio_read+0x74> <== ALWAYS TAKEN
40008768: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4000876c: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
40008770: 82 10 3f ff mov -1, %g1
40008774: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
40008778: 40 00 24 d8 call 40011ad8 <__errno>
4000877c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
40008780: 10 80 00 06 b 40008798 <aio_read+0x84>
40008784: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
40008788: 82 10 20 01 mov 1, %g1
4000878c: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
40008790: 7f ff ff 5b call 400084fc <rtems_aio_enqueue>
40008794: 81 e8 00 00 restore
}
40008798: 81 c7 e0 08 ret
4000879c: 91 e8 3f ff restore %g0, -1, %o0
400087a8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
400087a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
400087ac: d0 06 00 00 ld [ %i0 ], %o0
400087b0: 40 00 17 93 call 4000e5fc <fcntl>
400087b4: 92 10 20 03 mov 3, %o1
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
400087b8: 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)))
400087bc: 90 0a 20 03 and %o0, 3, %o0
400087c0: 90 02 3f ff add %o0, -1, %o0
400087c4: 80 a2 20 01 cmp %o0, 1
400087c8: 18 80 00 11 bgu 4000880c <aio_write+0x64>
400087cc: 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)
400087d0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400087d4: 80 a0 60 00 cmp %g1, 0
400087d8: 22 80 00 04 be,a 400087e8 <aio_write+0x40>
400087dc: 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);
400087e0: 10 80 00 0b b 4000880c <aio_write+0x64>
400087e4: 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)
400087e8: 80 a0 60 00 cmp %g1, 0
400087ec: 06 80 00 08 bl 4000880c <aio_write+0x64>
400087f0: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
400087f4: 7f ff ef f1 call 400047b8 <malloc>
400087f8: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
400087fc: b0 92 20 00 orcc %o0, 0, %i0
40008800: 32 80 00 09 bne,a 40008824 <aio_write+0x7c> <== ALWAYS TAKEN
40008804: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008808: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
4000880c: 82 10 3f ff mov -1, %g1
40008810: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
40008814: 40 00 24 b1 call 40011ad8 <__errno>
40008818: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
4000881c: 10 80 00 06 b 40008834 <aio_write+0x8c>
40008820: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
40008824: 82 10 20 02 mov 2, %g1
40008828: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
4000882c: 7f ff ff 34 call 400084fc <rtems_aio_enqueue>
40008830: 81 e8 00 00 restore
}
40008834: 81 c7 e0 08 ret
40008838: 91 e8 3f ff restore %g0, -1, %o0
400047d4 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
400047d4: 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(
400047d8: 94 10 20 19 mov 0x19, %o2
400047dc: 92 10 00 18 mov %i0, %o1
400047e0: 90 07 bf c8 add %fp, -56, %o0
400047e4: 17 10 00 4a sethi %hi(0x40012800), %o3
400047e8: 96 12 e3 a0 or %o3, 0x3a0, %o3 ! 40012ba0 <rtems_global_user_env+0x4>
400047ec: 40 00 04 c3 call 40005af8 <rtems_filesystem_eval_path_start_with_root_and_current>
400047f0: 98 02 ff fc add %o3, -4, %o4
400047f4: 90 07 bf b0 add %fp, -80, %o0
400047f8: 40 00 05 da call 40005f60 <rtems_filesystem_location_copy_and_detach>
400047fc: 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 );
40004800: 40 00 06 50 call 40006140 <rtems_filesystem_location_transform_to_global>
40004804: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
40004808: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4000480c: 39 10 00 49 sethi %hi(0x40012400), %i4
40004810: b8 17 20 64 or %i4, 0x64, %i4 ! 40012464 <rtems_filesystem_null_handlers>
40004814: 80 a0 40 1c cmp %g1, %i4
40004818: 02 80 00 29 be 400048bc <chroot+0xe8>
4000481c: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
40004820: 40 00 06 16 call 40006078 <rtems_filesystem_global_location_obtain>
40004824: 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)(
40004828: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000482c: 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 =
40004830: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40004834: 9f c0 40 00 call %g1
40004838: 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 ) {
4000483c: 80 a2 20 00 cmp %o0, 0
40004840: 32 80 00 17 bne,a 4000489c <chroot+0xc8>
40004844: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
40004848: 40 00 03 1d call 400054bc <rtems_libio_set_private_env>
4000484c: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
40004850: 80 a2 20 00 cmp %o0, 0
40004854: 12 80 00 0c bne 40004884 <chroot+0xb0>
40004858: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
4000485c: 39 10 00 4a sethi %hi(0x40012800), %i4
40004860: d0 07 23 98 ld [ %i4 + 0x398 ], %o0 ! 40012b98 <rtems_current_user_env>
40004864: 92 10 00 1d mov %i5, %o1
40004868: 40 00 05 fb call 40006054 <rtems_filesystem_global_location_assign>
4000486c: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
40004870: d0 07 23 98 ld [ %i4 + 0x398 ], %o0
40004874: d2 07 bf ac ld [ %fp + -84 ], %o1
40004878: 40 00 05 f7 call 40006054 <rtems_filesystem_global_location_assign>
4000487c: b0 10 20 00 clr %i0
40004880: 30 80 00 10 b,a 400048c0 <chroot+0xec>
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
40004884: 02 80 00 18 be 400048e4 <chroot+0x110> <== NEVER TAKEN
40004888: 01 00 00 00 nop
errno = ENOMEM;
4000488c: 40 00 1f 6b call 4000c638 <__errno>
40004890: 01 00 00 00 nop
40004894: 10 80 00 08 b 400048b4 <chroot+0xe0>
40004898: 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 ) ) {
4000489c: 80 a0 40 1c cmp %g1, %i4
400048a0: 02 80 00 11 be 400048e4 <chroot+0x110> <== NEVER TAKEN
400048a4: 01 00 00 00 nop
errno = eno;
400048a8: 40 00 1f 64 call 4000c638 <__errno>
400048ac: 01 00 00 00 nop
400048b0: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
400048b4: 10 80 00 0c b 400048e4 <chroot+0x110>
400048b8: c2 22 00 00 st %g1, [ %o0 ]
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
}
} else {
rv = -1;
400048bc: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
400048c0: 40 00 04 d4 call 40005c10 <rtems_filesystem_eval_path_cleanup>
400048c4: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
400048c8: 80 a6 20 00 cmp %i0, 0
400048cc: 02 80 00 0a be 400048f4 <chroot+0x120>
400048d0: 01 00 00 00 nop
rtems_filesystem_global_location_release( new_current_loc );
400048d4: 40 00 05 c8 call 40005ff4 <rtems_filesystem_global_location_release>
400048d8: d0 07 bf ac ld [ %fp + -84 ], %o0
400048dc: 81 c7 e0 08 ret
400048e0: 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 );
400048e4: 40 00 05 c4 call 40005ff4 <rtems_filesystem_global_location_release>
400048e8: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
400048ec: 10 bf ff f5 b 400048c0 <chroot+0xec>
400048f0: b0 10 3f ff mov -1, %i0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
}
return rv;
}
400048f4: 81 c7 e0 08 ret
400048f8: 81 e8 00 00 restore
40007990 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40007990: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40007994: 80 a6 60 00 cmp %i1, 0
40007998: 02 80 00 26 be 40007a30 <clock_gettime+0xa0>
4000799c: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
400079a0: 12 80 00 16 bne 400079f8 <clock_gettime+0x68>
400079a4: 80 a6 20 04 cmp %i0, 4
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
400079a8: 90 07 bf f8 add %fp, -8, %o0
400079ac: 13 10 00 6a sethi %hi(0x4001a800), %o1
400079b0: 40 00 08 1d call 40009a24 <_TOD_Get_with_nanoseconds>
400079b4: 92 12 60 48 or %o1, 0x48, %o1 ! 4001a848 <_TOD>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
400079b8: 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);
400079bc: 94 10 20 00 clr %o2
400079c0: 90 10 00 1c mov %i4, %o0
400079c4: 92 10 00 1d mov %i5, %o1
400079c8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400079cc: 40 00 3c 14 call 40016a1c <__divdi3>
400079d0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
400079d4: 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);
400079d8: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
400079dc: 94 10 20 00 clr %o2
400079e0: 92 10 00 1d mov %i5, %o1
400079e4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400079e8: 40 00 3c f8 call 40016dc8 <__moddi3>
400079ec: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
400079f0: 10 80 00 06 b 40007a08 <clock_gettime+0x78>
400079f4: 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 ) {
400079f8: 12 80 00 06 bne 40007a10 <clock_gettime+0x80> <== ALWAYS TAKEN
400079fc: 80 a6 20 02 cmp %i0, 2
_TOD_Get_uptime_as_timespec( tp );
40007a00: 40 00 08 1a call 40009a68 <_TOD_Get_uptime_as_timespec>
40007a04: 90 10 00 19 mov %i1, %o0
return 0;
40007a08: 81 c7 e0 08 ret
40007a0c: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40007a10: 02 bf ff fc be 40007a00 <clock_gettime+0x70>
40007a14: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
40007a18: 12 80 00 06 bne 40007a30 <clock_gettime+0xa0>
40007a1c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
40007a20: 40 00 23 6d call 400107d4 <__errno>
40007a24: 01 00 00 00 nop
40007a28: 10 80 00 05 b 40007a3c <clock_gettime+0xac>
40007a2c: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40007a30: 40 00 23 69 call 400107d4 <__errno>
40007a34: 01 00 00 00 nop
40007a38: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40007a3c: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
40007a40: 81 c7 e0 08 ret
40007a44: 91 e8 3f ff restore %g0, -1, %o0
40025ef4 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
40025ef4: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40025ef8: 82 96 60 00 orcc %i1, 0, %g1
40025efc: 02 80 00 4b be 40026028 <clock_settime+0x134> <== NEVER TAKEN
40025f00: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40025f04: 12 80 00 41 bne 40026008 <clock_settime+0x114>
40025f08: 80 a6 20 02 cmp %i0, 2
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
40025f0c: c6 00 40 00 ld [ %g1 ], %g3
40025f10: 05 08 76 b9 sethi %hi(0x21dae400), %g2
40025f14: 84 10 a0 ff or %g2, 0xff, %g2 ! 21dae4ff <RAM_SIZE+0x219ae4ff>
40025f18: 80 a0 c0 02 cmp %g3, %g2
40025f1c: 08 80 00 43 bleu 40026028 <clock_settime+0x134>
40025f20: 05 10 01 91 sethi %hi(0x40064400), %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;
40025f24: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 ! 40064430 <_Thread_Dispatch_disable_level>
++level;
40025f28: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
40025f2c: c6 20 a0 30 st %g3, [ %g2 + 0x30 ]
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40025f30: 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 );
40025f34: 90 07 bf f8 add %fp, -8, %o0
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40025f38: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
40025f3c: 89 28 a0 03 sll %g2, 3, %g4
40025f40: bb 28 e0 03 sll %g3, 3, %i5
40025f44: b7 30 e0 1d srl %g3, 0x1d, %i3
40025f48: b8 16 c0 04 or %i3, %g4, %i4
40025f4c: 89 37 60 1b srl %i5, 0x1b, %g4
40025f50: b5 2f 20 05 sll %i4, 5, %i2
40025f54: b7 2f 60 05 sll %i5, 5, %i3
40025f58: b4 11 00 1a or %g4, %i2, %i2
40025f5c: ba a6 c0 1d subcc %i3, %i5, %i5
40025f60: 89 37 60 1a srl %i5, 0x1a, %g4
40025f64: b8 66 80 1c subx %i2, %i4, %i4
40025f68: b7 2f 60 06 sll %i5, 6, %i3
40025f6c: b5 2f 20 06 sll %i4, 6, %i2
40025f70: b6 a6 c0 1d subcc %i3, %i5, %i3
40025f74: b4 11 00 1a or %g4, %i2, %i2
40025f78: b4 66 80 1c subx %i2, %i4, %i2
40025f7c: b2 86 c0 03 addcc %i3, %g3, %i1
40025f80: b0 46 80 02 addx %i2, %g2, %i0
40025f84: 89 36 60 1e srl %i1, 0x1e, %g4
40025f88: 85 2e 20 02 sll %i0, 2, %g2
40025f8c: 84 11 00 02 or %g4, %g2, %g2
40025f90: 87 2e 60 02 sll %i1, 2, %g3
40025f94: ba 86 40 03 addcc %i1, %g3, %i5
40025f98: b8 46 00 02 addx %i0, %g2, %i4
40025f9c: 89 37 60 1e srl %i5, 0x1e, %g4
40025fa0: 85 2f 20 02 sll %i4, 2, %g2
40025fa4: 84 11 00 02 or %g4, %g2, %g2
40025fa8: 87 2f 60 02 sll %i5, 2, %g3
40025fac: b6 87 40 03 addcc %i5, %g3, %i3
40025fb0: b4 47 00 02 addx %i4, %g2, %i2
40025fb4: bb 2e e0 02 sll %i3, 2, %i5
40025fb8: 85 36 e0 1e srl %i3, 0x1e, %g2
40025fbc: 86 86 c0 1d addcc %i3, %i5, %g3
40025fc0: b9 2e a0 02 sll %i2, 2, %i4
40025fc4: b8 10 80 1c or %g2, %i4, %i4
40025fc8: 84 46 80 1c addx %i2, %i4, %g2
40025fcc: bb 28 a0 09 sll %g2, 9, %i5
40025fd0: b9 30 e0 17 srl %g3, 0x17, %i4
40025fd4: 84 17 00 1d or %i4, %i5, %g2
40025fd8: fa 00 60 04 ld [ %g1 + 4 ], %i5
40025fdc: 89 28 e0 09 sll %g3, 9, %g4
40025fe0: b6 81 00 1d addcc %g4, %i5, %i3
40025fe4: 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;
40025fe8: b0 10 20 00 clr %i0
40025fec: 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 );
40025ff0: 40 00 04 4d call 40027124 <_TOD_Set_with_timestamp>
40025ff4: 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();
40025ff8: 7f ff 90 77 call 4000a1d4 <_Thread_Enable_dispatch>
40025ffc: 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;
40026000: 81 c7 e0 08 ret
40026004: 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 )
40026008: 02 80 00 04 be 40026018 <clock_settime+0x124>
4002600c: 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 )
40026010: 12 80 00 06 bne 40026028 <clock_settime+0x134>
40026014: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
40026018: 40 00 44 a0 call 40037298 <__errno>
4002601c: 01 00 00 00 nop
40026020: 10 80 00 05 b 40026034 <clock_settime+0x140>
40026024: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
40026028: 40 00 44 9c call 40037298 <__errno>
4002602c: 01 00 00 00 nop
40026030: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40026034: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
40026038: 81 c7 e0 08 ret
4002603c: 91 e8 3f ff restore %g0, -1, %o0
400041d0 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
400041d0: 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) {
400041d4: 03 10 00 6c sethi %hi(0x4001b000), %g1
400041d8: e0 00 63 10 ld [ %g1 + 0x310 ], %l0 ! 4001b310 <disktab_size>
400041dc: 80 a6 00 10 cmp %i0, %l0
400041e0: 0a 80 00 16 bcs 40004238 <create_disk+0x68>
400041e4: 03 10 00 6c sethi %hi(0x4001b000), %g1
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
400041e8: bb 2c 20 01 sll %l0, 1, %i5
if (major >= new_size) {
400041ec: 80 a6 00 1d cmp %i0, %i5
400041f0: 0a 80 00 03 bcs 400041fc <create_disk+0x2c> <== NEVER TAKEN
400041f4: d0 00 63 14 ld [ %g1 + 0x314 ], %o0
new_size = major + 1;
400041f8: ba 06 20 01 add %i0, 1, %i5
}
table = realloc(table, new_size * sizeof(*table));
400041fc: 40 00 07 ce call 40006134 <realloc>
40004200: 93 2f 60 03 sll %i5, 3, %o1
if (table == NULL) {
40004204: a2 92 20 00 orcc %o0, 0, %l1
40004208: 02 80 00 58 be 40004368 <create_disk+0x198> <== ALWAYS TAKEN
4000420c: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40004210: 91 2c 20 03 sll %l0, 3, %o0 <== NOT EXECUTED
40004214: 92 10 20 00 clr %o1 <== NOT EXECUTED
40004218: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
4000421c: 40 00 42 35 call 40014af0 <memset> <== NOT EXECUTED
40004220: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
40004224: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED
40004228: e2 20 63 14 st %l1, [ %g1 + 0x314 ] ! 4001b314 <disktab> <== NOT EXECUTED
disktab_size = new_size;
4000422c: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED
40004230: fa 20 63 10 st %i5, [ %g1 + 0x310 ] ! 4001b310 <disktab_size><== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
40004234: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED
40004238: e4 00 63 14 ld [ %g1 + 0x314 ], %l2 ! 4001b314 <disktab>
4000423c: a3 2e 20 03 sll %i0, 3, %l1
40004240: d0 04 80 11 ld [ %l2 + %l1 ], %o0
40004244: a8 04 80 11 add %l2, %l1, %l4
40004248: 80 a2 20 00 cmp %o0, 0
4000424c: 02 80 00 05 be 40004260 <create_disk+0x90>
40004250: e0 05 20 04 ld [ %l4 + 4 ], %l0
40004254: 80 a6 40 10 cmp %i1, %l0
40004258: 2a 80 00 16 bcs,a 400042b0 <create_disk+0xe0>
4000425c: 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) {
40004260: 80 a4 20 00 cmp %l0, 0
40004264: 02 80 00 03 be 40004270 <create_disk+0xa0>
40004268: ba 10 20 08 mov 8, %i5
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
4000426c: bb 2c 20 01 sll %l0, 1, %i5
}
if (minor >= new_size) {
40004270: 80 a6 40 1d cmp %i1, %i5
40004274: 3a 80 00 02 bcc,a 4000427c <create_disk+0xac>
40004278: ba 06 60 01 add %i1, 1, %i5
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
4000427c: 40 00 07 ae call 40006134 <realloc>
40004280: 93 2f 60 02 sll %i5, 2, %o1
if (table == NULL) {
40004284: a6 92 20 00 orcc %o0, 0, %l3
40004288: 02 80 00 38 be 40004368 <create_disk+0x198>
4000428c: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40004290: 91 2c 20 02 sll %l0, 2, %o0
40004294: 92 10 20 00 clr %o1
40004298: 90 04 c0 08 add %l3, %o0, %o0
4000429c: 40 00 42 15 call 40014af0 <memset>
400042a0: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
400042a4: e6 24 80 11 st %l3, [ %l2 + %l1 ]
disktab [major].size = new_size;
400042a8: fa 25 20 04 st %i5, [ %l4 + 4 ]
}
return disktab [major].minor + minor;
400042ac: e2 04 80 11 ld [ %l2 + %l1 ], %l1
400042b0: a1 2e 60 02 sll %i1, 2, %l0
400042b4: 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) {
400042b8: 80 a0 60 00 cmp %g1, 0
400042bc: 32 80 00 04 bne,a 400042cc <create_disk+0xfc> <== ALWAYS TAKEN
400042c0: c4 04 40 10 ld [ %l1 + %l0 ], %g2
return RTEMS_NO_MEMORY;
400042c4: 10 80 00 2a b 4000436c <create_disk+0x19c> <== NOT EXECUTED
400042c8: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
if (*dd_entry != NULL) {
400042cc: 80 a0 a0 00 cmp %g2, 0
400042d0: 12 80 00 27 bne 4000436c <create_disk+0x19c>
400042d4: 82 10 20 0c mov 0xc, %g1
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
400042d8: 40 00 04 f5 call 400056ac <malloc>
400042dc: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
400042e0: ba 92 20 00 orcc %o0, 0, %i5
400042e4: 02 80 00 21 be 40004368 <create_disk+0x198> <== NEVER TAKEN
400042e8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
400042ec: 02 80 00 11 be 40004330 <create_disk+0x160>
400042f0: a4 10 20 00 clr %l2
alloc_name = strdup(name);
400042f4: 40 00 42 d9 call 40014e58 <strdup>
400042f8: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
400042fc: a4 92 20 00 orcc %o0, 0, %l2
40004300: 12 80 00 11 bne 40004344 <create_disk+0x174> <== ALWAYS TAKEN
40004304: b4 10 00 08 mov %o0, %i2
free(dd);
40004308: 40 00 03 a8 call 400051a8 <free> <== NOT EXECUTED
4000430c: 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;
40004310: 10 80 00 17 b 4000436c <create_disk+0x19c> <== NOT EXECUTED
40004314: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
40004318: 40 00 03 a4 call 400051a8 <free> <== NOT EXECUTED
4000431c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
40004320: 40 00 03 a2 call 400051a8 <free> <== NOT EXECUTED
40004324: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
40004328: 10 80 00 11 b 4000436c <create_disk+0x19c> <== NOT EXECUTED
4000432c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
}
}
*dd_entry = dd;
40004330: fa 24 40 10 st %i5, [ %l1 + %l0 ]
*dd_ptr = dd;
40004334: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
40004338: e4 27 00 00 st %l2, [ %i4 ]
return RTEMS_SUCCESSFUL;
4000433c: 10 80 00 0c b 4000436c <create_disk+0x19c>
40004340: 82 10 20 00 clr %g1
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
40004344: 13 00 00 18 sethi %hi(0x6000), %o1
40004348: 94 10 00 18 mov %i0, %o2
4000434c: 92 12 61 ff or %o1, 0x1ff, %o1
40004350: 40 00 05 47 call 4000586c <mknod>
40004354: 96 10 00 19 mov %i1, %o3
40004358: 80 a2 20 00 cmp %o0, 0
4000435c: 36 bf ff f6 bge,a 40004334 <create_disk+0x164> <== ALWAYS TAKEN
40004360: fa 24 40 10 st %i5, [ %l1 + %l0 ]
40004364: 30 bf ff ed b,a 40004318 <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;
40004368: 82 10 20 1a mov 0x1a, %g1
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
4000436c: 81 c7 e0 08 ret
40004370: 91 e8 00 01 restore %g0, %g1, %o0
40005330 <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)
40005330: 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)
40005334: 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)
40005338: b8 10 00 18 mov %i0, %i4
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
4000533c: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
40005340: 92 10 20 28 mov 0x28, %o1
40005344: 40 00 03 1a call 40005fac <calloc>
40005348: b0 10 20 1a mov 0x1a, %i0
4000534c: 80 a2 20 00 cmp %o0, 0
40005350: 02 80 00 27 be 400053ec <data_to_part_desc.part.1+0xbc> <== NEVER TAKEN
40005354: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
40005358: 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));
4000535c: 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);
40005360: c2 2a 00 00 stb %g1, [ %o0 ]
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
40005364: 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));
40005368: 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);
4000536c: 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));
40005370: 40 00 41 ba call 40015a58 <memcpy>
40005374: 90 07 bf fc add %fp, -4, %o0
part_desc->start = LE_TO_CPU_U32(temp);
40005378: 7f ff ff ac call 40005228 <CPU_swap_u32>
4000537c: d0 07 bf fc ld [ %fp + -4 ], %o0
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40005380: 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);
40005384: d0 27 60 04 st %o0, [ %i5 + 4 ]
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40005388: 94 10 20 04 mov 4, %o2
4000538c: 40 00 41 b3 call 40015a58 <memcpy>
40005390: 90 07 bf fc add %fp, -4, %o0
part_desc->size = LE_TO_CPU_U32(temp);
40005394: 7f ff ff a5 call 40005228 <CPU_swap_u32>
40005398: d0 07 bf fc ld [ %fp + -4 ], %o0
4000539c: 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) ||
400053a0: 82 0e e0 7f and %i3, 0x7f, %g1
400053a4: 80 a0 60 05 cmp %g1, 5
400053a8: 02 80 00 0c be 400053d8 <data_to_part_desc.part.1+0xa8>
400053ac: 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)));
400053b0: 11 10 00 94 sethi %hi(0x40025000), %o0
400053b4: 92 0e e0 ff and %i3, 0xff, %o1
400053b8: 90 12 22 80 or %o0, 0x280, %o0
400053bc: 40 00 41 39 call 400158a0 <memchr>
400053c0: 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) ||
400053c4: 80 a2 20 00 cmp %o0, 0
400053c8: 02 80 00 06 be 400053e0 <data_to_part_desc.part.1+0xb0>
400053cc: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
400053d0: 02 80 00 04 be 400053e0 <data_to_part_desc.part.1+0xb0> <== NEVER TAKEN
400053d4: 01 00 00 00 nop
*new_part_desc = part_desc;
400053d8: 10 80 00 04 b 400053e8 <data_to_part_desc.part.1+0xb8>
400053dc: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
400053e0: 40 00 03 2b call 4000608c <free>
400053e4: 90 10 00 1d mov %i5, %o0
}
return RTEMS_SUCCESSFUL;
400053e8: b0 10 20 00 clr %i0
}
400053ec: 81 c7 e0 08 ret
400053f0: 81 e8 00 00 restore
40003460 <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
40003460: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
40003464: 03 10 00 4e sethi %hi(0x40013800), %g1
40003468: c2 00 62 5c ld [ %g1 + 0x25c ], %g1 ! 40013a5c <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
4000346c: 05 10 00 4b sethi %hi(0x40012c00), %g2
40003470: c2 00 60 04 ld [ %g1 + 4 ], %g1
40003474: 84 10 a0 e4 or %g2, 0xe4, %g2
40003478: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
4000347c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40003480: 80 a0 c0 02 cmp %g3, %g2
40003484: 12 80 00 25 bne 40003518 <devFS_Show+0xb8> <== NEVER TAKEN
40003488: 33 10 00 4b sethi %hi(0x40012c00), %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;
4000348c: 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]);
40003490: 31 10 00 4b sethi %hi(0x40012c00), %i0
}
printk(
40003494: 21 10 00 4b sethi %hi(0x40012c00), %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;
40003498: f4 00 60 04 ld [ %g1 + 4 ], %i2
4000349c: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
400034a0: b6 10 20 00 clr %i3
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
400034a4: b2 16 61 38 or %i1, 0x138, %i1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
400034a8: b0 16 21 40 or %i0, 0x140, %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) {
400034ac: 10 80 00 18 b 4000350c <devFS_Show+0xac>
400034b0: a0 14 21 48 or %l0, 0x148, %l0
devFS_node *current = nodes + i;
if (current->name != NULL) {
400034b4: 80 a0 60 00 cmp %g1, 0
400034b8: 22 80 00 14 be,a 40003508 <devFS_Show+0xa8>
400034bc: b6 06 e0 01 inc %i3
size_t j = 0;
size_t m = current->namelen;
400034c0: e2 07 60 04 ld [ %i5 + 4 ], %l1
printk("/");
400034c4: 90 10 00 19 mov %i1, %o0
400034c8: 40 00 03 d1 call 4000440c <printk>
400034cc: b8 10 20 00 clr %i4
for (j = 0; j < m; ++j) {
400034d0: 10 80 00 07 b 400034ec <devFS_Show+0x8c>
400034d4: 80 a7 00 11 cmp %i4, %l1
printk("%c", current->name [j]);
400034d8: 90 10 00 18 mov %i0, %o0
400034dc: d2 48 40 1c ldsb [ %g1 + %i4 ], %o1
400034e0: 40 00 03 cb call 4000440c <printk>
400034e4: 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) {
400034e8: 80 a7 00 11 cmp %i4, %l1
400034ec: 32 bf ff fb bne,a 400034d8 <devFS_Show+0x78>
400034f0: c2 07 40 00 ld [ %i5 ], %g1
printk("%c", current->name [j]);
}
printk(
400034f4: d2 07 60 08 ld [ %i5 + 8 ], %o1
400034f8: d4 07 60 0c ld [ %i5 + 0xc ], %o2
400034fc: 40 00 03 c4 call 4000440c <printk>
40003500: 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) {
40003504: b6 06 e0 01 inc %i3
40003508: ba 07 60 14 add %i5, 0x14, %i5
4000350c: 80 a6 c0 1a cmp %i3, %i2
40003510: 32 bf ff e9 bne,a 400034b4 <devFS_Show+0x54>
40003514: c2 07 40 00 ld [ %i5 ], %g1
40003518: 81 c7 e0 08 ret
4000351c: 81 e8 00 00 restore
4000d24c <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
4000d24c: 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;
4000d250: 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;
4000d254: f2 06 00 00 ld [ %i0 ], %i1
4000d258: 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;
4000d25c: 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;
4000d260: e2 00 60 04 ld [ %g1 + 4 ], %l1
4000d264: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
4000d268: b8 10 20 00 clr %i4
devFS_node *free_node = NULL;
4000d26c: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000d270: 10 80 00 12 b 4000d2b8 <devFS_eval_path+0x6c>
4000d274: b4 10 20 00 clr %i2
devFS_node *current = nodes + i;
if (current->name != NULL) {
4000d278: 80 a2 20 00 cmp %o0, 0
4000d27c: 02 80 00 0c be 4000d2ac <devFS_eval_path+0x60>
4000d280: a0 10 00 1d mov %i5, %l0
if (
4000d284: c4 07 60 04 ld [ %i5 + 4 ], %g2
4000d288: 80 a0 80 1b cmp %g2, %i3
4000d28c: 12 80 00 08 bne 4000d2ac <devFS_eval_path+0x60>
4000d290: a0 10 00 01 mov %g1, %l0
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
4000d294: 92 10 00 19 mov %i1, %o1
4000d298: 40 00 0c 6f call 40010454 <memcmp>
4000d29c: 94 10 00 1b mov %i3, %o2
4000d2a0: 80 a2 20 00 cmp %o0, 0
4000d2a4: 22 80 00 02 be,a 4000d2ac <devFS_eval_path+0x60>
4000d2a8: 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) {
4000d2ac: b4 06 a0 01 inc %i2
4000d2b0: ba 07 60 14 add %i5, 0x14, %i5
4000d2b4: 82 10 00 10 mov %l0, %g1
4000d2b8: 80 a7 20 00 cmp %i4, 0
4000d2bc: 02 80 00 0a be 4000d2e4 <devFS_eval_path+0x98>
4000d2c0: 80 a6 80 11 cmp %i2, %l1
4000d2c4: 80 a0 60 00 cmp %g1, 0
4000d2c8: 02 80 00 07 be 4000d2e4 <devFS_eval_path+0x98> <== NEVER TAKEN
4000d2cc: 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) {
4000d2d0: 80 a7 20 00 cmp %i4, 0
4000d2d4: 12 80 00 08 bne 4000d2f4 <devFS_eval_path+0xa8>
4000d2d8: 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) {
4000d2dc: 10 80 00 0b b 4000d308 <devFS_eval_path+0xbc>
4000d2e0: 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) {
4000d2e4: 32 bf ff e5 bne,a 4000d278 <devFS_eval_path+0x2c>
4000d2e8: 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) {
4000d2ec: 10 bf ff fa b 4000d2d4 <devFS_eval_path+0x88>
4000d2f0: 80 a7 20 00 cmp %i4, 0
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
4000d2f4: 80 88 a0 40 btst 0x40, %g2
4000d2f8: 12 80 00 12 bne 4000d340 <devFS_eval_path+0xf4>
4000d2fc: b2 10 20 11 mov 0x11, %i1
currentloc->node_access = node;
4000d300: 10 80 00 0a b 4000d328 <devFS_eval_path+0xdc>
4000d304: 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) {
4000d308: 02 80 00 0d be 4000d33c <devFS_eval_path+0xf0> <== NEVER TAKEN
4000d30c: 80 a0 60 00 cmp %g1, 0
if (free_node != NULL) {
4000d310: 02 80 00 09 be 4000d334 <devFS_eval_path+0xe8>
4000d314: 84 10 21 ff mov 0x1ff, %g2
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
4000d318: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
currentloc->node_access = free_node;
4000d31c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
4000d320: f2 26 20 08 st %i1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
4000d324: 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;
4000d328: c0 26 20 04 clr [ %i0 + 4 ]
4000d32c: 81 c7 e0 08 ret
4000d330: 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);
4000d334: 10 80 00 03 b 4000d340 <devFS_eval_path+0xf4>
4000d338: b2 10 20 1c mov 0x1c, %i1
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000d33c: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
4000d340: 7f ff e3 b6 call 40006218 <rtems_filesystem_eval_path_error>
4000d344: 81 e8 00 00 restore
40004ffc <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40004ffc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
40005000: 80 a6 a0 03 cmp %i2, 3
40005004: 12 80 00 0e bne 4000503c <devFS_mknod+0x40>
40005008: 05 00 00 2c sethi %hi(0xb000), %g2
4000500c: c2 4e 40 00 ldsb [ %i1 ], %g1
40005010: 80 a0 60 64 cmp %g1, 0x64
40005014: 12 80 00 0b bne 40005040 <devFS_mknod+0x44> <== NEVER TAKEN
40005018: 03 00 00 08 sethi %hi(0x2000), %g1
4000501c: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
40005020: 80 a0 60 65 cmp %g1, 0x65
40005024: 12 80 00 07 bne 40005040 <devFS_mknod+0x44> <== NEVER TAKEN
40005028: 03 00 00 08 sethi %hi(0x2000), %g1
4000502c: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
40005030: 80 a0 60 76 cmp %g1, 0x76
40005034: 02 80 00 1b be 400050a0 <devFS_mknod+0xa4> <== ALWAYS TAKEN
40005038: 03 00 00 3c sethi %hi(0xf000), %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
4000503c: 03 00 00 08 sethi %hi(0x2000), %g1
40005040: 84 0e c0 02 and %i3, %g2, %g2
40005044: 80 a0 80 01 cmp %g2, %g1
40005048: 12 80 00 1b bne 400050b4 <devFS_mknod+0xb8>
4000504c: 01 00 00 00 nop
char *dupname = malloc(namelen);
40005050: 40 00 01 47 call 4000556c <malloc>
40005054: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
40005058: 84 92 20 00 orcc %o0, 0, %g2
4000505c: 02 80 00 0d be 40005090 <devFS_mknod+0x94>
40005060: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
40005064: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
40005068: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
4000506c: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
40005070: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
40005074: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
40005078: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
4000507c: 94 10 00 1a mov %i2, %o2
40005080: 40 00 2d 1f call 400104fc <memcpy>
40005084: b0 10 20 00 clr %i0
40005088: 81 c7 e0 08 ret
4000508c: 81 e8 00 00 restore
} else {
errno = ENOMEM;
40005090: 40 00 29 16 call 4000f4e8 <__errno>
40005094: 01 00 00 00 nop
40005098: 10 80 00 0a b 400050c0 <devFS_mknod+0xc4>
4000509c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
400050a0: b6 0e c0 01 and %i3, %g1, %i3
400050a4: 03 00 00 10 sethi %hi(0x4000), %g1
400050a8: 80 a6 c0 01 cmp %i3, %g1
400050ac: 02 bf ff f7 be 40005088 <devFS_mknod+0x8c> <== ALWAYS TAKEN
400050b0: b0 10 20 00 clr %i0
errno = ENOTSUP;
400050b4: 40 00 29 0d call 4000f4e8 <__errno>
400050b8: 01 00 00 00 nop
400050bc: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
400050c0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
400050c4: b0 10 3f ff mov -1, %i0
}
}
return rv;
}
400050c8: 81 c7 e0 08 ret
400050cc: 81 e8 00 00 restore
40004160 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
40004160: 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);
40004164: 03 10 00 6c sethi %hi(0x4001b000), %g1
40004168: d0 00 63 0c ld [ %g1 + 0x30c ], %o0 ! 4001b30c <diskdevs_mutex>
4000416c: 92 10 20 00 clr %o1
40004170: 94 10 20 00 clr %o2
40004174: 40 00 14 b8 call 40009454 <rtems_semaphore_obtain>
40004178: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
4000417c: 80 a2 20 00 cmp %o0, 0
40004180: 12 80 00 05 bne 40004194 <disk_lock+0x34> <== NEVER TAKEN
40004184: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
40004188: 03 10 00 6c sethi %hi(0x4001b000), %g1
return RTEMS_SUCCESSFUL;
4000418c: 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;
40004190: c4 28 63 08 stb %g2, [ %g1 + 0x308 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
40004194: 81 c7 e0 08 ret
40004198: 81 e8 00 00 restore
4000419c <disk_unlock>:
static void
disk_unlock(void)
{
4000419c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
400041a0: 03 10 00 6c sethi %hi(0x4001b000), %g1
400041a4: c0 28 63 08 clrb [ %g1 + 0x308 ] ! 4001b308 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
400041a8: 03 10 00 6c sethi %hi(0x4001b000), %g1
400041ac: 40 00 14 f3 call 40009578 <rtems_semaphore_release>
400041b0: d0 00 63 0c ld [ %g1 + 0x30c ], %o0 ! 4001b30c <diskdevs_mutex>
if (sc != RTEMS_SUCCESSFUL) {
400041b4: 80 a2 20 00 cmp %o0, 0
400041b8: 02 80 00 04 be 400041c8 <disk_unlock+0x2c> <== ALWAYS TAKEN
400041bc: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
400041c0: 40 00 16 58 call 40009b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
400041c4: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
400041c8: 81 c7 e0 08 ret
400041cc: 81 e8 00 00 restore
40005a84 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
40005a84: 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);
40005a88: 7f ff f2 70 call 40002448 <sparc_disable_interrupts>
40005a8c: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
40005a90: 10 80 00 0f b 40005acc <drainOutput.part.0+0x48>
40005a94: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2>
rtems_interrupt_enable (level);
40005a98: 7f ff f2 70 call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
40005a9c: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
40005aa0: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
40005aa4: 92 10 20 00 clr %o1 <== NOT EXECUTED
40005aa8: 40 00 09 50 call 40007fe8 <rtems_semaphore_obtain> <== NOT EXECUTED
40005aac: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005ab0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005ab4: 02 80 00 04 be 40005ac4 <drainOutput.part.0+0x40> <== NOT EXECUTED
40005ab8: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40005abc: 40 00 0b 28 call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
40005ac0: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
40005ac4: 7f ff f2 61 call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
40005ac8: 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) {
40005acc: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
40005ad0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40005ad4: 80 a0 80 01 cmp %g2, %g1
40005ad8: 32 bf ff f0 bne,a 40005a98 <drainOutput.part.0+0x14> <== NEVER TAKEN
40005adc: 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);
40005ae0: 7f ff f2 5e call 40002458 <sparc_enable_interrupts>
40005ae4: 91 e8 00 08 restore %g0, %o0, %o0
40004500 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
40004500: 92 10 20 00 clr %o1
40004504: 94 10 20 00 clr %o2
40004508: 82 13 c0 00 mov %o7, %g1
4000450c: 40 00 00 0c call 4000453c <fcntl>
40004510: 9e 10 40 00 mov %g1, %o7
40004514: 40 00 45 bc call 40015c04 <__umoddi3+0x2d8> <== NOT EXECUTED
40004518: 40 00 46 98 call 40015f78 <_CPU_cache_invalidate_entire_instruction+0x8><== NOT EXECUTED
4000451c: 40 00 46 a4 call 40015fac <rtems_cache_flush_multiple_data_lines+0x4><== NOT EXECUTED
40004520: 40 00 46 bc call 40016010 <rtems_cache_freeze_instruction+0x4><== NOT EXECUTED
40004524: 40 00 46 cc call 40016054 <_isatty_r+0x8> <== NOT EXECUTED
40004528: 40 00 46 f0 call 400160e8 <_exit+0xc> <== NOT EXECUTED
4000452c: 40 00 46 f0 call 400160ec <_exit+0x10> <== NOT EXECUTED
40004530: 40 00 46 f0 call 400160f0 <_exit+0x14> <== NOT EXECUTED
40004534: 40 00 46 f0 call 400160f4 <_exit+0x18> <== NOT EXECUTED
40004538: 40 00 46 f0 call 400160f8 <_exit+0x1c> <== NOT EXECUTED
400044b4 <dup2>:
*/
int dup2(
int fildes,
int fildes2
)
{
400044b4: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
400044b8: 90 10 00 18 mov %i0, %o0
400044bc: 40 00 01 46 call 400049d4 <fstat>
400044c0: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
400044c4: 80 a2 3f ff cmp %o0, -1
400044c8: 12 80 00 04 bne 400044d8 <dup2+0x24>
400044cc: 90 10 00 19 mov %i1, %o0
return -1;
400044d0: 81 c7 e0 08 ret
400044d4: 91 e8 3f ff restore %g0, -1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
400044d8: 40 00 01 3f call 400049d4 <fstat>
400044dc: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
400044e0: 80 a2 3f ff cmp %o0, -1
400044e4: 02 bf ff fb be 400044d0 <dup2+0x1c> <== NEVER TAKEN
400044e8: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
400044ec: 92 10 20 00 clr %o1
400044f0: 40 00 00 13 call 4000453c <fcntl>
400044f4: 94 10 00 19 mov %i1, %o2
}
400044f8: 81 c7 e0 08 ret
400044fc: 91 e8 00 08 restore %g0, %o0, %o0
40006870 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
40006870: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
40006874: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006878: 80 88 62 00 btst 0x200, %g1
4000687c: 02 80 00 19 be 400068e0 <echo+0x70> <== NEVER TAKEN
40006880: 03 10 00 7a sethi %hi(0x4001e800), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
40006884: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 4001e930 <__ctype_ptr__>
40006888: 82 00 40 18 add %g1, %i0, %g1
4000688c: 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) &&
40006890: 80 88 60 20 btst 0x20, %g1
40006894: 02 80 00 14 be 400068e4 <echo+0x74>
40006898: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
4000689c: 82 06 3f f7 add %i0, -9, %g1
400068a0: 82 08 60 ff and %g1, 0xff, %g1
400068a4: 80 a0 60 01 cmp %g1, 1
400068a8: 08 80 00 0f bleu 400068e4 <echo+0x74>
400068ac: 82 10 20 5e mov 0x5e, %g1
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
400068b0: 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] = '^';
400068b4: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
400068b8: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
400068bc: 90 07 bf f8 add %fp, -8, %o0
400068c0: 92 10 20 02 mov 2, %o1
400068c4: 7f ff ff 43 call 400065d0 <rtems_termios_puts>
400068c8: 94 10 00 19 mov %i1, %o2
tty->column += 2;
400068cc: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
400068d0: 82 00 60 02 add %g1, 2, %g1
400068d4: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
400068d8: 81 c7 e0 08 ret
400068dc: 81 e8 00 00 restore
} else {
oproc (c, tty);
400068e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400068e4: 7f ff ff 84 call 400066f4 <oproc>
400068e8: 92 10 00 19 mov %i1, %o1
400068ec: 81 c7 e0 08 ret
400068f0: 81 e8 00 00 restore
40024df8 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
40024df8: 03 10 01 8f sethi %hi(0x40063c00), %g1
40024dfc: d0 00 61 08 ld [ %g1 + 0x108 ], %o0 ! 40063d08 <group_fp>
40024e00: 80 a2 20 00 cmp %o0, 0
40024e04: 02 80 00 05 be 40024e18 <endgrent+0x20> <== NEVER TAKEN
40024e08: 01 00 00 00 nop
fclose(group_fp);
40024e0c: 82 13 c0 00 mov %o7, %g1
40024e10: 40 00 49 74 call 400373e0 <fclose>
40024e14: 9e 10 40 00 mov %g1, %o7
40024e18: 81 c3 e0 08 retl <== NOT EXECUTED
40024c54 <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
40024c54: 03 10 01 8f sethi %hi(0x40063c00), %g1
40024c58: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 ! 40063c28 <passwd_fp>
40024c5c: 80 a2 20 00 cmp %o0, 0
40024c60: 02 80 00 05 be 40024c74 <endpwent+0x20> <== NEVER TAKEN
40024c64: 01 00 00 00 nop
fclose(passwd_fp);
40024c68: 82 13 c0 00 mov %o7, %g1
40024c6c: 40 00 49 dd call 400373e0 <fclose>
40024c70: 9e 10 40 00 mov %g1, %o7
40024c74: 81 c3 e0 08 retl <== NOT EXECUTED
400068f4 <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)
400068f4: 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);
400068f8: 35 10 00 74 sethi %hi(0x4001d000), %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)
400068fc: ba 10 00 18 mov %i0, %i5
40006900: 37 10 00 7a sethi %hi(0x4001e800), %i3
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40006904: 31 10 00 74 sethi %hi(0x4001d000), %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);
40006908: b4 16 a3 28 or %i2, 0x328, %i2
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
4000690c: 10 80 00 62 b 40006a94 <erase.part.2+0x1a0>
40006910: b0 16 23 20 or %i0, 0x320, %i0
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
40006914: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
40006918: 86 00 ff ff add %g3, -1, %g3
4000691c: c6 27 60 20 st %g3, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
40006920: 80 88 60 08 btst 8, %g1
40006924: 02 80 00 59 be 40006a88 <erase.part.2+0x194> <== NEVER TAKEN
40006928: f8 09 00 03 ldub [ %g4 + %g3 ], %i4
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
4000692c: 80 a6 60 00 cmp %i1, 0
40006930: 32 80 00 08 bne,a 40006950 <erase.part.2+0x5c>
40006934: b8 0f 20 ff and %i4, 0xff, %i4
40006938: 80 88 60 10 btst 0x10, %g1
4000693c: 32 80 00 05 bne,a 40006950 <erase.part.2+0x5c> <== ALWAYS TAKEN
40006940: b8 0f 20 ff and %i4, 0xff, %i4
echo (tty->termios.c_cc[VERASE], tty);
40006944: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
40006948: 7f ff ff ca call 40006870 <echo> <== NOT EXECUTED
4000694c: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
} else if (c == '\t') {
40006950: 80 a7 20 09 cmp %i4, 9
40006954: 32 80 00 28 bne,a 400069f4 <erase.part.2+0x100>
40006958: c4 06 e1 30 ld [ %i3 + 0x130 ], %g2
int col = tty->read_start_column;
4000695c: 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)) {
40006960: da 06 e1 30 ld [ %i3 + 0x130 ], %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;
40006964: 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)
40006968: 10 80 00 12 b 400069b0 <erase.part.2+0xbc>
4000696c: 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') {
40006970: 80 a3 e0 09 cmp %o7, 9
40006974: 12 80 00 04 bne 40006984 <erase.part.2+0x90>
40006978: 84 00 a0 01 inc %g2
col = (col | 7) + 1;
4000697c: 10 80 00 0c b 400069ac <erase.part.2+0xb8>
40006980: b8 17 20 07 or %i4, 7, %i4
} else if (iscntrl (c)) {
40006984: 9e 03 40 0f add %o5, %o7, %o7
40006988: de 0b e0 01 ldub [ %o7 + 1 ], %o7
4000698c: 80 8b e0 20 btst 0x20, %o7
40006990: 22 80 00 08 be,a 400069b0 <erase.part.2+0xbc> <== ALWAYS TAKEN
40006994: b8 07 20 01 inc %i4
if (tty->termios.c_lflag & ECHOCTL)
40006998: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000699c: 32 80 00 05 bne,a 400069b0 <erase.part.2+0xbc> <== NOT EXECUTED
400069a0: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
400069a4: 10 80 00 04 b 400069b4 <erase.part.2+0xc0> <== NOT EXECUTED
400069a8: 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++;
400069ac: b8 07 20 01 inc %i4
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
400069b0: 80 a0 80 03 cmp %g2, %g3
400069b4: 32 bf ff ef bne,a 40006970 <erase.part.2+0x7c>
400069b8: de 09 00 02 ldub [ %g4 + %g2 ], %o7
}
/*
* Back up over the tab
*/
while (tty->column > col) {
400069bc: 10 80 00 09 b 400069e0 <erase.part.2+0xec>
400069c0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_termios_puts ("\b", 1, tty);
400069c4: 92 10 20 01 mov 1, %o1
400069c8: 7f ff ff 02 call 400065d0 <rtems_termios_puts>
400069cc: 94 10 00 1d mov %i5, %o2
tty->column--;
400069d0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400069d4: 82 00 7f ff add %g1, -1, %g1
400069d8: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
/*
* Back up over the tab
*/
while (tty->column > col) {
400069dc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400069e0: 80 a0 40 1c cmp %g1, %i4
400069e4: 14 bf ff f8 bg 400069c4 <erase.part.2+0xd0>
400069e8: 90 10 00 18 mov %i0, %o0
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
400069ec: 10 80 00 28 b 40006a8c <erase.part.2+0x198>
400069f0: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
400069f4: b8 07 20 01 inc %i4
400069f8: c4 08 80 1c ldub [ %g2 + %i4 ], %g2
400069fc: 80 88 a0 20 btst 0x20, %g2
40006a00: 22 80 00 10 be,a 40006a40 <erase.part.2+0x14c> <== ALWAYS TAKEN
40006a04: c2 06 e1 30 ld [ %i3 + 0x130 ], %g1
40006a08: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
40006a0c: 02 80 00 0d be 40006a40 <erase.part.2+0x14c> <== NOT EXECUTED
40006a10: c2 06 e1 30 ld [ %i3 + 0x130 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
40006a14: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40006a18: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
40006a1c: 7f ff fe ed call 400065d0 <rtems_termios_puts> <== NOT EXECUTED
40006a20: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
40006a24: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
40006a28: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006a2c: 22 80 00 05 be,a 40006a40 <erase.part.2+0x14c> <== NOT EXECUTED
40006a30: c2 06 e1 30 ld [ %i3 + 0x130 ], %g1 <== NOT EXECUTED
tty->column--;
40006a34: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40006a38: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
40006a3c: c2 06 e1 30 ld [ %i3 + 0x130 ], %g1 <== NOT EXECUTED
40006a40: c2 08 40 1c ldub [ %g1 + %i4 ], %g1
40006a44: 80 88 60 20 btst 0x20, %g1
40006a48: 02 80 00 07 be 40006a64 <erase.part.2+0x170> <== ALWAYS TAKEN
40006a4c: 90 10 00 1a mov %i2, %o0
40006a50: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
40006a54: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
40006a58: 02 80 00 0d be 40006a8c <erase.part.2+0x198> <== NOT EXECUTED
40006a5c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
40006a60: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40006a64: 92 10 20 03 mov 3, %o1
40006a68: 7f ff fe da call 400065d0 <rtems_termios_puts>
40006a6c: 94 10 00 1d mov %i5, %o2
if (tty->column)
40006a70: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40006a74: 80 a0 60 00 cmp %g1, 0
40006a78: 02 80 00 05 be 40006a8c <erase.part.2+0x198> <== NEVER TAKEN
40006a7c: 80 a6 60 00 cmp %i1, 0
tty->column--;
40006a80: 82 00 7f ff add %g1, -1, %g1
40006a84: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
40006a88: 80 a6 60 00 cmp %i1, 0
40006a8c: 02 80 00 06 be 40006aa4 <erase.part.2+0x1b0>
40006a90: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
40006a94: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
40006a98: 80 a0 e0 00 cmp %g3, 0
40006a9c: 32 bf ff 9e bne,a 40006914 <erase.part.2+0x20>
40006aa0: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
40006aa4: 81 c7 e0 08 ret
40006aa8: 81 e8 00 00 restore
40005080 <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
)
{
40005080: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
40005084: 92 10 20 00 clr %o1
40005088: 90 10 00 18 mov %i0, %o0
4000508c: 40 00 2d 24 call 4001051c <memset>
40005090: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
40005094: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
40005098: 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) {
4000509c: 80 a6 a0 00 cmp %i2, 0
400050a0: 02 80 00 19 be 40005104 <eval_path_start+0x84>
400050a4: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
400050a8: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
400050ac: 40 00 01 79 call 40005690 <rtems_filesystem_global_location_obtain>
400050b0: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
400050b4: 83 2e e0 18 sll %i3, 0x18, %g1
400050b8: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
400050bc: 80 a0 60 5c cmp %g1, 0x5c
400050c0: 02 80 00 05 be 400050d4 <eval_path_start+0x54> <== NEVER TAKEN
400050c4: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
400050c8: 80 a0 60 2f cmp %g1, 0x2f
400050cc: 12 80 00 0a bne 400050f4 <eval_path_start+0x74>
400050d0: 90 10 00 1d mov %i5, %o0
++ctx->path;
400050d4: c2 06 00 00 ld [ %i0 ], %g1
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
400050d8: 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;
400050dc: 82 00 60 01 inc %g1
400050e0: c2 26 00 00 st %g1, [ %i0 ]
--ctx->pathlen;
400050e4: c2 06 20 04 ld [ %i0 + 4 ], %g1
400050e8: 82 00 7f ff add %g1, -1, %g1
400050ec: 10 80 00 02 b 400050f4 <eval_path_start+0x74>
400050f0: 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(
400050f4: 40 00 01 67 call 40005690 <rtems_filesystem_global_location_obtain>
400050f8: 01 00 00 00 nop
400050fc: 10 80 00 0d b 40005130 <eval_path_start+0xb0>
40005100: 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;
40005104: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
40005108: 40 00 01 62 call 40005690 <rtems_filesystem_global_location_obtain>
4000510c: 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;
40005110: c0 27 bf fc clr [ %fp + -4 ]
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
40005114: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
40005118: 40 00 01 5e call 40005690 <rtems_filesystem_global_location_obtain>
4000511c: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
40005120: 40 00 2a 71 call 4000fae4 <__errno>
40005124: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40005128: 82 10 20 02 mov 2, %g1
4000512c: 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;
40005130: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40005134: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005138: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000513c: c2 00 40 00 ld [ %g1 ], %g1
40005140: 9f c0 40 00 call %g1
40005144: 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(
40005148: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
4000514c: 40 00 1d 05 call 4000c560 <rtems_filesystem_location_clone>
40005150: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
40005154: 90 10 00 18 mov %i0, %o0
40005158: 7f ff ff b0 call 40005018 <rtems_filesystem_eval_path_continue>
4000515c: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
40005160: 81 c7 e0 08 ret
40005164: 81 e8 00 00 restore
40013490 <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)
{
40013490: 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);
40013494: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
40013498: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2
4001349c: 84 20 80 01 sub %g2, %g1, %g2
400134a0: 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);
400134a4: 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 -
400134a8: 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);
400134ac: 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)
400134b0: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
400134b4: 80 a0 60 00 cmp %g1, 0
400134b8: 02 80 00 06 be 400134d0 <fat_buf_access+0x40>
400134bc: 01 00 00 00 nop
400134c0: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
400134c4: 80 a0 40 19 cmp %g1, %i1
400134c8: 22 80 00 1c be,a 40013538 <fat_buf_access+0xa8>
400134cc: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
{
fat_buf_release(fs_info);
400134d0: 7f ff ff 7c call 400132c0 <fat_buf_release>
400134d4: 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);
400134d8: 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)
400134dc: 80 a6 a0 01 cmp %i2, 1
400134e0: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
400134e4: 12 80 00 06 bne 400134fc <fat_buf_access+0x6c>
400134e8: 94 06 20 8c add %i0, 0x8c, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
400134ec: 7f ff f7 ae call 400113a4 <rtems_bdbuf_read>
400134f0: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
400134f4: 10 80 00 05 b 40013508 <fat_buf_access+0x78>
400134f8: 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);
400134fc: 7f ff f7 79 call 400112e0 <rtems_bdbuf_get>
40013500: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
40013504: 80 a2 20 00 cmp %o0, 0
40013508: 02 80 00 08 be 40013528 <fat_buf_access+0x98> <== ALWAYS TAKEN
4001350c: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
40013510: 40 00 21 0d call 4001b944 <__errno> <== NOT EXECUTED
40013514: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013518: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001351c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013520: 81 c7 e0 08 ret <== NOT EXECUTED
40013524: 81 e8 00 00 restore <== NOT EXECUTED
fs_info->c.blk_num = sec_num;
40013528: f2 26 20 84 st %i1, [ %i0 + 0x84 ]
fs_info->c.modified = 0;
4001352c: c0 2e 20 88 clrb [ %i0 + 0x88 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
40013530: c2 2e 20 89 stb %g1, [ %i0 + 0x89 ]
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
40013534: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
40013538: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001353c: b8 00 40 1c add %g1, %i4, %i4
40013540: f8 26 c0 00 st %i4, [ %i3 ]
return RC_OK;
}
40013544: 81 c7 e0 08 ret
40013548: 91 e8 20 00 restore %g0, 0, %o0
400132c0 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
400132c0: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
400132c4: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
400132c8: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
400132cc: 80 a0 60 00 cmp %g1, 0
400132d0: 02 80 00 6e be 40013488 <fat_buf_release+0x1c8>
400132d4: b0 10 20 00 clr %i0
return RC_OK;
if (fs_info->c.modified)
400132d8: c2 0f 60 88 ldub [ %i5 + 0x88 ], %g1
400132dc: 80 a0 60 00 cmp %g1, 0
400132e0: 02 80 00 5d be 40013454 <fat_buf_release+0x194>
400132e4: 01 00 00 00 nop
{
uint32_t sec_num = fs_info->c.blk_num;
400132e8: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
400132ec: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
400132f0: 80 a0 40 02 cmp %g1, %g2
400132f4: 0a 80 00 05 bcs 40013308 <fat_buf_release+0x48>
400132f8: b8 10 20 00 clr %i4
400132fc: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40013300: 80 a0 40 02 cmp %g1, %g2
40013304: b8 40 20 00 addx %g0, 0, %i4
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
40013308: 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)
4001330c: 80 8f 20 ff btst 0xff, %i4
40013310: 02 80 00 12 be 40013358 <fat_buf_release+0x98>
40013314: c6 0f 60 0c ldub [ %i5 + 0xc ], %g3
40013318: c8 0f 60 54 ldub [ %i5 + 0x54 ], %g4
4001331c: 80 a1 20 00 cmp %g4, 0
40013320: 12 80 00 0e bne 40013358 <fat_buf_release+0x98> <== NEVER TAKEN
40013324: 84 08 a0 ff and %g2, 0xff, %g2
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
40013328: 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,
4001332c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
40013330: d2 01 20 1c ld [ %g4 + 0x1c ], %o1
40013334: d4 17 40 00 lduh [ %i5 ], %o2
40013338: 86 08 e0 ff and %g3, 0xff, %g3
4001333c: 86 20 c0 02 sub %g3, %g2, %g3
40013340: 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);
40013344: 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 -
40013348: 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);
4001334c: 85 28 40 02 sll %g1, %g2, %g2
40013350: 40 00 24 22 call 4001c3d8 <memcpy>
40013354: 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);
40013358: 7f ff f8 c4 call 40011668 <rtems_bdbuf_release_modified>
4001335c: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
40013360: 80 a2 20 00 cmp %o0, 0
40013364: 12 80 00 41 bne 40013468 <fat_buf_release+0x1a8> <== NEVER TAKEN
40013368: 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)
4001336c: 02 80 00 45 be 40013480 <fat_buf_release+0x1c0>
40013370: c0 2f 60 88 clrb [ %i5 + 0x88 ]
40013374: c2 0f 60 54 ldub [ %i5 + 0x54 ], %g1
40013378: 80 a0 60 00 cmp %g1, 0
4001337c: 22 80 00 2f be,a 40013438 <fat_buf_release+0x178> <== ALWAYS TAKEN
40013380: 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;
40013384: 10 80 00 40 b 40013484 <fat_buf_release+0x1c4> <== NOT EXECUTED
40013388: 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,
4001338c: 7f ff bc b1 call 40002650 <.umul>
40013390: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
40013394: 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);
40013398: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
4001339c: 90 02 00 1b add %o0, %i3, %o0
400133a0: f6 0f 60 0c ldub [ %i5 + 0xc ], %i3
400133a4: b6 26 c0 01 sub %i3, %g1, %i3
400133a8: 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);
400133ac: 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 -
400133b0: 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);
400133b4: 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
400133b8: 80 a6 e0 00 cmp %i3, 0
400133bc: 12 80 00 0b bne 400133e8 <fat_buf_release+0x128>
400133c0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
400133c4: c4 17 40 00 lduh [ %i5 ], %g2
400133c8: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
400133cc: 80 a0 80 01 cmp %g2, %g1
400133d0: 12 80 00 06 bne 400133e8 <fat_buf_release+0x128>
400133d4: 01 00 00 00 nop
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
400133d8: 7f ff f7 c2 call 400112e0 <rtems_bdbuf_get>
400133dc: 94 07 bf fc add %fp, -4, %o2
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
}
if ( sc != RTEMS_SUCCESSFUL)
400133e0: 10 80 00 05 b 400133f4 <fat_buf_release+0x134>
400133e4: 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);
400133e8: 7f ff f7 ef call 400113a4 <rtems_bdbuf_read>
400133ec: 94 07 bf fc add %fp, -4, %o2
}
if ( sc != RTEMS_SUCCESSFUL)
400133f0: 80 a2 20 00 cmp %o0, 0
400133f4: 22 80 00 03 be,a 40013400 <fat_buf_release+0x140> <== ALWAYS TAKEN
400133f8: c2 07 bf fc ld [ %fp + -4 ], %g1
400133fc: 30 80 00 0b b,a 40013428 <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);
40013400: d2 07 60 90 ld [ %i5 + 0x90 ], %o1
40013404: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40013408: d4 17 40 00 lduh [ %i5 ], %o2
4001340c: 40 00 23 f3 call 4001c3d8 <memcpy>
40013410: 90 02 00 1b add %o0, %i3, %o0
sc = rtems_bdbuf_release_modified(bd);
40013414: 7f ff f8 95 call 40011668 <rtems_bdbuf_release_modified>
40013418: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
4001341c: 80 a2 20 00 cmp %o0, 0
40013420: 22 80 00 06 be,a 40013438 <fat_buf_release+0x178> <== ALWAYS TAKEN
40013424: b8 07 20 01 inc %i4
rtems_set_errno_and_return_minus_one(ENOMEM);
40013428: 40 00 21 47 call 4001b944 <__errno> <== NOT EXECUTED
4001342c: 01 00 00 00 nop <== NOT EXECUTED
40013430: 10 80 00 11 b 40013474 <fat_buf_release+0x1b4> <== NOT EXECUTED
40013434: 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++)
40013438: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
4001343c: 90 0f 20 ff and %i4, 0xff, %o0
40013440: 80 a2 00 01 cmp %o0, %g1
40013444: 0a bf ff d2 bcs 4001338c <fat_buf_release+0xcc>
40013448: 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;
4001344c: 10 80 00 0e b 40013484 <fat_buf_release+0x1c4>
40013450: c0 2f 60 89 clrb [ %i5 + 0x89 ]
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
40013454: 7f ff f8 50 call 40011594 <rtems_bdbuf_release>
40013458: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
4001345c: 80 a2 20 00 cmp %o0, 0
40013460: 22 80 00 09 be,a 40013484 <fat_buf_release+0x1c4> <== ALWAYS TAKEN
40013464: c0 2f 60 89 clrb [ %i5 + 0x89 ]
rtems_set_errno_and_return_minus_one(EIO);
40013468: 40 00 21 37 call 4001b944 <__errno> <== NOT EXECUTED
4001346c: 01 00 00 00 nop <== NOT EXECUTED
40013470: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40013474: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013478: 81 c7 e0 08 ret <== NOT EXECUTED
4001347c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
40013480: c0 2f 60 89 clrb [ %i5 + 0x89 ]
return RC_OK;
40013484: b0 10 20 00 clr %i0
}
40013488: 81 c7 e0 08 ret
4001348c: 81 e8 00 00 restore
40013264 <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)) )
40013264: 80 a2 60 00 cmp %o1, 0
40013268: 32 80 00 0c bne,a 40013298 <fat_cluster_num_to_block_num+0x34>
4001326c: c2 0a 20 0c ldub [ %o0 + 0xc ], %g1
40013270: c2 0a 20 0e ldub [ %o0 + 0xe ], %g1
40013274: 80 88 60 03 btst 3, %g1
40013278: 22 80 00 08 be,a 40013298 <fat_cluster_num_to_block_num+0x34><== NEVER TAKEN
4001327c: 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);
40013280: c4 0a 20 0c ldub [ %o0 + 0xc ], %g2
40013284: c2 0a 20 02 ldub [ %o0 + 2 ], %g1
40013288: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4001328c: 82 20 80 01 sub %g2, %g1, %g1
40013290: 81 c3 e0 08 retl
40013294: 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);
40013298: 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;
4001329c: 92 02 7f fe add %o1, -2, %o1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400132a0: 84 20 80 01 sub %g2, %g1, %g2
400132a4: 93 2a 40 02 sll %o1, %g2, %o1
400132a8: c4 0a 20 02 ldub [ %o0 + 2 ], %g2
400132ac: d0 02 20 34 ld [ %o0 + 0x34 ], %o0
400132b0: 82 20 40 02 sub %g1, %g2, %g1
400132b4: 91 32 00 01 srl %o0, %g1, %o0
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
}
return blk;
}
400132b8: 81 c3 e0 08 retl
400132bc: 90 02 00 09 add %o0, %o1, %o0
400125c0 <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)) )
400125c0: 80 a2 60 00 cmp %o1, 0
400125c4: 32 80 00 08 bne,a 400125e4 <fat_cluster_num_to_sector_num+0x24>
400125c8: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
400125cc: c2 0a 20 0e ldub [ %o0 + 0xe ], %g1
400125d0: 80 88 60 03 btst 3, %g1
400125d4: 22 80 00 04 be,a 400125e4 <fat_cluster_num_to_sector_num+0x24><== NEVER TAKEN
400125d8: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
400125dc: 81 c3 e0 08 retl
400125e0: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
400125e4: 92 02 7f fe add %o1, -2, %o1
400125e8: 93 2a 40 01 sll %o1, %g1, %o1
400125ec: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
fs_info->vol.data_fsec);
}
400125f0: 81 c3 e0 08 retl
400125f4: 90 02 40 01 add %o1, %g1, %o0
40013664 <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)
{
40013664: 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));
40013668: c2 16 20 06 lduh [ %i0 + 6 ], %g1
4001366c: 82 20 40 1a sub %g1, %i2, %g1
40013670: 80 a6 c0 01 cmp %i3, %g1
40013674: 38 80 00 02 bgu,a 4001367c <fat_cluster_set+0x18> <== NEVER TAKEN
40013678: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
4001367c: 90 10 00 18 mov %i0, %o0
40013680: 7f ff fe f9 call 40013264 <fat_cluster_num_to_block_num>
40013684: 92 10 00 19 mov %i1, %o1
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
40013688: 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;
4001368c: 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;
40013690: a3 36 80 01 srl %i2, %g1, %l1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
40013694: 83 2c 40 01 sll %l1, %g1, %g1
40013698: a4 10 20 01 mov 1, %l2
4001369c: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
400136a0: a2 02 00 11 add %o0, %l1, %l1
while ( (RC_OK == rc)
400136a4: 10 80 00 2a b 4001374c <fat_cluster_set+0xe8>
400136a8: 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));
400136ac: 82 20 80 1a sub %g2, %i2, %g1
400136b0: 80 a0 40 1b cmp %g1, %i3
400136b4: 08 80 00 03 bleu 400136c0 <fat_cluster_set+0x5c> <== ALWAYS TAKEN
400136b8: ba 10 00 01 mov %g1, %i5
400136bc: 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));
400136c0: 80 a7 40 01 cmp %i5, %g1
400136c4: 08 80 00 03 bleu 400136d0 <fat_cluster_set+0x6c> <== ALWAYS TAKEN
400136c8: b2 10 00 1d mov %i5, %i1
400136cc: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
400136d0: 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)
400136d4: 80 a6 60 00 cmp %i1, 0
400136d8: 02 80 00 27 be 40013774 <fat_cluster_set+0x110> <== NEVER TAKEN
400136dc: 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);
400136e0: 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);
400136e4: 90 10 00 18 mov %i0, %o0
400136e8: 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)
400136ec: 80 a6 40 02 cmp %i1, %g2
400136f0: 02 80 00 03 be 400136fc <fat_cluster_set+0x98>
400136f4: 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);
400136f8: 94 10 20 01 mov 1, %o2
400136fc: 7f ff ff 65 call 40013490 <fat_buf_access>
40013700: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
40013704: 80 a2 20 00 cmp %o0, 0
40013708: 12 80 00 0a bne 40013730 <fat_cluster_set+0xcc> <== NEVER TAKEN
4001370c: 80 a7 40 08 cmp %i5, %o0
{
memset(blk_buf + offset, pattern, bytes_to_write);
40013710: d0 07 bf fc ld [ %fp + -4 ], %o0
40013714: 92 10 00 1c mov %i4, %o1
40013718: 90 02 00 1a add %o0, %i2, %o0
4001371c: 40 00 23 6c call 4001c4cc <memset>
40013720: 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;
40013724: 10 80 00 14 b 40013774 <fat_cluster_set+0x110>
40013728: e4 2e 20 88 stb %l2, [ %i0 + 0x88 ]
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
4001372c: 80 a7 40 08 cmp %i5, %o0
40013730: 12 80 00 06 bne 40013748 <fat_cluster_set+0xe4> <== NEVER TAKEN
40013734: 82 10 3f ff mov -1, %g1
rc = -1;
else
{
bytes_to_write -= ret;
40013738: b6 26 c0 1d sub %i3, %i5, %i3
bytes_written += ret;
4001373c: a0 04 00 1d add %l0, %i5, %l0
++cur_blk;
40013740: a2 04 60 01 inc %l1
40013744: 82 10 20 00 clr %g1
40013748: b4 10 20 00 clr %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
4001374c: 80 a6 e0 00 cmp %i3, 0
40013750: 02 80 00 04 be 40013760 <fat_cluster_set+0xfc>
40013754: 80 a0 60 00 cmp %g1, 0
40013758: 22 bf ff d5 be,a 400136ac <fat_cluster_set+0x48> <== ALWAYS TAKEN
4001375c: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
40013760: 80 a0 60 00 cmp %g1, 0
40013764: 12 80 00 06 bne 4001377c <fat_cluster_set+0x118> <== NEVER TAKEN
40013768: b0 10 3f ff mov -1, %i0
4001376c: 81 c7 e0 08 ret
40013770: 91 e8 00 10 restore %g0, %l0, %o0
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
40013774: 10 bf ff ee b 4001372c <fat_cluster_set+0xc8>
40013778: 90 10 00 19 mov %i1, %o0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4001377c: 81 c7 e0 08 ret <== NOT EXECUTED
40013780: 81 e8 00 00 restore <== NOT EXECUTED
40013784 <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
40013784: 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));
40013788: c2 16 20 06 lduh [ %i0 + 6 ], %g1
4001378c: 82 20 40 1a sub %g1, %i2, %g1
40013790: 80 a6 c0 01 cmp %i3, %g1
40013794: 38 80 00 02 bgu,a 4001379c <fat_cluster_write+0x18> <== NEVER TAKEN
40013798: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
4001379c: 90 10 00 18 mov %i0, %o0
400137a0: 7f ff fe b1 call 40013264 <fat_cluster_num_to_block_num>
400137a4: 92 10 00 19 mov %i1, %o1
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
400137a8: 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;
400137ac: 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);
400137b0: a5 36 80 01 srl %i2, %g1, %l2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400137b4: 83 2c 80 01 sll %l2, %g1, %g1
400137b8: a6 10 20 01 mov 1, %l3
400137bc: 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;
400137c0: a4 02 00 12 add %o0, %l2, %l2
while ( (RC_OK == rc)
400137c4: 10 80 00 2d b 40013878 <fat_cluster_write+0xf4>
400137c8: 82 10 20 00 clr %g1
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
400137cc: 82 20 80 1a sub %g2, %i2, %g1
400137d0: 80 a0 40 1b cmp %g1, %i3
400137d4: 08 80 00 03 bleu 400137e0 <fat_cluster_write+0x5c>
400137d8: b2 10 00 01 mov %g1, %i1
400137dc: 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));
400137e0: 80 a6 40 01 cmp %i1, %g1
400137e4: 08 80 00 03 bleu 400137f0 <fat_cluster_write+0x6c> <== ALWAYS TAKEN
400137e8: a0 10 00 19 mov %i1, %l0
400137ec: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
400137f0: 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)
400137f4: 80 a4 20 00 cmp %l0, 0
400137f8: 02 80 00 2a be 400138a0 <fat_cluster_write+0x11c> <== NEVER TAKEN
400137fc: 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);
40013800: 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);
40013804: 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
40013808: 80 a7 60 00 cmp %i5, 0
4001380c: 12 80 00 05 bne 40013820 <fat_cluster_write+0x9c>
40013810: 93 2c 80 09 sll %l2, %o1, %o1
|| (bytes_to_write == fs_info->vol.bytes_per_block))
40013814: 80 a4 00 02 cmp %l0, %g2
40013818: 12 80 00 04 bne 40013828 <fat_cluster_write+0xa4>
4001381c: 94 10 20 01 mov 1, %o2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
40013820: 10 80 00 02 b 40013828 <fat_cluster_write+0xa4>
40013824: 94 10 20 02 mov 2, %o2
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
40013828: 7f ff ff 1a call 40013490 <fat_buf_access>
4001382c: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
40013830: 80 a2 20 00 cmp %o0, 0
40013834: 12 80 00 0a bne 4001385c <fat_cluster_write+0xd8> <== NEVER TAKEN
40013838: 80 a6 40 08 cmp %i1, %o0
{
memcpy(blk_buf + offset, buf, bytes_to_write);
4001383c: d0 07 bf fc ld [ %fp + -4 ], %o0
40013840: 92 07 00 11 add %i4, %l1, %o1
40013844: 90 02 00 1a add %o0, %i2, %o0
40013848: 40 00 22 e4 call 4001c3d8 <memcpy>
4001384c: 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;
40013850: 10 80 00 14 b 400138a0 <fat_cluster_write+0x11c>
40013854: e6 2e 20 88 stb %l3, [ %i0 + 0x88 ]
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
40013858: 80 a6 40 08 cmp %i1, %o0
4001385c: 12 80 00 06 bne 40013874 <fat_cluster_write+0xf0> <== NEVER TAKEN
40013860: 82 10 3f ff mov -1, %g1
rc = -1;
else
{
bytes_to_write -= ret;
40013864: b6 26 c0 19 sub %i3, %i1, %i3
bytes_written += ret;
40013868: a2 04 40 19 add %l1, %i1, %l1
++cur_blk;
4001386c: a4 04 a0 01 inc %l2
40013870: 82 10 20 00 clr %g1
40013874: b4 10 20 00 clr %i2
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
40013878: 80 a6 e0 00 cmp %i3, 0
4001387c: 02 80 00 04 be 4001388c <fat_cluster_write+0x108>
40013880: 80 a0 60 00 cmp %g1, 0
40013884: 22 bf ff d2 be,a 400137cc <fat_cluster_write+0x48> <== ALWAYS TAKEN
40013888: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
4001388c: 80 a0 60 00 cmp %g1, 0
40013890: 12 80 00 06 bne 400138a8 <fat_cluster_write+0x124> <== NEVER TAKEN
40013894: b0 10 3f ff mov -1, %i0
40013898: 81 c7 e0 08 ret
4001389c: 91 e8 00 11 restore %g0, %l1, %o0
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
400138a0: 10 bf ff ee b 40013858 <fat_cluster_write+0xd4>
400138a4: 90 10 00 10 mov %l0, %o0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
400138a8: 81 c7 e0 08 ret <== NOT EXECUTED
400138ac: 81 e8 00 00 restore <== NOT EXECUTED
40012b2c <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40012b2c: 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)
40012b30: c2 06 60 08 ld [ %i1 + 8 ], %g1
40012b34: 80 a0 60 01 cmp %g1, 1
40012b38: 08 80 00 05 bleu 40012b4c <fat_file_close+0x20>
40012b3c: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
40012b40: 90 10 20 00 clr %o0
40012b44: 10 80 00 25 b 40012bd8 <fat_file_close+0xac>
40012b48: 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)
40012b4c: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
40012b50: 80 88 60 01 btst 1, %g1
40012b54: 02 80 00 14 be 40012ba4 <fat_file_close+0x78>
40012b58: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
40012b5c: 92 10 00 19 mov %i1, %o1
40012b60: 7f ff ff ae call 40012a18 <fat_file_truncate>
40012b64: 94 10 20 00 clr %o2
if ( rc != RC_OK )
40012b68: 80 a2 20 00 cmp %o0, 0
40012b6c: 12 80 00 1b bne 40012bd8 <fat_file_close+0xac> <== NEVER TAKEN
40012b70: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40012b74: 40 00 0e 6d call 40016528 <_Chain_Extract>
40012b78: 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) )
40012b7c: d2 06 60 0c ld [ %i1 + 0xc ], %o1
40012b80: 40 00 06 01 call 40014384 <fat_ino_is_unique>
40012b84: 90 10 00 18 mov %i0, %o0
40012b88: 80 8a 20 ff btst 0xff, %o0
40012b8c: 02 80 00 0f be 40012bc8 <fat_file_close+0x9c> <== ALWAYS TAKEN
40012b90: 01 00 00 00 nop
fat_free_unique_ino(fs_info, fat_fd->ino);
40012b94: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
40012b98: 40 00 05 f0 call 40014358 <fat_free_unique_ino> <== NOT EXECUTED
40012b9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012ba0: 30 80 00 0a b,a 40012bc8 <fat_file_close+0x9c> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
40012ba4: 40 00 05 f8 call 40014384 <fat_ino_is_unique>
40012ba8: d2 06 60 0c ld [ %i1 + 0xc ], %o1
40012bac: 80 8a 20 ff btst 0xff, %o0
40012bb0: 02 80 00 04 be 40012bc0 <fat_file_close+0x94>
40012bb4: 01 00 00 00 nop
{
fat_fd->links_num = 0;
40012bb8: 10 80 00 06 b 40012bd0 <fat_file_close+0xa4>
40012bbc: c0 26 60 08 clr [ %i1 + 8 ]
40012bc0: 40 00 0e 5a call 40016528 <_Chain_Extract>
40012bc4: 90 10 00 19 mov %i1, %o0
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
40012bc8: 7f ff cb e4 call 40005b58 <free>
40012bcc: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
40012bd0: 40 00 01 bc call 400132c0 <fat_buf_release>
40012bd4: 81 e8 00 00 restore
return rc;
}
40012bd8: 81 c7 e0 08 ret
40012bdc: 91 e8 00 08 restore %g0, %o0, %o0
40012cb0 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
40012cb0: 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;
40012cb4: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
40012cb8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
40012cbc: 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;
40012cc0: 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)
40012cc4: 80 a6 c0 01 cmp %i3, %g1
40012cc8: 18 80 00 04 bgu 40012cd8 <fat_file_extend+0x28>
40012ccc: ba 10 00 18 mov %i0, %i5
return RC_OK;
40012cd0: 81 c7 e0 08 ret
40012cd4: 91 e8 20 00 restore %g0, 0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40012cd8: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40012cdc: 80 a0 a0 01 cmp %g2, 1
40012ce0: 32 80 00 0b bne,a 40012d0c <fat_file_extend+0x5c>
40012ce4: e0 17 60 06 lduh [ %i5 + 6 ], %l0
40012ce8: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40012cec: 80 a0 a0 00 cmp %g2, 0
40012cf0: 32 80 00 07 bne,a 40012d0c <fat_file_extend+0x5c> <== NEVER TAKEN
40012cf4: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40012cf8: 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)) &&
40012cfc: 80 88 a0 03 btst 3, %g2
40012d00: 22 80 00 03 be,a 40012d0c <fat_file_extend+0x5c> <== NEVER TAKEN
40012d04: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
40012d08: 30 80 00 34 b,a 40012dd8 <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))) &
40012d0c: 84 04 3f ff add %l0, -1, %g2
40012d10: 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 -
40012d14: a0 24 00 12 sub %l0, %l2, %l0
40012d18: 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;
40012d1c: 84 26 c0 01 sub %i3, %g1, %g2
if (bytes2add > bytes_remain)
40012d20: 80 a0 80 10 cmp %g2, %l0
40012d24: 08 80 00 03 bleu 40012d30 <fat_file_extend+0x80>
40012d28: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
40012d2c: a2 20 80 10 sub %g2, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
40012d30: 80 a4 20 00 cmp %l0, 0
40012d34: 02 80 00 17 be 40012d90 <fat_file_extend+0xe0>
40012d38: 80 a4 60 00 cmp %l1, 0
40012d3c: 80 a6 a0 00 cmp %i2, 0
40012d40: 02 80 00 14 be 40012d90 <fat_file_extend+0xe0>
40012d44: 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;
40012d48: 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);
40012d4c: 90 10 00 1d mov %i5, %o0
40012d50: 92 10 00 19 mov %i1, %o1
40012d54: 95 30 40 0a srl %g1, %o2, %o2
40012d58: 7f ff fe 39 call 4001263c <fat_file_lseek>
40012d5c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40012d60: b0 92 60 00 orcc %o1, 0, %i0
40012d64: 12 80 00 21 bne 40012de8 <fat_file_extend+0x138> <== NEVER TAKEN
40012d68: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
40012d6c: 90 10 00 1d mov %i5, %o0
40012d70: 94 10 00 12 mov %l2, %o2
40012d74: 96 10 00 10 mov %l0, %o3
40012d78: 98 10 20 00 clr %o4
40012d7c: 40 00 02 3a call 40013664 <fat_cluster_set>
40012d80: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
40012d84: 80 a4 00 08 cmp %l0, %o0
40012d88: 12 80 00 18 bne 40012de8 <fat_file_extend+0x138> <== NEVER TAKEN
40012d8c: 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)
40012d90: 02 bf ff d0 be 40012cd0 <fat_file_extend+0x20>
40012d94: a4 04 7f ff add %l1, -1, %l2
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40012d98: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40012d9c: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40012da0: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40012da4: 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;
40012da8: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40012dac: 96 07 bf fc add %fp, -4, %o3
40012db0: 94 10 00 12 mov %l2, %o2
40012db4: 98 07 bf f8 add %fp, -8, %o4
40012db8: 40 00 1c 38 call 40019e98 <fat_scan_fat_for_free_clusters>
40012dbc: 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)
40012dc0: b0 92 20 00 orcc %o0, 0, %i0
40012dc4: 12 80 00 09 bne 40012de8 <fat_file_extend+0x138> <== NEVER TAKEN
40012dc8: 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))
40012dcc: 80 94 00 01 orcc %l0, %g1, %g0
40012dd0: 12 80 00 08 bne 40012df0 <fat_file_extend+0x140> <== ALWAYS TAKEN
40012dd4: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
40012dd8: 40 00 22 db call 4001b944 <__errno>
40012ddc: b0 10 3f ff mov -1, %i0
40012de0: 82 10 20 1c mov 0x1c, %g1
40012de4: c2 22 00 00 st %g1, [ %o0 ]
40012de8: 81 c7 e0 08 ret
40012dec: 81 e8 00 00 restore
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
40012df0: 02 80 00 09 be 40012e14 <fat_file_extend+0x164> <== ALWAYS TAKEN
40012df4: 82 24 80 01 sub %l2, %g1, %g1
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
40012df8: c4 17 60 06 lduh [ %i5 + 6 ], %g2 <== NOT EXECUTED
40012dfc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
40012e00: a2 0c 40 02 and %l1, %g2, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40012e04: 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);
40012e08: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40012e0c: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
40012e10: 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 )
40012e14: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
40012e18: 80 a2 e0 00 cmp %o3, 0
40012e1c: 32 80 00 07 bne,a 40012e38 <fat_file_extend+0x188>
40012e20: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
40012e24: c2 07 bf f0 ld [ %fp + -16 ], %g1
fat_fd->map.file_cln = 0;
40012e28: 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;
40012e2c: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
40012e30: 10 80 00 1d b 40012ea4 <fat_file_extend+0x1f4>
40012e34: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
40012e38: 80 a0 7f ff cmp %g1, -1
40012e3c: 22 80 00 04 be,a 40012e4c <fat_file_extend+0x19c> <== NEVER TAKEN
40012e40: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
40012e44: 10 80 00 0c b 40012e74 <fat_file_extend+0x1c4>
40012e48: c2 27 bf f4 st %g1, [ %fp + -12 ]
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
40012e4c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40012e50: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40012e54: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
40012e58: 7f ff ff 62 call 40012be0 <fat_file_ioctl> <== NOT EXECUTED
40012e5c: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
40012e60: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
40012e64: 02 80 00 05 be 40012e78 <fat_file_extend+0x1c8> <== NOT EXECUTED
40012e68: 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);
40012e6c: 10 80 00 1f b 40012ee8 <fat_file_extend+0x238> <== NOT EXECUTED
40012e70: 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);
40012e74: d2 07 bf f4 ld [ %fp + -12 ], %o1
40012e78: d4 07 bf f0 ld [ %fp + -16 ], %o2
40012e7c: 40 00 1b 37 call 40019b58 <fat_set_fat_cluster>
40012e80: 90 10 00 1d mov %i5, %o0
40012e84: b4 10 00 08 mov %o0, %i2
if ( rc != RC_OK )
40012e88: 80 a6 a0 00 cmp %i2, 0
40012e8c: 02 80 00 04 be 40012e9c <fat_file_extend+0x1ec> <== ALWAYS TAKEN
40012e90: 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);
40012e94: 10 80 00 16 b 40012eec <fat_file_extend+0x23c> <== NOT EXECUTED
40012e98: 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);
40012e9c: 40 00 01 09 call 400132c0 <fat_buf_release>
40012ea0: 01 00 00 00 nop
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
40012ea4: c2 07 bf fc ld [ %fp + -4 ], %g1
40012ea8: 80 a0 60 00 cmp %g1, 0
40012eac: 22 80 00 14 be,a 40012efc <fat_file_extend+0x24c> <== NEVER TAKEN
40012eb0: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
40012eb4: c2 07 bf f8 ld [ %fp + -8 ], %g1
40012eb8: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
40012ebc: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40012ec0: 80 a0 60 00 cmp %g1, 0
40012ec4: 32 80 00 0e bne,a 40012efc <fat_file_extend+0x24c>
40012ec8: f6 27 00 00 st %i3, [ %i4 ]
{
rc = fat_init_clusters_chain(fs_info, chain);
40012ecc: d2 07 bf f0 ld [ %fp + -16 ], %o1
40012ed0: 40 00 04 d4 call 40014220 <fat_init_clusters_chain>
40012ed4: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40012ed8: b4 92 20 00 orcc %o0, 0, %i2
40012edc: 22 80 00 08 be,a 40012efc <fat_file_extend+0x24c> <== ALWAYS TAKEN
40012ee0: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
40012ee4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012ee8: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
40012eec: 40 00 1b bc call 40019ddc <fat_free_fat_clusters_chain> <== NOT EXECUTED
40012ef0: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
40012ef4: 81 c7 e0 08 ret <== NOT EXECUTED
40012ef8: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
*a_length = new_length;
fat_fd->fat_file_size = new_length;
40012efc: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
40012f00: 81 c7 e0 08 ret
40012f04: 81 e8 00 00 restore
40012be0 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
40012be0: 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);
40012be4: 82 07 a0 50 add %fp, 0x50, %g1
40012be8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40012bec: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40012bf0: 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;
40012bf4: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
40012bf8: 80 a6 a0 01 cmp %i2, 1
40012bfc: 12 80 00 26 bne 40012c94 <fat_file_ioctl+0xb4> <== NEVER TAKEN
40012c00: c2 27 bf fc st %g1, [ %fp + -4 ]
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
40012c04: 82 07 a0 58 add %fp, 0x58, %g1
40012c08: c2 27 bf fc st %g1, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
40012c0c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40012c10: 80 a6 c0 01 cmp %i3, %g1
40012c14: 0a 80 00 06 bcs 40012c2c <fat_file_ioctl+0x4c> <== ALWAYS TAKEN
40012c18: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
40012c1c: 40 00 23 4a call 4001b944 <__errno> <== NOT EXECUTED
40012c20: 01 00 00 00 nop <== NOT EXECUTED
40012c24: 10 80 00 1f b 40012ca0 <fat_file_ioctl+0xc0> <== NOT EXECUTED
40012c28: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40012c2c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40012c30: 80 a0 60 01 cmp %g1, 1
40012c34: 32 80 00 0d bne,a 40012c68 <fat_file_ioctl+0x88>
40012c38: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
40012c3c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40012c40: 80 a0 60 00 cmp %g1, 0
40012c44: 32 80 00 09 bne,a 40012c68 <fat_file_ioctl+0x88> <== NEVER TAKEN
40012c48: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40012c4c: 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)) &&
40012c50: 80 88 60 03 btst 3, %g1
40012c54: 22 80 00 05 be,a 40012c68 <fat_file_ioctl+0x88>
40012c58: 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;
40012c5c: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
40012c60: 81 c7 e0 08 ret
40012c64: 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);
40012c68: 90 10 00 18 mov %i0, %o0
40012c6c: 92 10 00 19 mov %i1, %o1
40012c70: 95 36 c0 0a srl %i3, %o2, %o2
40012c74: 7f ff fe 72 call 4001263c <fat_file_lseek>
40012c78: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
40012c7c: b0 92 60 00 orcc %o1, 0, %i0
40012c80: 12 80 00 03 bne 40012c8c <fat_file_ioctl+0xac> <== NEVER TAKEN
40012c84: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
40012c88: c2 27 40 00 st %g1, [ %i5 ]
break;
40012c8c: 81 c7 e0 08 ret
40012c90: 81 e8 00 00 restore
default:
errno = EINVAL;
40012c94: 40 00 23 2c call 4001b944 <__errno> <== NOT EXECUTED
40012c98: 01 00 00 00 nop <== NOT EXECUTED
40012c9c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40012ca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
40012ca4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
40012ca8: 81 c7 e0 08 ret <== NOT EXECUTED
40012cac: 81 e8 00 00 restore <== NOT EXECUTED
4001263c <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
4001263c: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
40012640: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
40012644: 80 a6 80 01 cmp %i2, %g1
40012648: 12 80 00 05 bne 4001265c <fat_file_lseek+0x20>
4001264c: 01 00 00 00 nop
*disk_cln = fat_fd->map.disk_cln;
40012650: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
40012654: 10 80 00 1b b 400126c0 <fat_file_lseek+0x84>
40012658: 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)
4001265c: 28 80 00 06 bleu,a 40012674 <fat_file_lseek+0x38>
40012660: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
cur_cln = fat_fd->map.disk_cln;
40012664: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
count = file_cln - fat_fd->map.file_cln;
40012668: 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;
4001266c: 10 80 00 04 b 4001267c <fat_file_lseek+0x40>
40012670: c4 27 bf fc st %g2, [ %fp + -4 ]
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
40012674: b8 10 00 1a mov %i2, %i4
40012678: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4001267c: 10 80 00 0b b 400126a8 <fat_file_lseek+0x6c>
40012680: ba 10 20 00 clr %i5
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40012684: 90 10 00 18 mov %i0, %o0
40012688: 40 00 1c c2 call 40019990 <fat_get_fat_cluster>
4001268c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40012690: 80 a2 20 00 cmp %o0, 0
40012694: 22 80 00 05 be,a 400126a8 <fat_file_lseek+0x6c> <== ALWAYS TAKEN
40012698: ba 07 60 01 inc %i5
return rc;
4001269c: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
400126a0: 10 80 00 0a b 400126c8 <fat_file_lseek+0x8c> <== NOT EXECUTED
400126a4: 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++)
400126a8: 80 a7 40 1c cmp %i5, %i4
400126ac: 12 bf ff f6 bne 40012684 <fat_file_lseek+0x48>
400126b0: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
400126b4: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
400126b8: d2 26 60 38 st %o1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
400126bc: d2 26 c0 00 st %o1, [ %i3 ]
}
return RC_OK;
400126c0: 84 10 20 00 clr %g2
400126c4: 86 10 20 00 clr %g3
}
400126c8: b0 10 00 02 mov %g2, %i0
400126cc: 81 c7 e0 08 ret
400126d0: 93 e8 00 03 restore %g0, %g3, %o1
400126d4 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
400126d4: 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);
400126d8: 90 10 00 18 mov %i0, %o0
400126dc: 7f ff ff c7 call 400125f8 <fat_construct_key>
400126e0: 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;
400126e4: 82 0a 20 01 and %o0, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
400126e8: 85 28 60 02 sll %g1, 2, %g2
400126ec: b7 28 60 04 sll %g1, 4, %i3
400126f0: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
400126f4: 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);
400126f8: 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);
400126fc: 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;
40012700: 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 ));
40012704: 10 80 00 0c b 40012734 <fat_file_open+0x60>
40012708: 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);
4001270c: 7f ff ff bb call 400125f8 <fat_construct_key>
40012710: 92 07 60 20 add %i5, 0x20, %o1
if ( (key1) == ck)
40012714: 80 a7 00 08 cmp %i4, %o0
40012718: 32 80 00 07 bne,a 40012734 <fat_file_open+0x60>
4001271c: 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++;
40012720: 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;
40012724: fa 26 80 00 st %i5, [ %i2 ]
lfat_fd->links_num++;
40012728: 82 00 60 01 inc %g1
4001272c: 10 80 00 42 b 40012834 <fat_file_open+0x160>
40012730: 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) ; )
40012734: 80 a7 40 10 cmp %i5, %l0
40012738: 12 bf ff f5 bne 4001270c <fat_file_open+0x38>
4001273c: 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);
40012740: 10 80 00 3f b 4001283c <fat_file_open+0x168>
40012744: 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);
40012748: 7f ff ff ac call 400125f8 <fat_construct_key> <== NOT EXECUTED
4001274c: 92 07 60 20 add %i5, 0x20, %o1 <== NOT EXECUTED
if ( (key1) == ck)
40012750: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
40012754: 32 80 00 0a bne,a 4001277c <fat_file_open+0xa8> <== NOT EXECUTED
40012758: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
4001275c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40012760: 22 80 00 0b be,a 4001278c <fat_file_open+0xb8> <== NOT EXECUTED
40012764: a0 10 20 00 clr %l0 <== NOT EXECUTED
40012768: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001276c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40012770: 22 80 00 07 be,a 4001278c <fat_file_open+0xb8> <== NOT EXECUTED
40012774: a0 10 20 00 clr %l0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
40012778: 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) ; )
4001277c: 80 a7 40 10 cmp %i5, %l0
40012780: 12 bf ff f2 bne 40012748 <fat_file_open+0x74> <== NEVER TAKEN
40012784: 90 10 00 18 mov %i0, %o0
40012788: 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));
4001278c: 7f ff ce 3d call 40006080 <malloc>
40012790: 90 10 20 44 mov 0x44, %o0
40012794: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
40012798: 80 a2 20 00 cmp %o0, 0
4001279c: 02 80 00 1c be 4001280c <fat_file_open+0x138> <== NEVER TAKEN
400127a0: ba 10 00 08 mov %o0, %i5
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
400127a4: 92 10 20 00 clr %o1
400127a8: 40 00 27 49 call 4001c4cc <memset>
400127ac: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
400127b0: 82 10 20 01 mov 1, %g1
400127b4: c2 27 60 08 st %g1, [ %i5 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
400127b8: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
400127bc: 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;
400127c0: 82 08 7f fe and %g1, -2, %g1
400127c4: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
400127c8: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
400127cc: 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;
400127d0: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
400127d4: 40 00 27 01 call 4001c3d8 <memcpy>
400127d8: 94 10 20 10 mov 0x10, %o2
if ( rc != RC_OK )
400127dc: 80 a4 20 00 cmp %l0, 0
400127e0: 02 80 00 04 be 400127f0 <fat_file_open+0x11c> <== NEVER TAKEN
400127e4: 01 00 00 00 nop
lfat_fd->ino = key;
400127e8: 10 80 00 0f b 40012824 <fat_file_open+0x150>
400127ec: f8 27 60 0c st %i4, [ %i5 + 0xc ]
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
400127f0: 40 00 06 aa call 40014298 <fat_get_unique_ino> <== NOT EXECUTED
400127f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
400127f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400127fc: 12 80 00 0a bne 40012824 <fat_file_open+0x150> <== NOT EXECUTED
40012800: d0 27 60 0c st %o0, [ %i5 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
40012804: 7f ff cc d5 call 40005b58 <free> <== NOT EXECUTED
40012808: 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 );
4001280c: 40 00 24 4e call 4001b944 <__errno> <== NOT EXECUTED
40012810: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012814: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40012818: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001281c: 81 c7 e0 08 ret <== NOT EXECUTED
40012820: 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);
40012824: 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 );
40012828: 92 10 00 1d mov %i5, %o1
4001282c: 7f ff e0 a4 call 4000aabc <_Chain_Append>
40012830: 90 02 00 1b add %o0, %i3, %o0
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
40012834: 81 c7 e0 08 ret
40012838: 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);
4001283c: 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;
40012840: 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 ));
40012844: 10 bf ff ce b 4001277c <fat_file_open+0xa8>
40012848: a0 04 20 04 add %l0, 4, %l0
40012860 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
40012860: 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;
40012864: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
40012868: 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)
4001286c: 80 a6 e0 00 cmp %i3, 0
40012870: 02 80 00 68 be 40012a10 <fat_file_read+0x1b0> <== NEVER TAKEN
40012874: 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 )
40012878: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4001287c: 80 a6 80 01 cmp %i2, %g1
40012880: 1a 80 00 64 bcc 40012a10 <fat_file_read+0x1b0>
40012884: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
40012888: 38 80 00 07 bgu,a 400128a4 <fat_file_read+0x44> <== NEVER TAKEN
4001288c: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
40012890: 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) ||
40012894: 80 a6 80 02 cmp %i2, %g2
40012898: 28 80 00 04 bleu,a 400128a8 <fat_file_read+0x48>
4001289c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
400128a0: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
400128a4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400128a8: 80 a0 60 01 cmp %g1, 1
400128ac: 32 80 00 1c bne,a 4001291c <fat_file_read+0xbc>
400128b0: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
400128b4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
400128b8: 80 a0 60 00 cmp %g1, 0
400128bc: 32 80 00 18 bne,a 4001291c <fat_file_read+0xbc> <== NEVER TAKEN
400128c0: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
400128c4: 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)) &&
400128c8: 80 88 60 03 btst 3, %g1
400128cc: 22 80 00 14 be,a 4001291c <fat_file_read+0xbc>
400128d0: 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);
400128d4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
400128d8: 7f ff ff 3a call 400125c0 <fat_cluster_num_to_sector_num>
400128dc: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
400128e0: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
400128e4: 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);
400128e8: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
400128ec: 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);
400128f0: 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);
400128f4: 94 0e 80 0a and %i2, %o2, %o2
400128f8: 90 10 00 1d mov %i5, %o0
400128fc: 96 10 00 1b mov %i3, %o3
40012900: 40 00 03 13 call 4001354c <_fat_block_read>
40012904: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
40012908: 80 a2 20 00 cmp %o0, 0
4001290c: 16 80 00 41 bge 40012a10 <fat_file_read+0x1b0> <== ALWAYS TAKEN
40012910: 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;
40012914: 10 80 00 3f b 40012a10 <fat_file_read+0x1b0> <== NOT EXECUTED
40012918: 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);
4001291c: f0 17 60 06 lduh [ %i5 + 6 ], %i0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
40012920: 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);
40012924: a6 07 bf fc add %fp, -4, %l3
40012928: 90 10 00 1d mov %i5, %o0
4001292c: 92 10 00 19 mov %i1, %o1
40012930: 94 10 00 12 mov %l2, %o2
40012934: 7f ff ff 42 call 4001263c <fat_file_lseek>
40012938: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
4001293c: 90 92 60 00 orcc %o1, 0, %o0
40012940: 12 80 00 34 bne 40012a10 <fat_file_read+0x1b0> <== NEVER TAKEN
40012944: 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);
40012948: b1 2e 20 10 sll %i0, 0x10, %i0
4001294c: b1 36 20 10 srl %i0, 0x10, %i0
40012950: b0 06 3f ff add %i0, -1, %i0
40012954: b4 0e 80 18 and %i2, %i0, %i2
40012958: b0 10 20 00 clr %i0
4001295c: 10 80 00 20 b 400129dc <fat_file_read+0x17c>
40012960: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
40012964: a0 24 00 11 sub %l0, %l1, %l0
40012968: 80 a4 00 1b cmp %l0, %i3
4001296c: 38 80 00 02 bgu,a 40012974 <fat_file_read+0x114>
40012970: a0 10 00 1b mov %i3, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
40012974: d2 07 bf fc ld [ %fp + -4 ], %o1
40012978: 7f ff ff 12 call 400125c0 <fat_cluster_num_to_sector_num>
4001297c: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
40012980: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
40012984: 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);
40012988: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
4001298c: 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);
40012990: 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);
40012994: 94 0c 40 0a and %l1, %o2, %o2
40012998: 90 10 00 1d mov %i5, %o0
4001299c: 96 10 00 10 mov %l0, %o3
400129a0: 40 00 02 eb call 4001354c <_fat_block_read>
400129a4: 98 07 00 18 add %i4, %i0, %o4
if ( ret < 0 )
400129a8: 80 a2 20 00 cmp %o0, 0
400129ac: 06 80 00 18 bl 40012a0c <fat_file_read+0x1ac> <== NEVER TAKEN
400129b0: b6 26 c0 10 sub %i3, %l0, %i3
return -1;
count -= c;
cmpltd += c;
400129b4: b0 06 00 10 add %i0, %l0, %i0
save_cln = cur_cln;
400129b8: e0 07 bf fc ld [ %fp + -4 ], %l0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
400129bc: 90 10 00 1d mov %i5, %o0
400129c0: 92 10 00 10 mov %l0, %o1
400129c4: 94 10 00 13 mov %l3, %o2
400129c8: 40 00 1b f2 call 40019990 <fat_get_fat_cluster>
400129cc: a2 10 20 00 clr %l1
if ( rc != RC_OK )
400129d0: 80 a2 20 00 cmp %o0, 0
400129d4: 12 80 00 0f bne 40012a10 <fat_file_read+0x1b0> <== NEVER TAKEN
400129d8: 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)
400129dc: 80 a6 e0 00 cmp %i3, 0
400129e0: 32 bf ff e1 bne,a 40012964 <fat_file_read+0x104>
400129e4: 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);
400129e8: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
400129ec: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
400129f0: 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);
400129f4: b4 06 80 18 add %i2, %i0, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
400129f8: 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);
400129fc: 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 +
40012a00: a4 06 80 12 add %i2, %l2, %l2
40012a04: 10 80 00 03 b 40012a10 <fat_file_read+0x1b0>
40012a08: 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;
40012a0c: 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;
}
40012a10: 81 c7 e0 08 ret
40012a14: 91 e8 00 08 restore %g0, %o0, %o0
40013188 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40013188: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
4001318c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40013190: 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)) &&
40013194: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40013198: 80 a0 60 01 cmp %g1, 1
4001319c: 12 80 00 0d bne 400131d0 <fat_file_size+0x48>
400131a0: ba 10 00 18 mov %i0, %i5
400131a4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
400131a8: 80 a0 60 00 cmp %g1, 0
400131ac: 32 80 00 0a bne,a 400131d4 <fat_file_size+0x4c> <== NEVER TAKEN
400131b0: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
400131b4: 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)) &&
400131b8: 80 88 60 03 btst 3, %g1
400131bc: 22 80 00 06 be,a 400131d4 <fat_file_size+0x4c> <== ALWAYS TAKEN
400131c0: 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;
400131c4: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
400131c8: 10 80 00 18 b 40013228 <fat_file_size+0xa0> <== NOT EXECUTED
400131cc: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
400131d0: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
400131d4: 10 80 00 0d b 40013208 <fat_file_size+0x80>
400131d8: 82 10 20 00 clr %g1
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
400131dc: 92 10 00 1c mov %i4, %o1
400131e0: 40 00 19 ec call 40019990 <fat_get_fat_cluster>
400131e4: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
400131e8: b0 92 20 00 orcc %o0, 0, %i0
400131ec: 12 80 00 10 bne 4001322c <fat_file_size+0xa4> <== NEVER TAKEN
400131f0: 01 00 00 00 nop
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
400131f4: c2 17 60 06 lduh [ %i5 + 6 ], %g1
400131f8: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
400131fc: 82 00 80 01 add %g2, %g1, %g1
40013200: 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;
40013204: 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)
40013208: f8 07 bf fc ld [ %fp + -4 ], %i4
4001320c: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
40013210: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
40013214: 86 0f 00 03 and %i4, %g3, %g3
40013218: 80 a0 c0 02 cmp %g3, %g2
4001321c: 0a bf ff f0 bcs 400131dc <fat_file_size+0x54>
40013220: 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;
40013224: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
40013228: b0 10 20 00 clr %i0
return rc;
}
4001322c: 81 c7 e0 08 ret
40013230: 81 e8 00 00 restore
40012a18 <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
40012a18: 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;
40012a1c: 82 10 3f ff mov -1, %g1
40012a20: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
40012a24: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40012a28: 80 a6 80 01 cmp %i2, %g1
40012a2c: 0a 80 00 04 bcs 40012a3c <fat_file_truncate+0x24>
40012a30: c0 27 bf f8 clr [ %fp + -8 ]
return rc;
40012a34: 10 80 00 3b b 40012b20 <fat_file_truncate+0x108>
40012a38: 92 10 20 00 clr %o1
assert(fat_fd->fat_file_size);
40012a3c: 80 a0 60 00 cmp %g1, 0
40012a40: 32 80 00 0a bne,a 40012a68 <fat_file_truncate+0x50> <== ALWAYS TAKEN
40012a44: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
40012a48: 11 10 00 b0 sethi %hi(0x4002c000), %o0 <== NOT EXECUTED
40012a4c: 15 10 00 b0 sethi %hi(0x4002c000), %o2 <== NOT EXECUTED
40012a50: 17 10 00 b0 sethi %hi(0x4002c000), %o3 <== NOT EXECUTED
40012a54: 90 12 23 18 or %o0, 0x318, %o0 <== NOT EXECUTED
40012a58: 92 10 22 d1 mov 0x2d1, %o1 <== NOT EXECUTED
40012a5c: 94 12 a3 78 or %o2, 0x378, %o2 <== NOT EXECUTED
40012a60: 7f ff cb d8 call 400059c0 <__assert_func> <== NOT EXECUTED
40012a64: 96 12 e3 60 or %o3, 0x360, %o3 <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
40012a68: c6 16 20 06 lduh [ %i0 + 6 ], %g3
40012a6c: 86 00 ff ff add %g3, -1, %g3
40012a70: b4 00 c0 1a add %g3, %i2, %i2
40012a74: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
40012a78: 85 2e 80 02 sll %i2, %g2, %g2
40012a7c: 80 a0 80 01 cmp %g2, %g1
40012a80: 1a bf ff ed bcc 40012a34 <fat_file_truncate+0x1c>
40012a84: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
40012a88: 12 80 00 0b bne 40012ab4 <fat_file_truncate+0x9c>
40012a8c: 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);
40012a90: 92 10 00 19 mov %i1, %o1
40012a94: 94 10 00 1a mov %i2, %o2
40012a98: 7f ff fe e9 call 4001263c <fat_file_lseek>
40012a9c: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
40012aa0: 80 a2 60 00 cmp %o1, 0
40012aa4: 32 80 00 20 bne,a 40012b24 <fat_file_truncate+0x10c> <== NEVER TAKEN
40012aa8: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
40012aac: 10 80 00 0b b 40012ad8 <fat_file_truncate+0xc0>
40012ab0: 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);
40012ab4: 92 10 00 19 mov %i1, %o1
40012ab8: 94 06 bf ff add %i2, -1, %o2
40012abc: 7f ff fe e0 call 4001263c <fat_file_lseek>
40012ac0: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40012ac4: 80 a2 60 00 cmp %o1, 0
40012ac8: 02 bf ff f2 be 40012a90 <fat_file_truncate+0x78> <== ALWAYS TAKEN
40012acc: 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;
}
40012ad0: 81 c7 e0 08 ret <== NOT EXECUTED
40012ad4: 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);
40012ad8: 40 00 1c c1 call 40019ddc <fat_free_fat_clusters_chain>
40012adc: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
40012ae0: 92 92 20 00 orcc %o0, 0, %o1
40012ae4: 12 80 00 0f bne 40012b20 <fat_file_truncate+0x108> <== NEVER TAKEN
40012ae8: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
40012aec: 02 80 00 0d be 40012b20 <fat_file_truncate+0x108>
40012af0: 92 10 20 00 clr %o1
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
40012af4: d2 07 bf fc ld [ %fp + -4 ], %o1
40012af8: 90 10 00 18 mov %i0, %o0
40012afc: 40 00 1c 17 call 40019b58 <fat_set_fat_cluster>
40012b00: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
40012b04: 92 92 20 00 orcc %o0, 0, %o1
40012b08: 12 80 00 06 bne 40012b20 <fat_file_truncate+0x108> <== NEVER TAKEN
40012b0c: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
40012b10: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
40012b14: 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;
40012b18: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
40012b1c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
}
return RC_OK;
}
40012b20: b0 10 00 09 mov %o1, %i0
40012b24: 81 c7 e0 08 ret
40012b28: 81 e8 00 00 restore
40012f08 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40012f08: 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;
40012f0c: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40012f10: 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;
40012f14: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t file_cln_initial = fat_fd->map.file_cln;
40012f18: e6 06 60 34 ld [ %i1 + 0x34 ], %l3
uint32_t cln;
if ( count == 0 )
40012f1c: 80 a6 e0 00 cmp %i3, 0
40012f20: 02 80 00 84 be 40013130 <fat_file_write+0x228> <== NEVER TAKEN
40012f24: 90 10 20 00 clr %o0
return cmpltd;
if (start >= fat_fd->size_limit)
40012f28: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
40012f2c: 80 a6 80 1d cmp %i2, %i5
40012f30: 2a 80 00 07 bcs,a 40012f4c <fat_file_write+0x44> <== ALWAYS TAKEN
40012f34: ba 27 40 1a sub %i5, %i2, %i5
rtems_set_errno_and_return_minus_one(EFBIG);
40012f38: 40 00 22 83 call 4001b944 <__errno> <== NOT EXECUTED
40012f3c: 01 00 00 00 nop <== NOT EXECUTED
40012f40: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b> <== NOT EXECUTED
40012f44: 10 80 00 30 b 40013004 <fat_file_write+0xfc> <== NOT EXECUTED
40012f48: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012f4c: 80 a7 40 1b cmp %i5, %i3
40012f50: 38 80 00 02 bgu,a 40012f58 <fat_file_write+0x50> <== ALWAYS TAKEN
40012f54: 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;
40012f58: 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);
40012f5c: b6 07 40 1a add %i5, %i2, %i3
40012f60: 94 40 20 00 addx %g0, 0, %o2
40012f64: 90 10 00 10 mov %l0, %o0
40012f68: 92 10 00 19 mov %i1, %o1
40012f6c: 96 10 00 1b mov %i3, %o3
40012f70: 7f ff ff 50 call 40012cb0 <fat_file_extend>
40012f74: 98 07 bf f8 add %fp, -8, %o4
if (RC_OK == rc)
40012f78: 80 a2 20 00 cmp %o0, 0
40012f7c: 12 80 00 6d bne 40013130 <fat_file_write+0x228>
40012f80: 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))
40012f84: 80 a0 40 1b cmp %g1, %i3
40012f88: 32 80 00 02 bne,a 40012f90 <fat_file_write+0x88> <== NEVER TAKEN
40012f8c: 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));
40012f90: 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))
40012f94: 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));
40012f98: 80 a0 e0 01 cmp %g3, 1
40012f9c: 12 80 00 09 bne 40012fc0 <fat_file_write+0xb8>
40012fa0: 82 10 20 00 clr %g1
40012fa4: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
40012fa8: 80 a0 e0 00 cmp %g3, 0
40012fac: 12 80 00 06 bne 40012fc4 <fat_file_write+0xbc> <== NEVER TAKEN
40012fb0: 80 a0 60 00 cmp %g1, 0
40012fb4: 82 08 a0 03 and %g2, 3, %g1
40012fb8: 80 a0 00 01 cmp %g0, %g1
40012fbc: 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))
40012fc0: 80 a0 60 00 cmp %g1, 0
40012fc4: 02 80 00 12 be 4001300c <fat_file_write+0x104>
40012fc8: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
{
cln = fat_fd->cln;
40012fcc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
cln += (start >> fs_info->vol.bpc_log2);
byte = start & (fs_info->vol.bpc -1);
40012fd0: 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);
40012fd4: b7 36 80 1b srl %i2, %i3, %i3
byte = start & (fs_info->vol.bpc -1);
40012fd8: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
40012fdc: 90 10 00 10 mov %l0, %o0
40012fe0: 92 06 c0 09 add %i3, %o1, %o1
40012fe4: 94 0e 80 0a and %i2, %o2, %o2
40012fe8: 96 10 00 1d mov %i5, %o3
40012fec: 98 10 00 1c mov %i4, %o4
40012ff0: 40 00 01 e5 call 40013784 <fat_cluster_write>
40012ff4: 9a 10 20 00 clr %o5
cln,
byte,
count,
buf,
false);
if (0 > ret)
40012ff8: 80 a2 20 00 cmp %o0, 0
40012ffc: 16 80 00 4d bge 40013130 <fat_file_write+0x228> <== ALWAYS TAKEN
40013000: 01 00 00 00 nop
rc = -1;
40013004: 10 80 00 4b b 40013130 <fat_file_write+0x228> <== NOT EXECUTED
40013008: 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;
4001300c: 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;
40013010: 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);
40013014: 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;
40013018: 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);
4001301c: 90 10 00 10 mov %l0, %o0
40013020: 92 10 00 19 mov %i1, %o1
40013024: 94 10 00 11 mov %l1, %o2
40013028: 7f ff fd 85 call 4001263c <fat_file_lseek>
4001302c: 96 10 00 15 mov %l5, %o3
if (RC_OK == rc)
40013030: 80 a2 60 00 cmp %o1, 0
40013034: 12 80 00 34 bne 40013104 <fat_file_write+0x1fc> <== NEVER TAKEN
40013038: b7 2c 40 1b sll %l1, %i3, %i3
{
file_cln_cnt = cur_cln - fat_fd->cln;
4001303c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40013040: e4 07 bf fc ld [ %fp + -4 ], %l2
40013044: 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);
40013048: 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;
4001304c: 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);
40013050: 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;
40013054: 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 */
40013058: 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;
4001305c: 10 80 00 1a b 400130c4 <fat_file_write+0x1bc>
40013060: 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));
40013064: 96 22 c0 18 sub %o3, %i0, %o3
40013068: 80 a2 c0 1d cmp %o3, %i5
4001306c: 38 80 00 02 bgu,a 40013074 <fat_file_write+0x16c>
40013070: 96 10 00 1d mov %i5, %o3
if (file_cln_initial < file_cln_cnt)
40013074: 80 a4 c0 12 cmp %l3, %l2
40013078: 2a 80 00 02 bcs,a 40013080 <fat_file_write+0x178>
4001307c: a8 10 20 01 mov 1, %l4
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
40013080: d2 07 bf fc ld [ %fp + -4 ], %o1
40013084: 90 10 00 10 mov %l0, %o0
40013088: 94 10 00 18 mov %i0, %o2
4001308c: 98 07 00 1b add %i4, %i3, %o4
40013090: 40 00 01 bd call 40013784 <fat_cluster_write>
40013094: 9a 0d 20 01 and %l4, 1, %o5
40013098: 82 10 00 08 mov %o0, %g1
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
4001309c: 80 a0 60 00 cmp %g1, 0
400130a0: 16 80 00 1d bge 40013114 <fat_file_write+0x20c> <== ALWAYS TAKEN
400130a4: 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)
400130a8: 10 80 00 08 b 400130c8 <fat_file_write+0x1c0> <== NOT EXECUTED
400130ac: 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);
400130b0: 90 10 00 10 mov %l0, %o0
400130b4: 92 10 00 16 mov %l6, %o1
400130b8: 40 00 1a 36 call 40019990 <fat_get_fat_cluster>
400130bc: 94 10 00 15 mov %l5, %o2
ofs_cln = 0;
400130c0: 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)
400130c4: 80 a7 60 00 cmp %i5, 0
400130c8: 02 80 00 04 be 400130d8 <fat_file_write+0x1d0>
400130cc: 80 a2 20 00 cmp %o0, 0
400130d0: 22 bf ff e5 be,a 40013064 <fat_file_write+0x15c> <== ALWAYS TAKEN
400130d4: 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);
400130d8: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
400130dc: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
400130e0: 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);
400130e4: b4 06 80 1b add %i2, %i3, %i2
400130e8: b5 36 80 01 srl %i2, %g1, %i2
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
400130ec: 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)
400130f0: 92 92 20 00 orcc %o0, 0, %o1
400130f4: 12 80 00 03 bne 40013100 <fat_file_write+0x1f8> <== NEVER TAKEN
400130f8: e2 26 60 34 st %l1, [ %i1 + 0x34 ]
return rc;
else
return cmpltd;
400130fc: 92 10 00 1b mov %i3, %o1
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
40013100: 80 a2 60 00 cmp %o1, 0
40013104: 16 80 00 0b bge 40013130 <fat_file_write+0x228> <== ALWAYS TAKEN
40013108: 90 10 00 09 mov %o1, %o0
4001310c: 10 80 00 09 b 40013130 <fat_file_write+0x228> <== NOT EXECUTED
40013110: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
if (0 > ret)
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
40013114: a4 04 a0 01 inc %l2
bytes_to_write -= ret;
cmpltd += ret;
40013118: b6 06 c0 01 add %i3, %g1, %i3
save_cln = cur_cln;
if (0 < bytes_to_write)
4001311c: ba a7 40 01 subcc %i5, %g1, %i5
40013120: 12 bf ff e4 bne 400130b0 <fat_file_write+0x1a8>
40013124: ec 07 bf fc ld [ %fp + -4 ], %l6
40013128: 10 bf ff e6 b 400130c0 <fat_file_write+0x1b8>
4001312c: 90 10 20 00 clr %o0
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
40013130: 81 c7 e0 08 ret
40013134: 91 e8 00 08 restore %g0, %o0, %o0
40019ddc <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
40019ddc: 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;
40019de0: b8 10 20 00 clr %i4
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
40019de4: ba 10 00 18 mov %i0, %i5
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
40019de8: 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;
40019dec: 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)
40019df0: 10 80 00 19 b 40019e54 <fat_free_fat_clusters_chain+0x78>
40019df4: b4 10 20 00 clr %i2
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
40019df8: 92 10 00 1b mov %i3, %o1
40019dfc: 7f ff fe e5 call 40019990 <fat_get_fat_cluster>
40019e00: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40019e04: b0 92 20 00 orcc %o0, 0, %i0
40019e08: 02 80 00 0b be 40019e34 <fat_free_fat_clusters_chain+0x58><== ALWAYS TAKEN
40019e0c: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
40019e10: c2 07 60 44 ld [ %i5 + 0x44 ], %g1 <== NOT EXECUTED
40019e14: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
40019e18: 02 80 00 03 be 40019e24 <fat_free_fat_clusters_chain+0x48><== NOT EXECUTED
40019e1c: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
40019e20: f8 27 60 44 st %i4, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
40019e24: 7f ff e5 27 call 400132c0 <fat_buf_release> <== NOT EXECUTED
40019e28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019e2c: 81 c7 e0 08 ret <== NOT EXECUTED
40019e30: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
40019e34: 92 10 00 1b mov %i3, %o1
40019e38: 7f ff ff 48 call 40019b58 <fat_set_fat_cluster>
40019e3c: 94 10 20 00 clr %o2
if ( rc != RC_OK )
40019e40: 80 a2 20 00 cmp %o0, 0
40019e44: 32 80 00 02 bne,a 40019e4c <fat_free_fat_clusters_chain+0x70><== NEVER TAKEN
40019e48: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
40019e4c: 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++;
40019e50: 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)
40019e54: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
40019e58: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40019e5c: 84 0e c0 02 and %i3, %g2, %g2
40019e60: 80 a0 80 01 cmp %g2, %g1
40019e64: 0a bf ff e5 bcs 40019df8 <fat_free_fat_clusters_chain+0x1c>
40019e68: 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)
40019e6c: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
40019e70: 80 a0 7f ff cmp %g1, -1
40019e74: 02 80 00 05 be 40019e88 <fat_free_fat_clusters_chain+0xac><== ALWAYS TAKEN
40019e78: f2 27 60 4c st %i1, [ %i5 + 0x4c ]
fs_info->vol.free_cls += freed_cls_cnt;
40019e7c: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
40019e80: f8 27 60 44 st %i4, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
40019e84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019e88: 7f ff e5 0e call 400132c0 <fat_buf_release>
40019e8c: b0 10 00 1a mov %i2, %i0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
40019e90: 81 c7 e0 08 ret
40019e94: 81 e8 00 00 restore
40014358 <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);
40014358: c2 02 20 80 ld [ %o0 + 0x80 ], %g1 <== NOT EXECUTED
4001435c: c4 02 20 74 ld [ %o0 + 0x74 ], %g2 <== NOT EXECUTED
40014360: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
40014364: 92 22 40 01 sub %o1, %g1, %o1 <== NOT EXECUTED
40014368: 83 32 60 03 srl %o1, 3, %g1 <== NOT EXECUTED
4001436c: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
40014370: 93 28 c0 09 sll %g3, %o1, %o1 <== NOT EXECUTED
40014374: c6 08 80 01 ldub [ %g2 + %g1 ], %g3 <== NOT EXECUTED
40014378: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
4001437c: 81 c3 e0 08 retl <== NOT EXECUTED
40014380: d2 28 80 01 stb %o1, [ %g2 + %g1 ] <== NOT EXECUTED
40019990 <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
40019990: 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)) )
40019994: 80 a6 60 01 cmp %i1, 1
40019998: 08 80 00 67 bleu 40019b34 <fat_get_fat_cluster+0x1a4> <== NEVER TAKEN
4001999c: ba 10 00 18 mov %i0, %i5
400199a0: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
400199a4: 82 00 60 01 inc %g1
400199a8: 80 a6 40 01 cmp %i1, %g1
400199ac: 28 80 00 03 bleu,a 400199b8 <fat_get_fat_cluster+0x28> <== ALWAYS TAKEN
400199b0: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
400199b4: 30 80 00 60 b,a 40019b34 <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) +
400199b8: 86 08 60 01 and %g1, 1, %g3
400199bc: 80 88 e0 ff btst 0xff, %g3
400199c0: 02 80 00 05 be 400199d4 <fat_get_fat_cluster+0x44>
400199c4: 88 08 60 02 and %g1, 2, %g4
400199c8: 85 36 60 01 srl %i1, 1, %g2
400199cc: 10 80 00 06 b 400199e4 <fat_get_fat_cluster+0x54>
400199d0: 84 00 80 19 add %g2, %i1, %g2
400199d4: 80 89 20 ff btst 0xff, %g4
400199d8: 02 80 00 03 be 400199e4 <fat_get_fat_cluster+0x54>
400199dc: 85 2e 60 02 sll %i1, 2, %g2
400199e0: 85 2e 60 01 sll %i1, 1, %g2
400199e4: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
400199e8: c8 07 60 58 ld [ %i5 + 0x58 ], %g4
400199ec: 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);
400199f0: 80 88 e0 ff btst 0xff, %g3
400199f4: 02 80 00 05 be 40019a08 <fat_get_fat_cluster+0x78>
400199f8: b6 00 80 04 add %g2, %g4, %i3
400199fc: b9 36 60 01 srl %i1, 1, %i4
40019a00: 10 80 00 07 b 40019a1c <fat_get_fat_cluster+0x8c>
40019a04: b8 07 00 19 add %i4, %i1, %i4
40019a08: 82 08 60 02 and %g1, 2, %g1
40019a0c: 80 88 60 ff btst 0xff, %g1
40019a10: 02 80 00 03 be 40019a1c <fat_get_fat_cluster+0x8c>
40019a14: b9 2e 60 02 sll %i1, 2, %i4
40019a18: b9 2e 60 01 sll %i1, 1, %i4
40019a1c: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
40019a20: 90 10 00 1d mov %i5, %o0
40019a24: 92 10 00 1b mov %i3, %o1
40019a28: 94 10 20 01 mov 1, %o2
40019a2c: 7f ff e6 99 call 40013490 <fat_buf_access>
40019a30: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40019a34: b0 92 20 00 orcc %o0, 0, %i0
40019a38: 12 80 00 37 bne 40019b14 <fat_get_fat_cluster+0x184> <== NEVER TAKEN
40019a3c: 83 2c 20 10 sll %l0, 0x10, %g1
return rc;
switch ( fs_info->vol.type )
40019a40: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
40019a44: 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);
40019a48: 83 30 60 10 srl %g1, 0x10, %g1
40019a4c: 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 )
40019a50: 02 80 00 27 be 40019aec <fat_get_fat_cluster+0x15c>
40019a54: 82 0f 00 01 and %i4, %g1, %g1
40019a58: 80 a0 a0 04 cmp %g2, 4
40019a5c: 02 80 00 30 be 40019b1c <fat_get_fat_cluster+0x18c>
40019a60: 80 a0 a0 01 cmp %g2, 1
40019a64: 12 80 00 34 bne 40019b34 <fat_get_fat_cluster+0x1a4> <== NEVER TAKEN
40019a68: 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) )
40019a6c: 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));
40019a70: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
if ( ofs == (fs_info->vol.bps - 1) )
40019a74: 88 01 3f ff add %g4, -1, %g4
40019a78: 80 a0 40 04 cmp %g1, %g4
40019a7c: 12 80 00 10 bne 40019abc <fat_get_fat_cluster+0x12c> <== ALWAYS TAKEN
40019a80: c4 26 80 00 st %g2, [ %i2 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
40019a84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019a88: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
40019a8c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40019a90: 7f ff e6 80 call 40013490 <fat_buf_access> <== NOT EXECUTED
40019a94: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
40019a98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019a9c: 12 80 00 2c bne 40019b4c <fat_get_fat_cluster+0x1bc> <== NOT EXECUTED
40019aa0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
40019aa4: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
40019aa8: c2 08 40 00 ldub [ %g1 ], %g1 <== NOT EXECUTED
40019aac: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
40019ab0: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
40019ab4: 10 80 00 07 b 40019ad0 <fat_get_fat_cluster+0x140> <== NOT EXECUTED
40019ab8: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
40019abc: 82 00 c0 01 add %g3, %g1, %g1
40019ac0: c2 08 60 01 ldub [ %g1 + 1 ], %g1
40019ac4: 83 28 60 08 sll %g1, 8, %g1
40019ac8: 84 10 40 02 or %g1, %g2, %g2
40019acc: c4 26 80 00 st %g2, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
40019ad0: 80 8e 60 01 btst 1, %i1
40019ad4: 02 80 00 04 be 40019ae4 <fat_get_fat_cluster+0x154>
40019ad8: c2 06 80 00 ld [ %i2 ], %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
40019adc: 10 80 00 0d b 40019b10 <fat_get_fat_cluster+0x180>
40019ae0: 83 30 60 04 srl %g1, 4, %g1
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
40019ae4: 10 80 00 0b b 40019b10 <fat_get_fat_cluster+0x180>
40019ae8: 82 08 6f ff and %g1, 0xfff, %g1
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
40019aec: c4 07 bf fc ld [ %fp + -4 ], %g2
*ret_val = CF_LE_W(*ret_val);
40019af0: 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));
40019af4: c2 10 80 01 lduh [ %g2 + %g1 ], %g1
*ret_val = CF_LE_W(*ret_val);
40019af8: 86 10 e3 ff or %g3, 0x3ff, %g3
40019afc: 83 28 60 10 sll %g1, 0x10, %g1
40019b00: 85 30 60 18 srl %g1, 0x18, %g2
40019b04: 83 30 60 08 srl %g1, 8, %g1
40019b08: 82 08 40 03 and %g1, %g3, %g1
40019b0c: 82 10 80 01 or %g2, %g1, %g1
40019b10: c2 26 80 00 st %g1, [ %i2 ]
break;
40019b14: 81 c7 e0 08 ret
40019b18: 81 e8 00 00 restore
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
40019b1c: c4 07 bf fc ld [ %fp + -4 ], %g2
40019b20: 7f ff ff 90 call 40019960 <CPU_swap_u32>
40019b24: d0 00 80 01 ld [ %g2 + %g1 ], %o0
40019b28: d0 26 80 00 st %o0, [ %i2 ]
break;
40019b2c: 81 c7 e0 08 ret
40019b30: 81 e8 00 00 restore
default:
rtems_set_errno_and_return_minus_one(EIO);
40019b34: 40 00 07 84 call 4001b944 <__errno> <== NOT EXECUTED
40019b38: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40019b3c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40019b40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40019b44: 81 c7 e0 08 ret <== NOT EXECUTED
40019b48: 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)
40019b4c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
40019b50: 81 c7 e0 08 ret <== NOT EXECUTED
40019b54: 81 e8 00 00 restore <== NOT EXECUTED
40014298 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
40014298: 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))
4001429c: 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)
400142a0: 10 80 00 2b b 4001434c <fat_get_unique_ino+0xb4> <== NOT EXECUTED
400142a4: 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))
400142a8: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
400142ac: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
400142b0: b6 00 c0 02 add %g3, %g2, %i3 <== NOT EXECUTED
400142b4: f4 08 c0 02 ldub [ %g3 + %g2 ], %i2 <== NOT EXECUTED
400142b8: c4 48 c0 02 ldsb [ %g3 + %g2 ], %g2 <== NOT EXECUTED
400142bc: ba 08 60 07 and %g1, 7, %i5 <== NOT EXECUTED
400142c0: 85 38 80 1d sra %g2, %i5, %g2 <== NOT EXECUTED
400142c4: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
400142c8: 12 80 00 0a bne 400142f0 <fat_get_unique_ino+0x58> <== NOT EXECUTED
400142cc: 82 00 60 01 inc %g1 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
400142d0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400142d4: bb 28 40 1d sll %g1, %i5, %i5 <== NOT EXECUTED
400142d8: ba 17 40 1a or %i5, %i2, %i5 <== NOT EXECUTED
400142dc: fa 2e c0 00 stb %i5, [ %i3 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
400142e0: c4 06 20 78 ld [ %i0 + 0x78 ], %g2 <== NOT EXECUTED
400142e4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
400142e8: 81 c7 e0 08 ret <== NOT EXECUTED
400142ec: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
400142f0: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
400142f4: 3a 80 00 03 bcc,a 40014300 <fat_get_unique_ino+0x68> <== NOT EXECUTED
400142f8: c0 26 20 78 clr [ %i0 + 0x78 ] <== NOT EXECUTED
400142fc: 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++)
40014300: 92 02 60 01 inc %o1 <== NOT EXECUTED
40014304: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
40014308: 32 bf ff e8 bne,a 400142a8 <fat_get_unique_ino+0x10> <== NOT EXECUTED
4001430c: 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))
40014310: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40014314: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
40014318: 82 27 00 01 sub %i4, %g1, %g1 <== NOT EXECUTED
4001431c: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
40014320: 2a 80 00 04 bcs,a 40014330 <fat_get_unique_ino+0x98> <== NOT EXECUTED
40014324: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
40014328: 81 c7 e0 08 ret <== NOT EXECUTED
4001432c: 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);
40014330: 7f ff c9 f6 call 40006b08 <realloc> <== NOT EXECUTED
40014334: d2 26 20 7c st %o1, [ %i0 + 0x7c ] <== NOT EXECUTED
if (fs_info->uino != NULL)
40014338: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001433c: 02 bf ff fb be 40014328 <fat_get_unique_ino+0x90> <== NOT EXECUTED
40014340: d0 26 20 74 st %o0, [ %i0 + 0x74 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
40014344: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED
40014348: 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++)
4001434c: c8 06 20 7c ld [ %i0 + 0x7c ], %g4 <== NOT EXECUTED
40014350: 10 bf ff ed b 40014304 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
40014354: 92 10 20 00 clr %o1 <== NOT EXECUTED
40014220 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
40014220: 9d e3 bf 98 save %sp, -104, %sp
40014224: 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)
40014228: 10 80 00 10 b 40014268 <fat_init_clusters_chain+0x48>
4001422c: f2 27 bf fc st %i1, [ %fp + -4 ]
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40014230: 90 10 00 1d mov %i5, %o0
40014234: 94 10 20 00 clr %o2
40014238: 7f ff fd 0b call 40013664 <fat_cluster_set>
4001423c: 98 10 20 00 clr %o4
if ( ret != fs_info->vol.bpc )
40014240: c2 17 60 06 lduh [ %i5 + 6 ], %g1
40014244: 80 a2 00 01 cmp %o0, %g1
40014248: 12 80 00 11 bne 4001428c <fat_init_clusters_chain+0x6c> <== NEVER TAKEN
4001424c: d2 07 bf fc ld [ %fp + -4 ], %o1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40014250: 90 10 00 1d mov %i5, %o0
40014254: 40 00 15 cf call 40019990 <fat_get_fat_cluster>
40014258: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
4001425c: b0 92 20 00 orcc %o0, 0, %i0
40014260: 12 80 00 0c bne 40014290 <fat_init_clusters_chain+0x70> <== NEVER TAKEN
40014264: 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)
40014268: d2 07 bf fc ld [ %fp + -4 ], %o1
4001426c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
40014270: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40014274: 84 0a 40 02 and %o1, %g2, %g2
40014278: 80 a0 80 01 cmp %g2, %g1
4001427c: 2a bf ff ed bcs,a 40014230 <fat_init_clusters_chain+0x10>
40014280: d6 17 60 06 lduh [ %i5 + 6 ], %o3
return rc;
}
}
return rc;
40014284: 81 c7 e0 08 ret
40014288: 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;
4001428c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
}
return rc;
}
40014290: 81 c7 e0 08 ret <== NOT EXECUTED
40014294: 81 e8 00 00 restore <== NOT EXECUTED
400138b0 <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)
{
400138b0: 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);
400138b4: 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)
{
400138b8: 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;
400138bc: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
400138c0: 7f ff cb f7 call 4000689c <open>
400138c4: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
400138c8: 80 a2 20 00 cmp %o0, 0
400138cc: 06 80 00 17 bl 40013928 <fat_init_volume_info+0x78> <== NEVER TAKEN
400138d0: d0 26 e0 60 st %o0, [ %i3 + 0x60 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
400138d4: 7f ff c8 cb call 40005c00 <fstat>
400138d8: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
400138dc: 80 a2 20 00 cmp %o0, 0
400138e0: 12 80 00 10 bne 40013920 <fat_init_volume_info+0x70> <== NEVER TAKEN
400138e4: 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))
400138e8: c6 07 bf c4 ld [ %fp + -60 ], %g3
400138ec: 05 00 00 3c sethi %hi(0xf000), %g2
400138f0: 86 08 c0 02 and %g3, %g2, %g3
400138f4: 05 00 00 18 sethi %hi(0x6000), %g2
400138f8: 80 a0 c0 02 cmp %g3, %g2
400138fc: 12 80 00 09 bne 40013920 <fat_init_volume_info+0x70> <== NEVER TAKEN
40013900: 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);
40013904: 94 06 20 64 add %i0, 0x64, %o2
40013908: 40 00 05 5e call 40014e80 <ioctl>
4001390c: 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) {
40013910: 80 a2 20 00 cmp %o0, 0
40013914: 22 80 00 09 be,a 40013938 <fat_init_volume_info+0x88> <== ALWAYS TAKEN
40013918: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
close(vol->fd);
4001391c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40013920: 7f ff c8 6d call 40005ad4 <close> <== NOT EXECUTED
40013924: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
40013928: 40 00 20 07 call 4001b944 <__errno> <== NOT EXECUTED
4001392c: 01 00 00 00 nop <== NOT EXECUTED
40013930: 10 80 01 af b 40013fec <fat_init_volume_info+0x73c> <== NOT EXECUTED
40013934: 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);
40013938: 92 10 20 00 clr %o1
4001393c: 7f ff f6 9a call 400113a4 <rtems_bdbuf_read>
40013940: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
40013944: 80 a2 20 00 cmp %o0, 0
40013948: 22 80 00 03 be,a 40013954 <fat_init_volume_info+0xa4> <== ALWAYS TAKEN
4001394c: d0 07 bf a4 ld [ %fp + -92 ], %o0
40013950: 30 80 00 32 b,a 40013a18 <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);
40013954: c6 02 20 1c ld [ %o0 + 0x1c ], %g3
40013958: c2 08 e0 20 ldub [ %g3 + 0x20 ], %g1
4001395c: c4 08 e0 0b ldub [ %g3 + 0xb ], %g2
40013960: c2 2f bf 9a stb %g1, [ %fp + -102 ]
40013964: c2 08 e0 22 ldub [ %g3 + 0x22 ], %g1
40013968: d2 08 e0 0c ldub [ %g3 + 0xc ], %o1
4001396c: c2 2f bf 9b stb %g1, [ %fp + -101 ]
40013970: c2 08 e0 23 ldub [ %g3 + 0x23 ], %g1
40013974: d8 08 e0 0e ldub [ %g3 + 0xe ], %o4
40013978: c2 2f bf 8f stb %g1, [ %fp + -113 ]
4001397c: c2 08 e0 2c ldub [ %g3 + 0x2c ], %g1
40013980: d6 08 e0 0f ldub [ %g3 + 0xf ], %o3
40013984: c2 2f bf 9e stb %g1, [ %fp + -98 ]
40013988: c2 08 e0 2d ldub [ %g3 + 0x2d ], %g1
4001398c: c8 08 e0 11 ldub [ %g3 + 0x11 ], %g4
40013990: c2 2f bf 9d stb %g1, [ %fp + -99 ]
40013994: c2 08 e0 2e ldub [ %g3 + 0x2e ], %g1
40013998: da 08 e0 12 ldub [ %g3 + 0x12 ], %o5
4001399c: c2 2f bf 9c stb %g1, [ %fp + -100 ]
400139a0: c2 08 e0 2f ldub [ %g3 + 0x2f ], %g1
400139a4: fa 08 e0 0d ldub [ %g3 + 0xd ], %i5
400139a8: f4 08 e0 10 ldub [ %g3 + 0x10 ], %i2
400139ac: e2 08 e0 13 ldub [ %g3 + 0x13 ], %l1
400139b0: e4 08 e0 14 ldub [ %g3 + 0x14 ], %l2
400139b4: ee 08 e0 16 ldub [ %g3 + 0x16 ], %l7
400139b8: f0 08 e0 17 ldub [ %g3 + 0x17 ], %i0
400139bc: e0 08 e0 21 ldub [ %g3 + 0x21 ], %l0
400139c0: e8 08 e0 24 ldub [ %g3 + 0x24 ], %l4
400139c4: ec 08 e0 25 ldub [ %g3 + 0x25 ], %l6
400139c8: ea 08 e0 26 ldub [ %g3 + 0x26 ], %l5
400139cc: e6 08 e0 27 ldub [ %g3 + 0x27 ], %l3
400139d0: f8 08 e0 28 ldub [ %g3 + 0x28 ], %i4
400139d4: c2 2f bf 97 stb %g1, [ %fp + -105 ]
400139d8: c2 08 e0 30 ldub [ %g3 + 0x30 ], %g1
400139dc: f2 08 e0 31 ldub [ %g3 + 0x31 ], %i1
400139e0: c2 2f bf 9f stb %g1, [ %fp + -97 ]
sc = rtems_bdbuf_release( block);
400139e4: c4 27 bf 80 st %g2, [ %fp + -128 ]
400139e8: c8 27 bf 7c st %g4, [ %fp + -132 ]
400139ec: d2 27 bf 78 st %o1, [ %fp + -136 ]
400139f0: d6 27 bf 74 st %o3, [ %fp + -140 ]
400139f4: 7f ff f6 e8 call 40011594 <rtems_bdbuf_release>
400139f8: d8 3f bf 68 std %o4, [ %fp + -152 ]
if (sc != RTEMS_SUCCESSFUL)
400139fc: c4 07 bf 80 ld [ %fp + -128 ], %g2
40013a00: 80 a2 20 00 cmp %o0, 0
40013a04: c8 07 bf 7c ld [ %fp + -132 ], %g4
40013a08: d2 07 bf 78 ld [ %fp + -136 ], %o1
40013a0c: d6 07 bf 74 ld [ %fp + -140 ], %o3
40013a10: 02 80 00 08 be 40013a30 <fat_init_volume_info+0x180> <== ALWAYS TAKEN
40013a14: d8 1f bf 68 ldd [ %fp + -152 ], %o4
{
close(vol->fd);
40013a18: 7f ff c8 2f call 40005ad4 <close> <== NOT EXECUTED
40013a1c: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
40013a20: 40 00 1f c9 call 4001b944 <__errno> <== NOT EXECUTED
40013a24: 01 00 00 00 nop <== NOT EXECUTED
40013a28: 10 80 01 71 b 40013fec <fat_init_volume_info+0x73c> <== NOT EXECUTED
40013a2c: 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);
40013a30: 84 08 a0 ff and %g2, 0xff, %g2
40013a34: 92 0a 60 ff and %o1, 0xff, %o1
40013a38: 93 2a 60 08 sll %o1, 8, %o1
40013a3c: 92 12 40 02 or %o1, %g2, %o1
40013a40: d2 36 c0 00 sth %o1, [ %i3 ]
if ( (vol->bps != 512) &&
40013a44: 85 2a 60 10 sll %o1, 0x10, %g2
40013a48: 85 30 a0 10 srl %g2, 0x10, %g2
40013a4c: 80 a0 a4 00 cmp %g2, 0x400
40013a50: 02 80 00 0c be 40013a80 <fat_init_volume_info+0x1d0> <== NEVER TAKEN
40013a54: 86 10 00 09 mov %o1, %g3
40013a58: 80 a0 a2 00 cmp %g2, 0x200
40013a5c: 22 80 00 0a be,a 40013a84 <fat_init_volume_info+0x1d4> <== ALWAYS TAKEN
40013a60: 85 2a 60 10 sll %o1, 0x10, %g2
(vol->bps != 1024) &&
40013a64: 80 a0 a8 00 cmp %g2, 0x800 <== NOT EXECUTED
40013a68: 02 80 00 06 be 40013a80 <fat_init_volume_info+0x1d0> <== NOT EXECUTED
40013a6c: 1f 00 00 04 sethi %hi(0x1000), %o7 <== NOT EXECUTED
(vol->bps != 2048) &&
40013a70: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
40013a74: 02 80 00 04 be 40013a84 <fat_init_volume_info+0x1d4> <== NOT EXECUTED
40013a78: 85 2a 60 10 sll %o1, 0x10, %g2 <== NOT EXECUTED
40013a7c: 30 80 00 d6 b,a 40013dd4 <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;
40013a80: 85 2a 60 10 sll %o1, 0x10, %g2 <== NOT EXECUTED
40013a84: c0 2e e0 03 clrb [ %i3 + 3 ]
40013a88: 10 80 00 05 b 40013a9c <fat_init_volume_info+0x1ec>
40013a8c: 85 30 a0 19 srl %g2, 0x19, %g2
i >>= 1, vol->sec_mul++);
40013a90: 85 38 a0 01 sra %g2, 1, %g2 <== NOT EXECUTED
40013a94: 9e 03 e0 01 inc %o7 <== NOT EXECUTED
40013a98: 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;
40013a9c: 80 88 a0 01 btst 1, %g2
40013aa0: 22 bf ff fc be,a 40013a90 <fat_init_volume_info+0x1e0> <== NEVER TAKEN
40013aa4: 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;
40013aa8: 93 2a 60 10 sll %o1, 0x10, %o1
40013aac: c0 2e e0 02 clrb [ %i3 + 2 ]
40013ab0: 93 32 60 10 srl %o1, 0x10, %o1
40013ab4: 10 80 00 05 b 40013ac8 <fat_init_volume_info+0x218>
40013ab8: 9e 10 00 09 mov %o1, %o7
i >>= 1, vol->sec_log2++);
40013abc: 84 00 a0 01 inc %g2
40013ac0: 9f 3b e0 01 sra %o7, 1, %o7
40013ac4: 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;
40013ac8: 80 8b e0 01 btst 1, %o7
40013acc: 02 bf ff fc be 40013abc <fat_init_volume_info+0x20c>
40013ad0: c4 0e e0 02 ldub [ %i3 + 2 ], %g2
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
40013ad4: c6 36 e0 0a sth %g3, [ %i3 + 0xa ]
vol->bytes_per_block_log2 = vol->sec_log2;
40013ad8: c4 2e e0 0c stb %g2, [ %i3 + 0xc ]
vol->sectors_per_block = 1;
40013adc: 86 10 20 01 mov 1, %g3
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
40013ae0: 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)
40013ae4: 9e 8f 60 ff andcc %i5, 0xff, %o7
40013ae8: 02 80 00 bb be 40013dd4 <fat_init_volume_info+0x524> <== NEVER TAKEN
40013aec: 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;
40013af0: 10 80 00 05 b 40013b04 <fat_init_volume_info+0x254>
40013af4: c0 2e e0 05 clrb [ %i3 + 5 ]
i >>= 1, vol->spc_log2++);
40013af8: 86 00 e0 01 inc %g3
40013afc: 9f 3b e0 01 sra %o7, 1, %o7
40013b00: 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;
40013b04: 80 8b e0 01 btst 1, %o7
40013b08: 02 bf ff fc be 40013af8 <fat_init_volume_info+0x248>
40013b0c: 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)
40013b10: 87 2a 40 03 sll %o1, %g3, %g3
40013b14: 95 28 e0 10 sll %g3, 0x10, %o2
40013b18: 1f 20 00 00 sethi %hi(0x80000000), %o7
40013b1c: 80 a2 80 0f cmp %o2, %o7
40013b20: 18 80 00 ad bgu 40013dd4 <fat_init_volume_info+0x524> <== NEVER TAKEN
40013b24: 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;
40013b28: 1f 00 00 3f sethi %hi(0xfc00), %o7
40013b2c: c0 2e e0 08 clrb [ %i3 + 8 ]
40013b30: 9e 13 e3 ff or %o7, 0x3ff, %o7
40013b34: 10 80 00 05 b 40013b48 <fat_init_volume_info+0x298>
40013b38: 86 08 c0 0f and %g3, %o7, %g3
i >>= 1, vol->bpc_log2++);
40013b3c: 87 38 e0 01 sra %g3, 1, %g3
40013b40: 9e 03 e0 01 inc %o7
40013b44: 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;
40013b48: 80 88 e0 01 btst 1, %g3
40013b4c: 22 bf ff fc be,a 40013b3c <fat_init_volume_info+0x28c>
40013b50: de 0e e0 08 ldub [ %i3 + 8 ], %o7
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
40013b54: 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)) /
40013b58: 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);
40013b5c: 96 0a e0 ff and %o3, 0xff, %o3
40013b60: 98 0b 20 ff and %o4, 0xff, %o4
40013b64: 97 2a e0 08 sll %o3, 8, %o3
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40013b68: 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);
40013b6c: 98 12 c0 0c or %o3, %o4, %o4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40013b70: 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);
40013b74: d8 36 e0 18 sth %o4, [ %i3 + 0x18 ]
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40013b78: 88 09 20 ff and %g4, 0xff, %g4
40013b7c: 88 13 40 04 or %o5, %g4, %g4
40013b80: 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)) /
40013b84: 89 29 20 10 sll %g4, 0x10, %g4
40013b88: c4 27 bf 80 st %g2, [ %fp + -128 ]
40013b8c: 91 31 20 0b srl %g4, 0xb, %o0
40013b90: d8 27 bf 68 st %o4, [ %fp + -152 ]
40013b94: 7f ff ba eb call 40002740 <.div>
40013b98: 90 02 00 03 add %o0, %g3, %o0
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
40013b9c: 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)) /
40013ba0: d0 26 e0 28 st %o0, [ %i3 + 0x28 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
40013ba4: 85 2a 00 02 sll %o0, %g2, %g2
40013ba8: c4 26 e0 2c st %g2, [ %i3 + 0x2c ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
40013bac: b0 0e 20 ff and %i0, 0xff, %i0
40013bb0: ae 0d e0 ff and %l7, 0xff, %l7
40013bb4: 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)) /
40013bb8: 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)
40013bbc: ae 16 00 17 or %i0, %l7, %l7
40013bc0: af 2d e0 10 sll %l7, 0x10, %l7
40013bc4: 80 a5 e0 00 cmp %l7, 0
40013bc8: 02 80 00 05 be 40013bdc <fat_init_volume_info+0x32c>
40013bcc: d8 07 bf 68 ld [ %fp + -152 ], %o4
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
40013bd0: af 35 e0 10 srl %l7, 0x10, %l7
40013bd4: 10 80 00 0c b 40013c04 <fat_init_volume_info+0x354>
40013bd8: ee 26 e0 1c st %l7, [ %i3 + 0x1c ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
40013bdc: ac 0d a0 ff and %l6, 0xff, %l6
40013be0: aa 0d 60 ff and %l5, 0xff, %l5
40013be4: ad 2d a0 08 sll %l6, 8, %l6
40013be8: ab 2d 60 10 sll %l5, 0x10, %l5
40013bec: a8 0d 20 ff and %l4, 0xff, %l4
40013bf0: aa 15 80 15 or %l6, %l5, %l5
40013bf4: a7 2c e0 18 sll %l3, 0x18, %l3
40013bf8: a8 15 40 14 or %l5, %l4, %l4
40013bfc: a6 15 00 13 or %l4, %l3, %l3
40013c00: e6 26 e0 1c st %l3, [ %i3 + 0x1c ]
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
40013c04: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
40013c08: 99 2b 20 10 sll %o4, 0x10, %o4
40013c0c: c6 27 bf 84 st %g3, [ %fp + -124 ]
40013c10: b1 33 20 10 srl %o4, 0x10, %i0
40013c14: 7f ff ba 8f call 40002650 <.umul>
40013c18: 90 0e a0 ff and %i2, 0xff, %o0
40013c1c: c6 07 bf 84 ld [ %fp + -124 ], %g3
40013c20: 90 06 00 08 add %i0, %o0, %o0
40013c24: 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;
40013c28: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
40013c2c: a4 0c a0 ff and %l2, 0xff, %l2
40013c30: a2 0c 60 ff and %l1, 0xff, %l1
40013c34: a5 2c a0 08 sll %l2, 8, %l2
40013c38: a2 14 80 11 or %l2, %l1, %l1
40013c3c: a3 2c 60 10 sll %l1, 0x10, %l1
40013c40: 80 a4 60 00 cmp %l1, 0
40013c44: 02 80 00 05 be 40013c58 <fat_init_volume_info+0x3a8>
40013c48: c6 26 e0 34 st %g3, [ %i3 + 0x34 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
40013c4c: a3 34 60 10 srl %l1, 0x10, %l1
40013c50: 10 80 00 0d b 40013c84 <fat_init_volume_info+0x3d4>
40013c54: e2 26 e0 30 st %l1, [ %i3 + 0x30 ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
40013c58: c8 0f bf 9a ldub [ %fp + -102 ], %g4
40013c5c: c4 0f bf 9b ldub [ %fp + -101 ], %g2
40013c60: c2 0f bf 8f ldub [ %fp + -113 ], %g1
40013c64: a0 0c 20 ff and %l0, 0xff, %l0
40013c68: 85 28 a0 10 sll %g2, 0x10, %g2
40013c6c: a1 2c 20 08 sll %l0, 8, %l0
40013c70: 84 14 00 02 or %l0, %g2, %g2
40013c74: 84 10 80 04 or %g2, %g4, %g2
40013c78: 89 28 60 18 sll %g1, 0x18, %g4
40013c7c: 84 10 80 04 or %g2, %g4, %g2
40013c80: c4 26 e0 30 st %g2, [ %i3 + 0x30 ]
data_secs = vol->tot_secs - vol->data_fsec;
40013c84: d0 06 e0 30 ld [ %i3 + 0x30 ], %o0
vol->data_cls = data_secs / vol->spc;
40013c88: 92 0f 60 ff and %i5, 0xff, %o1
40013c8c: 7f ff ba ab call 40002738 <.udiv>
40013c90: 90 22 00 03 sub %o0, %g3, %o0
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
40013c94: 80 a2 2f f4 cmp %o0, 0xff4
40013c98: 18 80 00 08 bgu 40013cb8 <fat_init_volume_info+0x408>
40013c9c: d0 26 e0 38 st %o0, [ %i3 + 0x38 ]
{
vol->type = FAT_FAT12;
40013ca0: 84 10 20 01 mov 1, %g2
40013ca4: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
vol->mask = FAT_FAT12_MASK;
40013ca8: 84 10 2f ff mov 0xfff, %g2
40013cac: c4 26 e0 10 st %g2, [ %i3 + 0x10 ]
vol->eoc_val = FAT_FAT12_EOC;
40013cb0: 10 80 00 0f b 40013cec <fat_init_volume_info+0x43c>
40013cb4: 84 10 2f f8 mov 0xff8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
40013cb8: 05 00 00 3f sethi %hi(0xfc00), %g2
40013cbc: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4>
40013cc0: 80 a2 00 03 cmp %o0, %g3
40013cc4: 38 80 00 05 bgu,a 40013cd8 <fat_init_volume_info+0x428>
40013cc8: 84 10 20 04 mov 4, %g2
{
vol->type = FAT_FAT16;
40013ccc: 86 10 20 02 mov 2, %g3
40013cd0: 10 80 00 04 b 40013ce0 <fat_init_volume_info+0x430>
40013cd4: c6 2e e0 0e stb %g3, [ %i3 + 0xe ]
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
40013cd8: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
vol->mask = FAT_FAT32_MASK;
40013cdc: 05 03 ff ff sethi %hi(0xffffc00), %g2
40013ce0: 86 10 a3 ff or %g2, 0x3ff, %g3 ! fffffff <RAM_SIZE+0xfbfffff>
vol->eoc_val = FAT_FAT32_EOC;
40013ce4: 84 10 a3 f8 or %g2, 0x3f8, %g2
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
40013ce8: c6 26 e0 10 st %g3, [ %i3 + 0x10 ]
vol->eoc_val = FAT_FAT32_EOC;
40013cec: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
}
}
if (vol->type == FAT_FAT32)
40013cf0: c4 0e e0 0e ldub [ %i3 + 0xe ], %g2
40013cf4: 80 a0 a0 04 cmp %g2, 4
40013cf8: 12 80 00 63 bne 40013e84 <fat_init_volume_info+0x5d4>
40013cfc: 82 10 3f ff mov -1, %g1
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013d00: c6 0f bf 9d ldub [ %fp + -99 ], %g3
40013d04: c4 0f bf 9c ldub [ %fp + -100 ], %g2
40013d08: 87 28 e0 08 sll %g3, 8, %g3
40013d0c: 85 28 a0 10 sll %g2, 0x10, %g2
40013d10: c2 0f bf 97 ldub [ %fp + -105 ], %g1
40013d14: 84 10 c0 02 or %g3, %g2, %g2
40013d18: c6 0f bf 9e ldub [ %fp + -98 ], %g3
40013d1c: 84 10 80 03 or %g2, %g3, %g2
40013d20: 87 28 60 18 sll %g1, 0x18, %g3
40013d24: 84 10 80 03 or %g2, %g3, %g2
40013d28: c4 26 e0 3c st %g2, [ %i3 + 0x3c ]
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40013d2c: 84 0f 3f 80 and %i4, -128, %g2
if (vol->mirror)
40013d30: 80 88 a0 80 btst 0x80, %g2
40013d34: 02 80 00 05 be 40013d48 <fat_init_volume_info+0x498> <== ALWAYS TAKEN
40013d38: c4 2e e0 54 stb %g2, [ %i3 + 0x54 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
40013d3c: b8 0f 20 0f and %i4, 0xf, %i4 <== NOT EXECUTED
40013d40: 10 80 00 03 b 40013d4c <fat_init_volume_info+0x49c> <== NOT EXECUTED
40013d44: f8 2e e0 5c stb %i4, [ %i3 + 0x5c ] <== NOT EXECUTED
else
vol->afat = 0;
40013d48: c0 2e e0 5c clrb [ %i3 + 0x5c ]
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
40013d4c: f4 0f bf 9f ldub [ %fp + -97 ], %i2
40013d50: b2 0e 60 ff and %i1, 0xff, %i1
40013d54: b3 2e 60 08 sll %i1, 8, %i1
40013d58: b4 16 40 1a or %i1, %i2, %i2
40013d5c: f4 36 e0 40 sth %i2, [ %i3 + 0x40 ]
if( vol->info_sec == 0 )
40013d60: b5 2e a0 10 sll %i2, 0x10, %i2
40013d64: 93 36 a0 10 srl %i2, 0x10, %o1
40013d68: 80 a2 60 00 cmp %o1, 0
40013d6c: 32 80 00 03 bne,a 40013d78 <fat_init_volume_info+0x4c8> <== ALWAYS TAKEN
40013d70: 90 10 00 1b mov %i3, %o0
40013d74: 30 80 00 18 b,a 40013dd4 <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,
40013d78: 94 10 20 00 clr %o2
40013d7c: 96 10 20 04 mov 4, %o3
40013d80: 7f ff fd f3 call 4001354c <_fat_block_read>
40013d84: 98 07 bf a8 add %fp, -88, %o4
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
40013d88: 80 a2 20 00 cmp %o0, 0
40013d8c: 06 80 00 22 bl 40013e14 <fat_init_volume_info+0x564> <== NEVER TAKEN
40013d90: c4 0f bf aa ldub [ %fp + -86 ], %g2
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
40013d94: c6 0f bf a9 ldub [ %fp + -87 ], %g3
40013d98: 85 28 a0 10 sll %g2, 0x10, %g2
40013d9c: 87 28 e0 08 sll %g3, 8, %g3
40013da0: 86 10 c0 02 or %g3, %g2, %g3
40013da4: c4 0f bf a8 ldub [ %fp + -88 ], %g2
40013da8: 86 10 c0 02 or %g3, %g2, %g3
40013dac: c4 0f bf ab ldub [ %fp + -85 ], %g2
40013db0: 85 28 a0 18 sll %g2, 0x18, %g2
40013db4: 86 10 c0 02 or %g3, %g2, %g3
40013db8: 05 10 58 54 sethi %hi(0x41615000), %g2
40013dbc: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x1215252>
40013dc0: 80 a0 c0 02 cmp %g3, %g2
40013dc4: 02 80 00 0a be 40013dec <fat_init_volume_info+0x53c> <== ALWAYS TAKEN
40013dc8: 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);
40013dcc: 7f ff fd 3d call 400132c0 <fat_buf_release> <== NOT EXECUTED
40013dd0: 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);
40013dd4: 7f ff c7 40 call 40005ad4 <close> <== NOT EXECUTED
40013dd8: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40013ddc: 40 00 1e da call 4001b944 <__errno> <== NOT EXECUTED
40013de0: 01 00 00 00 nop <== NOT EXECUTED
40013de4: 10 80 00 82 b 40013fec <fat_init_volume_info+0x73c> <== NOT EXECUTED
40013de8: 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,
40013dec: d2 16 e0 40 lduh [ %i3 + 0x40 ], %o1
40013df0: 94 10 21 e4 mov 0x1e4, %o2
40013df4: 96 10 20 0c mov 0xc, %o3
40013df8: 7f ff fd d5 call 4001354c <_fat_block_read>
40013dfc: 98 07 bf a8 add %fp, -88, %o4
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
40013e00: 80 a2 20 00 cmp %o0, 0
40013e04: 16 80 00 08 bge 40013e24 <fat_init_volume_info+0x574> <== ALWAYS TAKEN
40013e08: 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);
40013e0c: 7f ff fd 2d call 400132c0 <fat_buf_release> <== NOT EXECUTED
40013e10: 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);
40013e14: 7f ff c7 30 call 40005ad4 <close> <== NOT EXECUTED
40013e18: 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 );
40013e1c: 81 c7 e0 08 ret <== NOT EXECUTED
40013e20: 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);
40013e24: c4 0f bf ae ldub [ %fp + -82 ], %g2
40013e28: 87 28 e0 08 sll %g3, 8, %g3
40013e2c: 85 28 a0 10 sll %g2, 0x10, %g2
40013e30: 84 10 c0 02 or %g3, %g2, %g2
40013e34: c6 0f bf ac ldub [ %fp + -84 ], %g3
40013e38: 84 10 80 03 or %g2, %g3, %g2
40013e3c: c6 0f bf af ldub [ %fp + -81 ], %g3
40013e40: 87 28 e0 18 sll %g3, 0x18, %g3
40013e44: 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);
40013e48: c6 0f bf b1 ldub [ %fp + -79 ], %g3
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
40013e4c: 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;
40013e50: c4 26 e0 44 st %g2, [ %i3 + 0x44 ]
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40013e54: c4 0f bf b2 ldub [ %fp + -78 ], %g2
40013e58: 87 28 e0 08 sll %g3, 8, %g3
40013e5c: 85 28 a0 10 sll %g2, 0x10, %g2
40013e60: 84 10 c0 02 or %g3, %g2, %g2
40013e64: c6 0f bf b0 ldub [ %fp + -80 ], %g3
40013e68: 84 10 80 03 or %g2, %g3, %g2
40013e6c: c6 0f bf b3 ldub [ %fp + -77 ], %g3
40013e70: 87 28 e0 18 sll %g3, 0x18, %g3
40013e74: 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 =
40013e78: 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;
40013e7c: 10 80 00 07 b 40013e98 <fat_init_volume_info+0x5e8>
40013e80: c4 26 e0 4c st %g2, [ %i3 + 0x4c ]
}
}
}
else
{
vol->rdir_cl = 0;
40013e84: c0 26 e0 3c clr [ %i3 + 0x3c ]
vol->mirror = 0;
40013e88: c0 2e e0 54 clrb [ %i3 + 0x54 ]
vol->afat = 0;
40013e8c: c0 2e e0 5c clrb [ %i3 + 0x5c ]
vol->free_cls = FAT_UNDEFINED_VALUE;
40013e90: c2 26 e0 44 st %g1, [ %i3 + 0x44 ]
vol->next_cl = FAT_UNDEFINED_VALUE;
40013e94: 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);
40013e98: 7f ff fd 0a call 400132c0 <fat_buf_release>
40013e9c: 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;
40013ea0: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
40013ea4: 7f ff b9 eb call 40002650 <.umul>
40013ea8: d0 0e e0 5c ldub [ %i3 + 0x5c ], %o0
40013eac: 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));
40013eb0: 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;
40013eb4: 90 02 00 02 add %o0, %g2, %o0
40013eb8: 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));
40013ebc: 7f ff c6 ef call 40005a78 <calloc>
40013ec0: 90 10 20 02 mov 2, %o0
if ( fs_info->vhash == NULL )
40013ec4: 80 a2 20 00 cmp %o0, 0
40013ec8: 02 80 00 12 be 40013f10 <fat_init_volume_info+0x660> <== NEVER TAKEN
40013ecc: 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 );
40013ed0: 84 02 20 04 add %o0, 4, %g2
40013ed4: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
40013ed8: 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 );
40013edc: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
40013ee0: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40013ee4: 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;
40013ee8: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
40013eec: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
40013ef0: 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));
40013ef4: 92 10 20 0c mov 0xc, %o1
40013ef8: 7f ff c6 e0 call 40005a78 <calloc>
40013efc: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
40013f00: 80 a2 20 00 cmp %o0, 0
40013f04: 12 80 00 06 bne 40013f1c <fat_init_volume_info+0x66c> <== ALWAYS TAKEN
40013f08: d0 26 e0 70 st %o0, [ %i3 + 0x70 ]
40013f0c: 30 80 00 1c b,a 40013f7c <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);
40013f10: 7f ff c6 f1 call 40005ad4 <close> <== NOT EXECUTED
40013f14: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
40013f18: 30 80 00 32 b,a 40013fe0 <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 );
40013f1c: 84 02 20 04 add %o0, 4, %g2
head->next = tail;
40013f20: 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 );
40013f24: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
40013f28: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40013f2c: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
40013f30: 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;
40013f34: 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 );
40013f38: 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;
40013f3c: 84 10 21 00 mov 0x100, %g2
head->next = tail;
40013f40: c6 22 20 0c st %g3, [ %o0 + 0xc ]
40013f44: c4 26 e0 7c st %g2, [ %i3 + 0x7c ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
40013f48: c6 06 e0 30 ld [ %i3 + 0x30 ], %g3
40013f4c: c4 0e e0 03 ldub [ %i3 + 3 ], %g2
fs_info->index = 0;
40013f50: 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;
40013f54: 85 28 c0 02 sll %g3, %g2, %g2
40013f58: 85 28 a0 04 sll %g2, 4, %g2
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
40013f5c: 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;
40013f60: c4 26 e0 80 st %g2, [ %i3 + 0x80 ]
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
40013f64: 7f ff c6 c5 call 40005a78 <calloc>
40013f68: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
40013f6c: 80 a2 20 00 cmp %o0, 0
40013f70: 12 80 00 0d bne 40013fa4 <fat_init_volume_info+0x6f4> <== ALWAYS TAKEN
40013f74: d0 26 e0 74 st %o0, [ %i3 + 0x74 ]
40013f78: 30 80 00 05 b,a 40013f8c <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);
40013f7c: 7f ff c6 d6 call 40005ad4 <close> <== NOT EXECUTED
40013f80: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40013f84: 10 80 00 15 b 40013fd8 <fat_init_volume_info+0x728> <== NOT EXECUTED
40013f88: 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);
40013f8c: 7f ff c6 d2 call 40005ad4 <close> <== NOT EXECUTED
40013f90: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40013f94: 7f ff c6 f1 call 40005b58 <free> <== NOT EXECUTED
40013f98: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40013f9c: 10 80 00 0f b 40013fd8 <fat_init_volume_info+0x728> <== NOT EXECUTED
40013fa0: 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));
40013fa4: d0 16 c0 00 lduh [ %i3 ], %o0
40013fa8: 7f ff c6 b4 call 40005a78 <calloc>
40013fac: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
40013fb0: 80 a2 20 00 cmp %o0, 0
40013fb4: 12 80 00 11 bne 40013ff8 <fat_init_volume_info+0x748> <== ALWAYS TAKEN
40013fb8: d0 26 e0 90 st %o0, [ %i3 + 0x90 ]
{
close(vol->fd);
40013fbc: 7f ff c6 c6 call 40005ad4 <close> <== NOT EXECUTED
40013fc0: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40013fc4: 7f ff c6 e5 call 40005b58 <free> <== NOT EXECUTED
40013fc8: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40013fcc: 7f ff c6 e3 call 40005b58 <free> <== NOT EXECUTED
40013fd0: d0 06 e0 70 ld [ %i3 + 0x70 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
40013fd4: d0 06 e0 74 ld [ %i3 + 0x74 ], %o0 <== NOT EXECUTED
40013fd8: 7f ff c6 e0 call 40005b58 <free> <== NOT EXECUTED
40013fdc: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40013fe0: 40 00 1e 59 call 4001b944 <__errno> <== NOT EXECUTED
40013fe4: 01 00 00 00 nop <== NOT EXECUTED
40013fe8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
40013fec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013ff0: 81 c7 e0 08 ret <== NOT EXECUTED
40013ff4: 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;
40013ff8: c4 0e e0 04 ldub [ %i3 + 4 ], %g2
40013ffc: c6 06 e0 34 ld [ %i3 + 0x34 ], %g3
40014000: 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)
40014004: 80 88 80 03 btst %g2, %g3
40014008: 22 80 00 04 be,a 40014018 <fat_init_volume_info+0x768> <== ALWAYS TAKEN
4001400c: 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;
40014010: 81 c7 e0 08 ret <== NOT EXECUTED
40014014: 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)))
40014018: 80 a0 e0 04 cmp %g3, 4
4001401c: 22 80 00 07 be,a 40014038 <fat_init_volume_info+0x788>
40014020: 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;
40014024: 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)))
40014028: 80 88 80 03 btst %g2, %g3
4001402c: 12 80 00 0f bne 40014068 <fat_init_volume_info+0x7b8> <== NEVER TAKEN
40014030: b0 10 20 00 clr %i0
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
40014034: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
40014038: d2 16 e0 06 lduh [ %i3 + 6 ], %o1
4001403c: 7f ff f6 78 call 40011a1c <rtems_bdbuf_set_block_size>
40014040: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
40014044: 80 a2 20 00 cmp %o0, 0
40014048: 12 80 00 08 bne 40014068 <fat_init_volume_info+0x7b8> <== NEVER TAKEN
4001404c: b0 10 20 00 clr %i0
{
vol->bytes_per_block = vol->bpc;
40014050: c4 16 e0 06 lduh [ %i3 + 6 ], %g2
40014054: c4 36 e0 0a sth %g2, [ %i3 + 0xa ]
vol->bytes_per_block_log2 = vol->bpc_log2;
40014058: c4 0e e0 08 ldub [ %i3 + 8 ], %g2
4001405c: c4 2e e0 0c stb %g2, [ %i3 + 0xc ]
vol->sectors_per_block = vol->spc;
40014060: c4 0e e0 04 ldub [ %i3 + 4 ], %g2
40014064: c4 2e e0 09 stb %g2, [ %i3 + 9 ]
}
}
return RC_OK;
}
40014068: 81 c7 e0 08 ret
4001406c: 81 e8 00 00 restore
40019e98 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
40019e98: 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;
40019e9c: e8 06 20 38 ld [ %i0 + 0x38 ], %l4
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
40019ea0: 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;
40019ea4: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
40019ea8: 80 a6 a0 00 cmp %i2, 0
40019eac: 02 80 00 7e be 4001a0a4 <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
40019eb0: a2 10 20 00 clr %l1
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
40019eb4: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
40019eb8: 80 a4 3f ff cmp %l0, -1
40019ebc: 22 80 00 02 be,a 40019ec4 <fat_scan_fat_for_free_clusters+0x2c>
40019ec0: 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;
40019ec4: a8 05 20 02 add %l4, 2, %l4
40019ec8: a6 10 20 02 mov 2, %l3
40019ecc: 10 80 00 5a b 4001a034 <fat_scan_fat_for_free_clusters+0x19c>
40019ed0: 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);
40019ed4: 92 10 00 10 mov %l0, %o1
40019ed8: 7f ff fe ae call 40019990 <fat_get_fat_cluster>
40019edc: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40019ee0: a2 92 20 00 orcc %o0, 0, %l1
40019ee4: 02 80 00 0b be 40019f10 <fat_scan_fat_for_free_clusters+0x78><== ALWAYS TAKEN
40019ee8: c2 07 bf fc ld [ %fp + -4 ], %g1
{
if (*cls_added != 0)
40019eec: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
40019ef0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40019ef4: 22 80 00 6d be,a 4001a0a8 <fat_scan_fat_for_free_clusters+0x210><== NOT EXECUTED
40019ef8: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
40019efc: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40019f00: 7f ff ff b7 call 40019ddc <fat_free_fat_clusters_chain> <== NOT EXECUTED
40019f04: 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;
}
40019f08: 81 c7 e0 08 ret <== NOT EXECUTED
40019f0c: 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)
40019f10: 80 a0 60 00 cmp %g1, 0
40019f14: 32 80 00 44 bne,a 4001a024 <fat_scan_fat_for_free_clusters+0x18c>
40019f18: 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)
40019f1c: c2 06 c0 00 ld [ %i3 ], %g1
40019f20: 80 a0 60 00 cmp %g1, 0
40019f24: 12 80 00 0e bne 40019f5c <fat_scan_fat_for_free_clusters+0xc4>
40019f28: 90 10 00 18 mov %i0, %o0
{
*chain = cl4find;
40019f2c: e0 26 40 00 st %l0, [ %i1 ]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
40019f30: 92 10 00 10 mov %l0, %o1
40019f34: 7f ff ff 09 call 40019b58 <fat_set_fat_cluster>
40019f38: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
40019f3c: 80 a2 20 00 cmp %o0, 0
40019f40: 32 80 00 59 bne,a 4001a0a4 <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
40019f44: 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)
40019f48: 80 a7 60 00 cmp %i5, 0
40019f4c: 22 80 00 18 be,a 40019fac <fat_scan_fat_for_free_clusters+0x114>
40019f50: c2 06 c0 00 ld [ %i3 ], %g1
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
40019f54: 10 80 00 1c b 40019fc4 <fat_scan_fat_for_free_clusters+0x12c>
40019f58: 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);
40019f5c: 92 10 00 10 mov %l0, %o1
40019f60: 7f ff fe fe call 40019b58 <fat_set_fat_cluster>
40019f64: 94 10 3f ff mov -1, %o2
40019f68: aa 10 00 08 mov %o0, %l5
if ( rc != RC_OK )
40019f6c: 80 a5 60 00 cmp %l5, 0
40019f70: 02 80 00 07 be 40019f8c <fat_scan_fat_for_free_clusters+0xf4><== ALWAYS TAKEN
40019f74: 90 10 00 18 mov %i0, %o0
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
40019f78: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40019f7c: 7f ff ff 98 call 40019ddc <fat_free_fat_clusters_chain> <== NOT EXECUTED
40019f80: 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;
}
40019f84: 81 c7 e0 08 ret <== NOT EXECUTED
40019f88: 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);
40019f8c: 92 10 00 12 mov %l2, %o1
40019f90: 7f ff fe f2 call 40019b58 <fat_set_fat_cluster>
40019f94: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
40019f98: a4 92 20 00 orcc %o0, 0, %l2
40019f9c: 02 bf ff ec be 40019f4c <fat_scan_fat_for_free_clusters+0xb4><== ALWAYS TAKEN
40019fa0: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
40019fa4: 10 80 00 35 b 4001a078 <fat_scan_fat_for_free_clusters+0x1e0><== NOT EXECUTED
40019fa8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
40019fac: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
40019fb0: 80 a0 40 1a cmp %g1, %i2
40019fb4: 02 80 00 0f be 40019ff0 <fat_scan_fat_for_free_clusters+0x158>
40019fb8: c2 26 c0 00 st %g1, [ %i3 ]
40019fbc: 10 80 00 19 b 4001a020 <fat_scan_fat_for_free_clusters+0x188>
40019fc0: 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);
40019fc4: 90 10 00 18 mov %i0, %o0
40019fc8: 92 10 00 10 mov %l0, %o1
40019fcc: 94 10 20 00 clr %o2
40019fd0: 7f ff e5 a5 call 40013664 <fat_cluster_set>
40019fd4: 98 10 20 00 clr %o4
if (fs_info->vol.bpc != bytes_written)
40019fd8: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40019fdc: 80 a0 40 08 cmp %g1, %o0
40019fe0: 22 bf ff f3 be,a 40019fac <fat_scan_fat_for_free_clusters+0x114><== ALWAYS TAKEN
40019fe4: c2 06 c0 00 ld [ %i3 ], %g1
{
rc = -1;
40019fe8: 10 80 00 23 b 4001a074 <fat_scan_fat_for_free_clusters+0x1dc><== NOT EXECUTED
40019fec: 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)
40019ff0: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
40019ff4: 80 a0 7f ff cmp %g1, -1
40019ff8: 02 80 00 05 be 4001a00c <fat_scan_fat_for_free_clusters+0x174><== ALWAYS TAKEN
40019ffc: e0 26 20 4c st %l0, [ %i0 + 0x4c ]
fs_info->vol.free_cls -= (*cls_added);
4001a000: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4001a004: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4001a008: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
4001a00c: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
4001a010: 7f ff e4 ac call 400132c0 <fat_buf_release>
4001a014: 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;
}
4001a018: 81 c7 e0 08 ret
4001a01c: 91 e8 00 11 restore %g0, %l1, %o0
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
4001a020: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
4001a024: 80 a4 00 14 cmp %l0, %l4
4001a028: 0a 80 00 03 bcs 4001a034 <fat_scan_fat_for_free_clusters+0x19c><== ALWAYS TAKEN
4001a02c: a6 04 e0 01 inc %l3
cl4find = 2;
4001a030: 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)
4001a034: 80 a4 c0 14 cmp %l3, %l4
4001a038: 0a bf ff a7 bcs 40019ed4 <fat_scan_fat_for_free_clusters+0x3c><== ALWAYS TAKEN
4001a03c: 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)
4001a040: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
4001a044: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4001a048: 02 80 00 05 be 4001a05c <fat_scan_fat_for_free_clusters+0x1c4><== NOT EXECUTED
4001a04c: e4 26 20 4c st %l2, [ %i0 + 0x4c ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
4001a050: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4001a054: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4001a058: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
4001a05c: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001a060: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a064: 7f ff e4 97 call 400132c0 <fat_buf_release> <== NOT EXECUTED
4001a068: 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;
}
4001a06c: 81 c7 e0 08 ret <== NOT EXECUTED
4001a070: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
4001a074: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001a078: 7f ff ff 59 call 40019ddc <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001a07c: 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);
4001a080: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001a084: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001a088: 7f ff fe b4 call 40019b58 <fat_set_fat_cluster> <== NOT EXECUTED
4001a08c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
4001a090: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a094: 7f ff e4 8b call 400132c0 <fat_buf_release> <== NOT EXECUTED
4001a098: a2 10 00 12 mov %l2, %l1 <== NOT EXECUTED
return rc;
}
4001a09c: 81 c7 e0 08 ret <== NOT EXECUTED
4001a0a0: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
4001a0a4: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
4001a0a8: 81 c7 e0 08 ret <== NOT EXECUTED
4001a0ac: 81 e8 00 00 restore <== NOT EXECUTED
400135cc <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
400135cc: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t cmpltd = 0;
400135d0: 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)
400135d4: 10 80 00 1b b 40013640 <fat_sector_write+0x74>
400135d8: a2 10 20 01 mov 1, %l1
{
c = MIN(count, (fs_info->vol.bps - ofs));
400135dc: ba 27 40 1a sub %i5, %i2, %i5
400135e0: 80 a7 40 1b cmp %i5, %i3
400135e4: 38 80 00 02 bgu,a 400135ec <fat_sector_write+0x20>
400135e8: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
400135ec: c2 16 20 0a lduh [ %i0 + 0xa ], %g1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
400135f0: 90 10 00 18 mov %i0, %o0
400135f4: 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)
400135f8: 80 a7 40 01 cmp %i5, %g1
400135fc: 02 80 00 03 be 40013608 <fat_sector_write+0x3c> <== NEVER TAKEN
40013600: 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);
40013604: 94 10 20 01 mov 1, %o2
40013608: 7f ff ff a2 call 40013490 <fat_buf_access>
4001360c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40013610: 80 a2 20 00 cmp %o0, 0
40013614: 12 80 00 10 bne 40013654 <fat_sector_write+0x88> <== NEVER TAKEN
40013618: d0 07 bf fc ld [ %fp + -4 ], %o0
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4001361c: 92 07 00 10 add %i4, %l0, %o1
40013620: 90 02 00 1a add %o0, %i2, %o0
40013624: 94 10 00 1d mov %i5, %o2
40013628: 40 00 23 6c call 4001c3d8 <memcpy>
4001362c: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
40013630: 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;
40013634: e2 2e 20 88 stb %l1, [ %i0 + 0x88 ]
sec_num++;
40013638: b2 06 60 01 inc %i1
ofs = 0;
4001363c: 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)
40013640: 80 a6 e0 00 cmp %i3, 0
40013644: 32 bf ff e6 bne,a 400135dc <fat_sector_write+0x10>
40013648: fa 16 00 00 lduh [ %i0 ], %i5
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
4001364c: 81 c7 e0 08 ret
40013650: 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;
40013654: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
40013658: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
4001365c: 81 c7 e0 08 ret <== NOT EXECUTED
40013660: 81 e8 00 00 restore <== NOT EXECUTED
40019b58 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
40019b58: 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;
40019b5c: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
40019b60: 80 a6 60 01 cmp %i1, 1
40019b64: 08 80 00 98 bleu 40019dc4 <fat_set_fat_cluster+0x26c> <== NEVER TAKEN
40019b68: ba 10 00 18 mov %i0, %i5
40019b6c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
40019b70: 82 00 60 01 inc %g1
40019b74: 80 a6 40 01 cmp %i1, %g1
40019b78: 28 80 00 03 bleu,a 40019b84 <fat_set_fat_cluster+0x2c> <== ALWAYS TAKEN
40019b7c: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
40019b80: 30 80 00 91 b,a 40019dc4 <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) +
40019b84: 84 08 60 01 and %g1, 1, %g2
40019b88: 80 88 a0 ff btst 0xff, %g2
40019b8c: 02 80 00 05 be 40019ba0 <fat_set_fat_cluster+0x48>
40019b90: 86 08 60 02 and %g1, 2, %g3
40019b94: a1 36 60 01 srl %i1, 1, %l0
40019b98: 10 80 00 06 b 40019bb0 <fat_set_fat_cluster+0x58>
40019b9c: a0 04 00 19 add %l0, %i1, %l0
40019ba0: 80 88 e0 ff btst 0xff, %g3
40019ba4: 02 80 00 03 be 40019bb0 <fat_set_fat_cluster+0x58>
40019ba8: a1 2e 60 02 sll %i1, 2, %l0
40019bac: a1 2e 60 01 sll %i1, 1, %l0
40019bb0: 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);
40019bb4: 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) +
40019bb8: a1 34 00 03 srl %l0, %g3, %l0
40019bbc: 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);
40019bc0: 02 80 00 05 be 40019bd4 <fat_set_fat_cluster+0x7c>
40019bc4: a0 04 00 03 add %l0, %g3, %l0
40019bc8: b7 36 60 01 srl %i1, 1, %i3
40019bcc: 10 80 00 07 b 40019be8 <fat_set_fat_cluster+0x90>
40019bd0: b6 06 c0 19 add %i3, %i1, %i3
40019bd4: 82 08 60 02 and %g1, 2, %g1
40019bd8: 80 88 60 ff btst 0xff, %g1
40019bdc: 02 80 00 03 be 40019be8 <fat_set_fat_cluster+0x90>
40019be0: b7 2e 60 02 sll %i1, 2, %i3
40019be4: b7 2e 60 01 sll %i1, 1, %i3
40019be8: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
40019bec: 90 10 00 1d mov %i5, %o0
40019bf0: 92 10 00 10 mov %l0, %o1
40019bf4: 94 10 20 01 mov 1, %o2
40019bf8: 7f ff e6 26 call 40013490 <fat_buf_access>
40019bfc: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40019c00: b0 92 20 00 orcc %o0, 0, %i0
40019c04: 12 80 00 4c bne 40019d34 <fat_set_fat_cluster+0x1dc> <== NEVER TAKEN
40019c08: 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);
40019c0c: b9 37 20 10 srl %i4, 0x10, %i4
40019c10: b8 07 3f ff add %i4, -1, %i4
40019c14: 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 )
40019c18: f6 0f 60 0e ldub [ %i5 + 0xe ], %i3
40019c1c: 80 a6 e0 02 cmp %i3, 2
40019c20: 02 80 00 53 be 40019d6c <fat_set_fat_cluster+0x214>
40019c24: 80 a6 e0 04 cmp %i3, 4
40019c28: 02 80 00 5b be 40019d94 <fat_set_fat_cluster+0x23c>
40019c2c: 80 a6 e0 01 cmp %i3, 1
40019c30: 12 80 00 65 bne 40019dc4 <fat_set_fat_cluster+0x26c> <== NEVER TAKEN
40019c34: 80 8e 60 01 btst 1, %i1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
40019c38: 02 80 00 23 be 40019cc4 <fat_set_fat_cluster+0x16c>
40019c3c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
40019c40: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
40019c44: 84 08 a0 0f and %g2, 0xf, %g2
40019c48: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
40019c4c: c2 07 bf fc ld [ %fp + -4 ], %g1
40019c50: 85 2e a0 04 sll %i2, 4, %g2
40019c54: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
40019c58: 84 10 c0 02 or %g3, %g2, %g2
40019c5c: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
40019c60: c2 17 40 00 lduh [ %i5 ], %g1
40019c64: 82 00 7f ff add %g1, -1, %g1
40019c68: 80 a7 00 01 cmp %i4, %g1
40019c6c: 12 80 00 0f bne 40019ca8 <fat_set_fat_cluster+0x150> <== ALWAYS TAKEN
40019c70: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
40019c74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019c78: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
40019c7c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40019c80: 7f ff e6 04 call 40013490 <fat_buf_access> <== NOT EXECUTED
40019c84: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
40019c88: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40019c8c: 12 80 00 2a bne 40019d34 <fat_set_fat_cluster+0x1dc> <== NOT EXECUTED
40019c90: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40019c94: 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;
40019c98: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40019c9c: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
40019ca0: 10 80 00 21 b 40019d24 <fat_set_fat_cluster+0x1cc> <== NOT EXECUTED
40019ca4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
40019ca8: c2 07 bf fc ld [ %fp + -4 ], %g1
40019cac: b8 07 20 01 inc %i4
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
40019cb0: b5 2e a0 14 sll %i2, 0x14, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
40019cb4: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
40019cb8: b5 36 a0 18 srl %i2, 0x18, %i2
40019cbc: 10 80 00 27 b 40019d58 <fat_set_fat_cluster+0x200>
40019cc0: c2 07 bf fc ld [ %fp + -4 ], %g1
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*(sec_buf + ofs) &= 0x00;
40019cc4: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
40019cc8: 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;
40019ccc: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) &= 0x00;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
40019cd0: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
40019cd4: 84 10 80 1a or %g2, %i2, %g2
40019cd8: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
40019cdc: c2 17 40 00 lduh [ %i5 ], %g1
40019ce0: 82 00 7f ff add %g1, -1, %g1
40019ce4: 80 a7 00 01 cmp %i4, %g1
40019ce8: 12 80 00 15 bne 40019d3c <fat_set_fat_cluster+0x1e4> <== ALWAYS TAKEN
40019cec: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
40019cf0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019cf4: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
40019cf8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40019cfc: 7f ff e5 e5 call 40013490 <fat_buf_access> <== NOT EXECUTED
40019d00: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
40019d04: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40019d08: 12 80 00 0b bne 40019d34 <fat_set_fat_cluster+0x1dc> <== NOT EXECUTED
40019d0c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40019d10: 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;
40019d14: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
40019d18: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
40019d1c: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40019d20: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
40019d24: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
40019d28: b4 16 80 02 or %i2, %g2, %i2 <== NOT EXECUTED
40019d2c: 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;
40019d30: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
40019d34: 81 c7 e0 08 ret <== NOT EXECUTED
40019d38: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
40019d3c: c2 07 bf fc ld [ %fp + -4 ], %g1
40019d40: b8 07 20 01 inc %i4
40019d44: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40019d48: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
40019d4c: 84 08 bf f0 and %g2, -16, %g2
40019d50: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
40019d54: c2 07 bf fc ld [ %fp + -4 ], %g1
40019d58: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
40019d5c: b4 10 80 1a or %g2, %i2, %i2
40019d60: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
40019d64: 81 c7 e0 08 ret
40019d68: 81 e8 00 00 restore
break;
}
return RC_OK;
}
40019d6c: 03 00 00 3f sethi %hi(0xfc00), %g1
40019d70: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40019d74: 82 0e 80 01 and %i2, %g1, %g1
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
40019d78: 83 28 60 08 sll %g1, 8, %g1
40019d7c: b5 2e a0 10 sll %i2, 0x10, %i2
40019d80: b5 36 a0 18 srl %i2, 0x18, %i2
40019d84: b4 10 40 1a or %g1, %i2, %i2
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
40019d88: c2 07 bf fc ld [ %fp + -4 ], %g1
40019d8c: 10 80 00 0a b 40019db4 <fat_set_fat_cluster+0x25c>
40019d90: 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));
40019d94: 11 3c 00 00 sethi %hi(0xf0000000), %o0
40019d98: 7f ff fe f2 call 40019960 <CPU_swap_u32>
40019d9c: 90 2e 80 08 andn %i2, %o0, %o0
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
40019da0: c2 07 bf fc ld [ %fp + -4 ], %g1
40019da4: c4 00 40 1c ld [ %g1 + %i4 ], %g2
40019da8: 84 08 a0 f0 and %g2, 0xf0, %g2
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
40019dac: 90 12 00 02 or %o0, %g2, %o0
40019db0: d0 20 40 1c st %o0, [ %g1 + %i4 ]
40019db4: 82 10 20 01 mov 1, %g1
40019db8: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
40019dbc: 81 c7 e0 08 ret
40019dc0: 81 e8 00 00 restore
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
40019dc4: 40 00 06 e0 call 4001b944 <__errno> <== NOT EXECUTED
40019dc8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40019dcc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40019dd0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
40019dd4: 81 c7 e0 08 ret <== NOT EXECUTED
40019dd8: 81 e8 00 00 restore <== NOT EXECUTED
40014140 <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)
{
40014140: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
40014144: 90 10 00 18 mov %i0, %o0
40014148: 7f ff ff ca call 40014070 <fat_sync>
4001414c: ba 10 00 18 mov %i0, %i5
if ( rc != RC_OK )
40014150: b0 92 20 00 orcc %o0, 0, %i0
40014154: 32 80 00 02 bne,a 4001415c <fat_shutdown_drive+0x1c> <== NEVER TAKEN
40014158: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
4001415c: 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;
40014160: f6 07 60 6c ld [ %i5 + 0x6c ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
40014164: 10 80 00 04 b 40014174 <fat_shutdown_drive+0x34>
40014168: b6 06 c0 1c add %i3, %i4, %i3
free(node);
4001416c: 7f ff c6 7b call 40005b58 <free>
40014170: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
40014174: 7f ff da 5e call 4000aaec <_Chain_Get>
40014178: 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 )
4001417c: 80 a2 20 00 cmp %o0, 0
40014180: 12 bf ff fb bne 4001416c <fat_shutdown_drive+0x2c>
40014184: 01 00 00 00 nop
40014188: 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++)
4001418c: 80 a7 20 18 cmp %i4, 0x18
40014190: 32 bf ff f5 bne,a 40014164 <fat_shutdown_drive+0x24>
40014194: f6 07 60 6c ld [ %i5 + 0x6c ], %i3
40014198: 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;
4001419c: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
400141a0: 10 80 00 04 b 400141b0 <fat_shutdown_drive+0x70>
400141a4: b6 06 c0 1c add %i3, %i4, %i3
free(node);
400141a8: 7f ff c6 6c call 40005b58 <free> <== NOT EXECUTED
400141ac: 01 00 00 00 nop <== NOT EXECUTED
400141b0: 7f ff da 4f call 4000aaec <_Chain_Get>
400141b4: 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 )
400141b8: 80 a2 20 00 cmp %o0, 0
400141bc: 12 bf ff fb bne 400141a8 <fat_shutdown_drive+0x68> <== NEVER TAKEN
400141c0: 01 00 00 00 nop
400141c4: 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++)
400141c8: 80 a7 20 18 cmp %i4, 0x18
400141cc: 32 bf ff f5 bne,a 400141a0 <fat_shutdown_drive+0x60>
400141d0: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
400141d4: 7f ff c6 61 call 40005b58 <free>
400141d8: d0 07 60 6c ld [ %i5 + 0x6c ], %o0
free(fs_info->rhash);
400141dc: 7f ff c6 5f call 40005b58 <free>
400141e0: d0 07 60 70 ld [ %i5 + 0x70 ], %o0
free(fs_info->uino);
400141e4: 7f ff c6 5d call 40005b58 <free>
400141e8: d0 07 60 74 ld [ %i5 + 0x74 ], %o0
free(fs_info->sec_buf);
400141ec: 7f ff c6 5b call 40005b58 <free>
400141f0: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
close(fs_info->vol.fd);
400141f4: 7f ff c6 38 call 40005ad4 <close>
400141f8: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
if (rc)
400141fc: 80 a6 20 00 cmp %i0, 0
40014200: 02 80 00 06 be 40014218 <fat_shutdown_drive+0xd8> <== ALWAYS TAKEN
40014204: 01 00 00 00 nop
errno = EIO;
40014208: 40 00 1d cf call 4001b944 <__errno> <== NOT EXECUTED
4001420c: 01 00 00 00 nop <== NOT EXECUTED
40014210: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40014214: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
40014218: 81 c7 e0 08 ret
4001421c: 81 e8 00 00 restore
40014070 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
40014070: 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)
40014074: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
40014078: 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;
4001407c: 90 10 20 00 clr %o0
if (fs_info->vol.type == FAT_FAT32)
40014080: 80 a0 a0 04 cmp %g2, 4
40014084: 12 80 00 20 bne 40014104 <fat_sync+0x94>
40014088: b4 10 20 00 clr %i2
{
uint32_t free_count = fs_info->vol.free_cls;
4001408c: 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)
40014090: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
40014094: 80 a6 c0 01 cmp %i3, %g1
40014098: 02 80 00 0d be 400140cc <fat_sync+0x5c> <== ALWAYS TAKEN
4001409c: f8 06 20 4c ld [ %i0 + 0x4c ], %i4
{
uint32_t le_free_count = CT_LE_L(free_count);
400140a0: 7f ff fc 65 call 40013234 <CPU_swap_u32> <== NOT EXECUTED
400140a4: 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,
400140a8: 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);
400140ac: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
400140b0: f6 26 20 48 st %i3, [ %i0 + 0x48 ] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
400140b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400140b8: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
400140bc: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
400140c0: 7f ff fd 43 call 400135cc <fat_sector_write> <== NOT EXECUTED
400140c4: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
400140c8: 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)
400140cc: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
400140d0: 80 a7 00 02 cmp %i4, %g2
400140d4: 02 80 00 0c be 40014104 <fat_sync+0x94> <== NEVER TAKEN
400140d8: 90 10 20 00 clr %o0
{
uint32_t le_next_free = CT_LE_L(next_free);
400140dc: 7f ff fc 56 call 40013234 <CPU_swap_u32>
400140e0: 90 10 00 1c mov %i4, %o0
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
400140e4: 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);
400140e8: d0 27 bf fc st %o0, [ %fp + -4 ]
fs_info->vol.next_cl_in_fs_info = next_free;
400140ec: f8 27 60 50 st %i4, [ %i5 + 0x50 ]
ret2 = fat_sector_write(fs_info,
400140f0: 90 10 00 1d mov %i5, %o0
400140f4: 94 10 21 ec mov 0x1ec, %o2
400140f8: 96 10 20 04 mov 4, %o3
400140fc: 7f ff fd 34 call 400135cc <fat_sector_write>
40014100: 98 07 bf fc add %fp, -4, %o4
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
40014104: 80 a2 20 00 cmp %o0, 0
40014108: 06 80 00 04 bl 40014118 <fat_sync+0xa8> <== NEVER TAKEN
4001410c: 80 a6 a0 00 cmp %i2, 0
40014110: 16 80 00 03 bge 4001411c <fat_sync+0xac> <== ALWAYS TAKEN
40014114: b0 10 20 00 clr %i0
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
40014118: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fat_buf_release(fs_info);
4001411c: 7f ff fc 69 call 400132c0 <fat_buf_release>
40014120: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
40014124: 7f ff f5 bb call 40011810 <rtems_bdbuf_syncdev>
40014128: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
4001412c: 80 a2 20 00 cmp %o0, 0
40014130: 32 80 00 02 bne,a 40014138 <fat_sync+0xc8> <== NEVER TAKEN
40014134: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
return rc;
}
40014138: 81 c7 e0 08 ret
4001413c: 81 e8 00 00 restore
40032efc <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
40032efc: 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 );
40032f00: 03 10 01 7f sethi %hi(0x4005fc00), %g1 <== NOT EXECUTED
40032f04: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 4005ffc0 <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;
40032f08: c0 27 bf c4 clr [ %fp + -60 ] <== NOT EXECUTED
st.st_uid = 0;
40032f0c: c0 37 bf ca clrh [ %fp + -54 ] <== NOT EXECUTED
st.st_gid = 0;
rtems_libio_check_fd( fd );
40032f10: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
40032f14: 1a 80 00 0c bcc 40032f44 <fchdir+0x48> <== NOT EXECUTED
40032f18: c0 37 bf cc clrh [ %fp + -52 ] <== NOT EXECUTED
iop = rtems_libio_iop( fd );
40032f1c: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
40032f20: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
40032f24: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED
40032f28: 03 10 01 90 sethi %hi(0x40064000), %g1 <== NOT EXECUTED
40032f2c: fa 00 62 a0 ld [ %g1 + 0x2a0 ], %i5 ! 400642a0 <rtems_libio_iops><== NOT EXECUTED
40032f30: ba 07 40 18 add %i5, %i0, %i5 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
40032f34: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
40032f38: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40032f3c: 32 80 00 08 bne,a 40032f5c <fchdir+0x60> <== NOT EXECUTED
40032f40: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
40032f44: 40 00 10 d5 call 40037298 <__errno> <== NOT EXECUTED
40032f48: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40032f4c: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
40032f50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40032f54: 81 c7 e0 08 ret <== NOT EXECUTED
40032f58: 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 );
40032f5c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40032f60: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40032f64: 9f c0 40 00 call %g1 <== NOT EXECUTED
40032f68: 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 );
40032f6c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40032f70: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40032f74: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
40032f78: 9f c0 40 00 call %g1 <== NOT EXECUTED
40032f7c: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if ( rv == 0 ) {
40032f80: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40032f84: 32 80 00 13 bne,a 40032fd0 <fchdir+0xd4> <== NOT EXECUTED
40032f88: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
bool access_ok = rtems_filesystem_check_access(
40032f8c: d2 07 bf c4 ld [ %fp + -60 ], %o1 <== NOT EXECUTED
40032f90: d4 17 bf ca lduh [ %fp + -54 ], %o2 <== NOT EXECUTED
40032f94: d6 17 bf cc lduh [ %fp + -52 ], %o3 <== NOT EXECUTED
40032f98: 7f ff 6e 0e call 4000e7d0 <rtems_filesystem_check_access> <== NOT EXECUTED
40032f9c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
40032fa0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40032fa4: 02 80 00 06 be 40032fbc <fchdir+0xc0> <== NOT EXECUTED
40032fa8: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
40032fac: 7f ff 6c 75 call 4000e180 <rtems_filesystem_location_clone><== NOT EXECUTED
40032fb0: 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;
40032fb4: 10 80 00 07 b 40032fd0 <fchdir+0xd4> <== NOT EXECUTED
40032fb8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
} else {
errno = EACCES;
40032fbc: 40 00 10 b7 call 40037298 <__errno> <== NOT EXECUTED
40032fc0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40032fc4: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
40032fc8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40032fcc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40032fd0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40032fd4: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
40032fd8: 9f c0 40 00 call %g1 <== NOT EXECUTED
40032fdc: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
40032fe0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40032fe4: 12 80 00 05 bne 40032ff8 <fchdir+0xfc> <== NOT EXECUTED
40032fe8: 01 00 00 00 nop <== NOT EXECUTED
rv = rtems_filesystem_chdir( &loc );
40032fec: 7f ff c3 1d call 40023c60 <rtems_filesystem_chdir> <== NOT EXECUTED
40032ff0: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
40032ff4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
return rv;
}
40032ff8: 81 c7 e0 08 ret <== NOT EXECUTED
40032ffc: 81 e8 00 00 restore <== NOT EXECUTED
40033000: 40 03 30 a8 call 400ff2a0 <__end+0x9a100> <== NOT EXECUTED
40033004: 40 03 31 84 call 400ff614 <__end+0x9a474> <== NOT EXECUTED
40033008: 40 03 31 90 call 400ff648 <__end+0x9a4a8> <== NOT EXECUTED
4003300c: 40 03 31 a8 call 400ff6ac <__end+0x9a50c> <== NOT EXECUTED
40033010: 40 03 31 b8 call 400ff6f0 <__end+0x9a550> <== NOT EXECUTED
40033014: 40 03 31 dc call 400ff784 <__end+0x9a5e4> <== NOT EXECUTED
40033018: 40 03 31 dc call 400ff788 <__end+0x9a5e8> <== NOT EXECUTED
4003301c: 40 03 31 dc call 400ff78c <__end+0x9a5ec> <== NOT EXECUTED
40033020: 40 03 31 dc call 400ff790 <__end+0x9a5f0> <== NOT EXECUTED
40033024: 40 03 31 dc call 400ff794 <__end+0x9a5f4> <== NOT EXECUTED
400241b8 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
400241b8: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
400241bc: 03 10 01 7f sethi %hi(0x4005fc00), %g1
400241c0: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 4005ffc0 <rtems_libio_number_iops>
400241c4: 80 a6 00 01 cmp %i0, %g1
400241c8: 2a 80 00 03 bcs,a 400241d4 <fchmod+0x1c>
400241cc: 83 2e 20 03 sll %i0, 3, %g1
400241d0: 30 80 00 0a b,a 400241f8 <fchmod+0x40>
iop = rtems_libio_iop( fd );
400241d4: b1 2e 20 06 sll %i0, 6, %i0
400241d8: b0 26 00 01 sub %i0, %g1, %i0
400241dc: 03 10 01 90 sethi %hi(0x40064000), %g1
400241e0: fa 00 62 a0 ld [ %g1 + 0x2a0 ], %i5 ! 400642a0 <rtems_libio_iops>
400241e4: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
400241e8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400241ec: 80 88 61 00 btst 0x100, %g1
400241f0: 32 80 00 06 bne,a 40024208 <fchmod+0x50>
400241f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
400241f8: 40 00 4c 28 call 40037298 <__errno>
400241fc: 01 00 00 00 nop
40024200: 10 80 00 1b b 4002426c <fchmod+0xb4>
40024204: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
40024208: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
4002420c: 80 a0 60 00 cmp %g1, 0
40024210: 02 80 00 14 be 40024260 <fchmod+0xa8> <== NEVER TAKEN
40024214: 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 );
40024218: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4002421c: c2 00 40 00 ld [ %g1 ], %g1
40024220: 9f c0 40 00 call %g1
40024224: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
40024228: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
4002422c: 90 07 60 14 add %i5, 0x14, %o0
40024230: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40024234: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40024238: 9f c0 40 00 call %g1
4002423c: 92 10 00 19 mov %i1, %o1
40024240: 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;
40024244: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40024248: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4002424c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40024250: 9f c0 40 00 call %g1
40024254: 01 00 00 00 nop
40024258: 81 c7 e0 08 ret
4002425c: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
40024260: 40 00 4c 0e call 40037298 <__errno> <== NOT EXECUTED
40024264: 01 00 00 00 nop <== NOT EXECUTED
40024268: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
4002426c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40024270: 81 c7 e0 08 ret
40024274: 91 e8 3f ff restore %g0, -1, %o0
40024278 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
40024278: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4002427c: 03 10 01 7f sethi %hi(0x4005fc00), %g1
40024280: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 4005ffc0 <rtems_libio_number_iops>
40024284: 80 a6 00 01 cmp %i0, %g1
40024288: 2a 80 00 03 bcs,a 40024294 <fchown+0x1c>
4002428c: 83 2e 20 03 sll %i0, 3, %g1
40024290: 30 80 00 0a b,a 400242b8 <fchown+0x40>
iop = rtems_libio_iop( fd );
40024294: b1 2e 20 06 sll %i0, 6, %i0
40024298: b0 26 00 01 sub %i0, %g1, %i0
4002429c: 03 10 01 90 sethi %hi(0x40064000), %g1
400242a0: fa 00 62 a0 ld [ %g1 + 0x2a0 ], %i5 ! 400642a0 <rtems_libio_iops>
400242a4: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
400242a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400242ac: 80 88 61 00 btst 0x100, %g1
400242b0: 32 80 00 06 bne,a 400242c8 <fchown+0x50>
400242b4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
400242b8: 40 00 4b f8 call 40037298 <__errno>
400242bc: 01 00 00 00 nop
400242c0: 10 80 00 1c b 40024330 <fchown+0xb8>
400242c4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
400242c8: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
400242cc: 80 a0 60 00 cmp %g1, 0
400242d0: 02 80 00 15 be 40024324 <fchown+0xac> <== NEVER TAKEN
400242d4: 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 );
400242d8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400242dc: c2 00 40 00 ld [ %g1 ], %g1
400242e0: 9f c0 40 00 call %g1
400242e4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
400242e8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400242ec: 90 07 60 14 add %i5, 0x14, %o0
400242f0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400242f4: 92 10 00 19 mov %i1, %o1
400242f8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
400242fc: 9f c0 40 00 call %g1
40024300: 94 10 00 1a mov %i2, %o2
40024304: 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;
40024308: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
4002430c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40024310: c2 00 60 04 ld [ %g1 + 4 ], %g1
40024314: 9f c0 40 00 call %g1
40024318: 01 00 00 00 nop
4002431c: 81 c7 e0 08 ret
40024320: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
40024324: 40 00 4b dd call 40037298 <__errno> <== NOT EXECUTED
40024328: 01 00 00 00 nop <== NOT EXECUTED
4002432c: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
40024330: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40024334: 81 c7 e0 08 ret
40024338: 91 e8 3f ff restore %g0, -1, %o0
400317b8 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
400317b8: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
400317bc: 05 10 00 de sethi %hi(0x40037800), %g2
400317c0: c4 00 a1 fc ld [ %g2 + 0x1fc ], %g2 ! 400379fc <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
400317c4: 82 07 a0 4c add %fp, 0x4c, %g1
400317c8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400317cc: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400317d0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
400317d4: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
400317d8: 80 a6 00 02 cmp %i0, %g2
400317dc: 1a 80 00 0c bcc 4003180c <fcntl+0x54>
400317e0: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
400317e4: 85 2e 20 03 sll %i0, 3, %g2
400317e8: b1 2e 20 06 sll %i0, 6, %i0
400317ec: b0 26 00 02 sub %i0, %g2, %i0
400317f0: 05 10 01 21 sethi %hi(0x40048400), %g2
400317f4: fa 00 a2 e4 ld [ %g2 + 0x2e4 ], %i5 ! 400486e4 <rtems_libio_iops>
400317f8: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
400317fc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
40031800: 80 8a 21 00 btst 0x100, %o0
40031804: 12 80 00 06 bne 4003181c <fcntl+0x64>
40031808: 80 a6 60 09 cmp %i1, 9
4003180c: 7f ff be 6c call 400211bc <__errno>
40031810: 01 00 00 00 nop
40031814: 10 80 00 5d b 40031988 <fcntl+0x1d0>
40031818: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
4003181c: 18 80 00 58 bgu 4003197c <fcntl+0x1c4>
40031820: 85 2e 60 02 sll %i1, 2, %g2
40031824: 07 10 00 c5 sethi %hi(0x40031400), %g3
40031828: 86 10 e3 90 or %g3, 0x390, %g3 ! 40031790 <_calloc_r+0x14>
4003182c: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
40031830: 81 c0 80 00 jmp %g2
40031834: 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();
40031838: 7f ff 5c cd call 40008b6c <rtems_libio_allocate>
4003183c: 01 00 00 00 nop
if (diop != NULL) {
40031840: b8 92 20 00 orcc %o0, 0, %i4
40031844: 02 80 00 62 be 400319cc <fcntl+0x214>
40031848: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
4003184c: 7f ff 5c b2 call 40008b14 <rtems_libio_to_fcntl_flags>
40031850: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
40031854: 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;
40031858: b6 0a 3d ff and %o0, -513, %i3
diop->flags |= rtems_libio_fcntl_flags( oflag );
4003185c: 7f ff 5c a1 call 40008ae0 <rtems_libio_fcntl_flags>
40031860: 90 10 00 1b mov %i3, %o0
40031864: 90 12 00 1a or %o0, %i2, %o0
40031868: 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;
4003186c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40031870: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40031874: c2 00 40 00 ld [ %g1 ], %g1
40031878: 9f c0 40 00 call %g1
4003187c: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40031880: 92 07 60 14 add %i5, 0x14, %o1
40031884: 7f ff 96 15 call 400170d8 <rtems_filesystem_location_clone>
40031888: 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;
4003188c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40031890: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40031894: c2 00 60 04 ld [ %g1 + 4 ], %g1
40031898: 9f c0 40 00 call %g1
4003189c: 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 );
400318a0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
400318a4: 90 10 00 1c mov %i4, %o0
400318a8: c2 00 40 00 ld [ %g1 ], %g1
400318ac: 92 10 20 00 clr %o1
400318b0: 94 10 00 1b mov %i3, %o2
400318b4: 9f c0 40 00 call %g1
400318b8: 96 10 20 00 clr %o3
if ( rv == 0 ) {
400318bc: b0 92 20 00 orcc %o0, 0, %i0
400318c0: 12 80 00 11 bne 40031904 <fcntl+0x14c> <== NEVER TAKEN
400318c4: 03 10 01 21 sethi %hi(0x40048400), %g1
rv = diop - rtems_libio_iops;
400318c8: f0 00 62 e4 ld [ %g1 + 0x2e4 ], %i0 ! 400486e4 <rtems_libio_iops>
400318cc: b8 27 00 18 sub %i4, %i0, %i4
400318d0: b9 3f 20 03 sra %i4, 3, %i4
400318d4: 85 2f 20 03 sll %i4, 3, %g2
400318d8: 83 2f 20 06 sll %i4, 6, %g1
400318dc: 82 00 80 01 add %g2, %g1, %g1
400318e0: 85 28 60 06 sll %g1, 6, %g2
400318e4: 82 00 40 02 add %g1, %g2, %g1
400318e8: 82 00 40 1c add %g1, %i4, %g1
400318ec: b1 28 60 0f sll %g1, 0xf, %i0
400318f0: 82 00 40 18 add %g1, %i0, %g1
400318f4: 83 28 60 03 sll %g1, 3, %g1
400318f8: b8 00 40 1c add %g1, %i4, %i4
400318fc: 10 80 00 25 b 40031990 <fcntl+0x1d8>
40031900: b0 20 00 1c neg %i4, %i0
} else {
rtems_libio_free( diop );
40031904: 7f ff 5c b1 call 40008bc8 <rtems_libio_free> <== NOT EXECUTED
40031908: 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) {
4003190c: 10 80 00 22 b 40031994 <fcntl+0x1dc> <== NOT EXECUTED
40031910: 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);
40031914: b1 32 20 0b srl %o0, 0xb, %i0
40031918: 10 80 00 21 b 4003199c <fcntl+0x1e4>
4003191c: 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 ) )
40031920: c2 00 40 00 ld [ %g1 ], %g1
40031924: 80 a0 60 00 cmp %g1, 0
40031928: 22 80 00 0e be,a 40031960 <fcntl+0x1a8>
4003192c: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
40031930: 10 80 00 0c b 40031960 <fcntl+0x1a8>
40031934: 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 );
40031938: 7f ff 5c 77 call 40008b14 <rtems_libio_to_fcntl_flags>
4003193c: 01 00 00 00 nop
40031940: 10 80 00 14 b 40031990 <fcntl+0x1d8>
40031944: b0 10 00 08 mov %o0, %i0
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
40031948: 7f ff 5c 66 call 40008ae0 <rtems_libio_fcntl_flags>
4003194c: 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);
40031950: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40031954: 90 0a 22 01 and %o0, 0x201, %o0
40031958: 82 08 7d fe and %g1, -514, %g1
4003195c: 90 12 00 01 or %o0, %g1, %o0
40031960: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
40031964: 10 80 00 0e b 4003199c <fcntl+0x1e4>
40031968: b0 10 20 00 clr %i0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
4003196c: 7f ff be 14 call 400211bc <__errno>
40031970: 01 00 00 00 nop
40031974: 10 80 00 05 b 40031988 <fcntl+0x1d0>
40031978: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
ret = -1;
break;
default:
errno = EINVAL;
4003197c: 7f ff be 10 call 400211bc <__errno>
40031980: 01 00 00 00 nop
40031984: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40031988: 10 80 00 10 b 400319c8 <fcntl+0x210>
4003198c: 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) {
40031990: 80 a6 20 00 cmp %i0, 0
40031994: 06 80 00 0e bl 400319cc <fcntl+0x214> <== NEVER TAKEN
40031998: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
4003199c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
400319a0: 90 10 00 1d mov %i5, %o0
400319a4: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
400319a8: 9f c0 40 00 call %g1
400319ac: 92 10 00 19 mov %i1, %o1
if (err) {
400319b0: ba 92 20 00 orcc %o0, 0, %i5
400319b4: 02 80 00 06 be 400319cc <fcntl+0x214> <== ALWAYS TAKEN
400319b8: 01 00 00 00 nop
errno = err;
400319bc: 7f ff be 00 call 400211bc <__errno> <== NOT EXECUTED
400319c0: 01 00 00 00 nop <== NOT EXECUTED
400319c4: 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);
400319c8: b0 10 3f ff mov -1, %i0
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
400319cc: 81 c7 e0 08 ret
400319d0: 81 e8 00 00 restore
4000498c <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
4000498c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40004990: 03 10 00 5c sethi %hi(0x40017000), %g1
40004994: c2 00 62 64 ld [ %g1 + 0x264 ], %g1 ! 40017264 <rtems_libio_number_iops>
40004998: 80 a6 00 01 cmp %i0, %g1
4000499c: 1a 80 00 0d bcc 400049d0 <fdatasync+0x44>
400049a0: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
400049a4: b1 2e 20 06 sll %i0, 6, %i0
400049a8: b0 26 00 01 sub %i0, %g1, %i0
400049ac: 03 10 00 5f sethi %hi(0x40017c00), %g1
400049b0: d0 00 61 c0 ld [ %g1 + 0x1c0 ], %o0 ! 40017dc0 <rtems_libio_iops>
400049b4: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open(iop);
400049b8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400049bc: 80 88 61 00 btst 0x100, %g1
400049c0: 02 80 00 04 be 400049d0 <fdatasync+0x44> <== NEVER TAKEN
400049c4: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
400049c8: 32 80 00 08 bne,a 400049e8 <fdatasync+0x5c>
400049cc: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
400049d0: 40 00 2f 3f call 400106cc <__errno>
400049d4: b0 10 3f ff mov -1, %i0
400049d8: 82 10 20 09 mov 9, %g1
400049dc: c2 22 00 00 st %g1, [ %o0 ]
400049e0: 81 c7 e0 08 ret
400049e4: 81 e8 00 00 restore
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
400049e8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
400049ec: 9f c0 40 00 call %g1
400049f0: 01 00 00 00 nop
}
400049f4: 81 c7 e0 08 ret
400049f8: 91 e8 00 08 restore %g0, %o0, %o0
4000e0a8 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000e0a8: 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) {
4000e0ac: 3b 10 00 8e sethi %hi(0x40023800), %i5
4000e0b0: c2 07 62 d0 ld [ %i5 + 0x2d0 ], %g1 ! 40023ad0 <pipe_semaphore>
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000e0b4: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4000e0b8: 80 a0 60 00 cmp %g1, 0
4000e0bc: 02 80 00 0c be 4000e0ec <fifo_open+0x44>
4000e0c0: b8 17 62 d0 or %i5, 0x2d0, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000e0c4: 03 10 00 8e sethi %hi(0x40023800), %g1
4000e0c8: d0 00 62 d0 ld [ %g1 + 0x2d0 ], %o0 ! 40023ad0 <pipe_semaphore>
4000e0cc: 92 10 20 00 clr %o1
4000e0d0: 7f ff ed 2a call 40009578 <rtems_semaphore_obtain>
4000e0d4: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
4000e0d8: 80 a2 20 00 cmp %o0, 0
4000e0dc: 22 80 01 00 be,a 4000e4dc <fifo_open+0x434> <== ALWAYS TAKEN
4000e0e0: fa 06 c0 00 ld [ %i3 ], %i5
return 0;
} else {
return -ENOMEM;
4000e0e4: 81 c7 e0 08 ret <== NOT EXECUTED
4000e0e8: 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 );
4000e0ec: 03 10 00 8f sethi %hi(0x40023c00), %g1
4000e0f0: d0 00 61 bc ld [ %g1 + 0x1bc ], %o0 ! 40023dbc <rtems_libio_semaphore>
4000e0f4: 92 10 20 00 clr %o1
4000e0f8: 7f ff ed 20 call 40009578 <rtems_semaphore_obtain>
4000e0fc: 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) {
4000e100: c2 07 62 d0 ld [ %i5 + 0x2d0 ], %g1
4000e104: 80 a0 60 00 cmp %g1, 0
4000e108: 12 80 00 0a bne 4000e130 <fifo_open+0x88> <== NEVER TAKEN
4000e10c: ba 10 20 00 clr %i5
sc = rtems_semaphore_create(
4000e110: 11 14 12 54 sethi %hi(0x50495000), %o0
4000e114: 92 10 20 01 mov 1, %o1
4000e118: 90 12 20 45 or %o0, 0x45, %o0
4000e11c: 94 10 20 54 mov 0x54, %o2
4000e120: 96 10 20 00 clr %o3
4000e124: 7f ff ec 78 call 40009304 <rtems_semaphore_create>
4000e128: 98 10 00 1c mov %i4, %o4
4000e12c: ba 10 00 08 mov %o0, %i5
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000e130: 03 10 00 8f sethi %hi(0x40023c00), %g1
4000e134: 7f ff ed 5a call 4000969c <rtems_semaphore_release>
4000e138: d0 00 61 bc ld [ %g1 + 0x1bc ], %o0 ! 40023dbc <rtems_libio_semaphore>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4000e13c: 80 a7 60 00 cmp %i5, 0
4000e140: 02 bf ff e1 be 4000e0c4 <fifo_open+0x1c>
4000e144: b0 10 3f f4 mov -12, %i0
4000e148: 81 c7 e0 08 ret
4000e14c: 81 e8 00 00 restore
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4000e150: 7f ff dc cf call 4000548c <malloc>
4000e154: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
4000e158: ba 92 20 00 orcc %o0, 0, %i5
4000e15c: 02 80 00 e4 be 4000e4ec <fifo_open+0x444> <== NEVER TAKEN
4000e160: 92 10 20 00 clr %o1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4000e164: 40 00 12 05 call 40012978 <memset>
4000e168: 94 10 20 34 mov 0x34, %o2
pipe->Size = PIPE_BUF;
4000e16c: 82 10 22 00 mov 0x200, %g1
pipe->Buffer = malloc(pipe->Size);
4000e170: 90 10 22 00 mov 0x200, %o0
4000e174: 7f ff dc c6 call 4000548c <malloc>
4000e178: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (! pipe->Buffer)
4000e17c: 80 a2 20 00 cmp %o0, 0
4000e180: 02 80 00 40 be 4000e280 <fifo_open+0x1d8> <== NEVER TAKEN
4000e184: d0 27 40 00 st %o0, [ %i5 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
4000e188: 39 10 00 8c sethi %hi(0x40023000), %i4
4000e18c: d0 4f 23 40 ldsb [ %i4 + 0x340 ], %o0 ! 40023340 <c.7174>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4000e190: 35 14 12 5c sethi %hi(0x50497000), %i2
4000e194: 82 16 a2 00 or %i2, 0x200, %g1 ! 50497200 <RAM_END+0x10097200>
4000e198: 92 10 20 00 clr %o1
4000e19c: 90 12 00 01 or %o0, %g1, %o0
4000e1a0: 94 10 20 00 clr %o2
4000e1a4: 40 00 05 eb call 4000f950 <rtems_barrier_create>
4000e1a8: 96 07 60 2c add %i5, 0x2c, %o3
4000e1ac: 80 a2 20 00 cmp %o0, 0
4000e1b0: 12 80 00 32 bne 4000e278 <fifo_open+0x1d0>
4000e1b4: d0 4f 23 40 ldsb [ %i4 + 0x340 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4000e1b8: 03 14 12 5d sethi %hi(0x50497400), %g1
4000e1bc: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000e1c0: 92 10 20 00 clr %o1
4000e1c4: 90 12 00 01 or %o0, %g1, %o0
4000e1c8: 94 10 20 00 clr %o2
4000e1cc: 40 00 05 e1 call 4000f950 <rtems_barrier_create>
4000e1d0: 96 07 60 30 add %i5, 0x30, %o3
4000e1d4: 80 a2 20 00 cmp %o0, 0
4000e1d8: 12 80 00 26 bne 4000e270 <fifo_open+0x1c8>
4000e1dc: d0 4f 23 40 ldsb [ %i4 + 0x340 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4000e1e0: b4 16 a3 00 or %i2, 0x300, %i2
4000e1e4: 92 10 20 01 mov 1, %o1
4000e1e8: 90 12 00 1a or %o0, %i2, %o0
4000e1ec: 94 10 20 10 mov 0x10, %o2
4000e1f0: 96 10 20 00 clr %o3
4000e1f4: 7f ff ec 44 call 40009304 <rtems_semaphore_create>
4000e1f8: 98 07 60 28 add %i5, 0x28, %o4
4000e1fc: 80 a2 20 00 cmp %o0, 0
4000e200: 12 80 00 1a bne 4000e268 <fifo_open+0x1c0>
4000e204: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
4000e208: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
4000e20c: 31 10 00 92 sethi %hi(0x40024800), %i0
4000e210: 7f ff f3 6d call 4000afc4 <_Objects_Get>
4000e214: 90 16 20 50 or %i0, 0x50, %o0 ! 40024850 <_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;
4000e218: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000e21c: 35 04 00 00 sethi %hi(0x10000000), %i2
4000e220: 82 10 40 1a or %g1, %i2, %g1
_Thread_Enable_dispatch();
4000e224: 7f ff f6 e9 call 4000bdc8 <_Thread_Enable_dispatch>
4000e228: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
4000e22c: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000e230: 94 07 bf fc add %fp, -4, %o2
4000e234: 7f ff f3 64 call 4000afc4 <_Objects_Get>
4000e238: 90 16 20 50 or %i0, 0x50, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4000e23c: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000e240: b4 10 40 1a or %g1, %i2, %i2
_Thread_Enable_dispatch();
4000e244: 7f ff f6 e1 call 4000bdc8 <_Thread_Enable_dispatch>
4000e248: f4 22 20 4c st %i2, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4000e24c: c2 0f 23 40 ldub [ %i4 + 0x340 ], %g1
4000e250: c4 4f 23 40 ldsb [ %i4 + 0x340 ], %g2
4000e254: 80 a0 a0 7a cmp %g2, 0x7a
4000e258: 12 80 00 a7 bne 4000e4f4 <fifo_open+0x44c>
4000e25c: 82 00 60 01 inc %g1
c = 'a';
4000e260: 10 80 00 a5 b 4000e4f4 <fifo_open+0x44c>
4000e264: 82 10 20 61 mov 0x61, %g1
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4000e268: 40 00 05 e9 call 4000fa0c <rtems_barrier_delete>
4000e26c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
4000e270: 40 00 05 e7 call 4000fa0c <rtems_barrier_delete>
4000e274: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
4000e278: 7f ff db 71 call 4000503c <free>
4000e27c: d0 07 40 00 ld [ %i5 ], %o0
err_buf:
free(pipe);
4000e280: 7f ff db 6f call 4000503c <free>
4000e284: 90 10 00 1d mov %i5, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000e288: 10 80 00 13 b 4000e2d4 <fifo_open+0x22c>
4000e28c: b0 10 3f f4 mov -12, %i0
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4000e290: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e294: 92 10 20 00 clr %o1
4000e298: 7f ff ec b8 call 40009578 <rtems_semaphore_obtain>
4000e29c: 94 10 20 00 clr %o2
err = -EINTR;
if (*pipep == NULL) {
4000e2a0: c2 06 c0 00 ld [ %i3 ], %g1
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4000e2a4: 80 a0 00 08 cmp %g0, %o0
4000e2a8: b0 60 20 00 subx %g0, 0, %i0
err = -EINTR;
if (*pipep == NULL) {
4000e2ac: 80 a0 60 00 cmp %g1, 0
4000e2b0: 12 80 00 09 bne 4000e2d4 <fifo_open+0x22c>
4000e2b4: b0 0e 3f fc and %i0, -4, %i0
if (err)
4000e2b8: 80 a6 20 00 cmp %i0, 0
4000e2bc: 22 80 00 06 be,a 4000e2d4 <fifo_open+0x22c> <== ALWAYS TAKEN
4000e2c0: fa 26 c0 00 st %i5, [ %i3 ]
pipe_free(pipe);
4000e2c4: 7f ff ff 41 call 4000dfc8 <pipe_free> <== NOT EXECUTED
4000e2c8: 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);
4000e2cc: 10 80 00 03 b 4000e2d8 <fifo_open+0x230> <== NOT EXECUTED
4000e2d0: 03 10 00 8e sethi %hi(0x40023800), %g1 <== NOT EXECUTED
4000e2d4: 03 10 00 8e sethi %hi(0x40023800), %g1
4000e2d8: 7f ff ec f1 call 4000969c <rtems_semaphore_release>
4000e2dc: d0 00 62 d0 ld [ %g1 + 0x2d0 ], %o0 ! 40023ad0 <pipe_semaphore>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
4000e2e0: 80 a6 20 00 cmp %i0, 0
4000e2e4: 12 80 00 86 bne 4000e4fc <fifo_open+0x454>
4000e2e8: 01 00 00 00 nop
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4000e2ec: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000e2f0: 82 08 60 06 and %g1, 6, %g1
4000e2f4: 80 a0 60 04 cmp %g1, 4
4000e2f8: 02 80 00 2e be 4000e3b0 <fifo_open+0x308>
4000e2fc: fa 06 c0 00 ld [ %i3 ], %i5
4000e300: 80 a0 60 06 cmp %g1, 6
4000e304: 02 80 00 56 be 4000e45c <fifo_open+0x3b4>
4000e308: 80 a0 60 02 cmp %g1, 2
4000e30c: 12 80 00 6a bne 4000e4b4 <fifo_open+0x40c> <== NEVER TAKEN
4000e310: 01 00 00 00 nop
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4000e314: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000e318: 82 00 60 01 inc %g1
4000e31c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000e320: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e324: 84 00 60 01 add %g1, 1, %g2
4000e328: 80 a0 60 00 cmp %g1, 0
4000e32c: 12 80 00 05 bne 4000e340 <fifo_open+0x298> <== NEVER TAKEN
4000e330: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
4000e334: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000e338: 40 00 05 de call 4000fab0 <rtems_barrier_release>
4000e33c: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
4000e340: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000e344: 80 a0 60 00 cmp %g1, 0
4000e348: 12 80 00 5b bne 4000e4b4 <fifo_open+0x40c>
4000e34c: 01 00 00 00 nop
/* Not an error */
if (LIBIO_NODELAY(iop))
4000e350: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000e354: 80 88 60 01 btst 1, %g1
4000e358: 12 80 00 57 bne 4000e4b4 <fifo_open+0x40c>
4000e35c: 01 00 00 00 nop
break;
prevCounter = pipe->writerCounter;
4000e360: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4000e364: 7f ff ec ce call 4000969c <rtems_semaphore_release>
4000e368: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
4000e36c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e370: 40 00 05 e6 call 4000fb08 <rtems_barrier_wait>
4000e374: 92 10 20 00 clr %o1
4000e378: 80 a2 20 00 cmp %o0, 0
4000e37c: 12 80 00 52 bne 4000e4c4 <fifo_open+0x41c> <== NEVER TAKEN
4000e380: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
4000e384: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e388: 7f ff ec 7c call 40009578 <rtems_semaphore_obtain>
4000e38c: 94 10 20 00 clr %o2
4000e390: 80 a2 20 00 cmp %o0, 0
4000e394: 32 80 00 4d bne,a 4000e4c8 <fifo_open+0x420> <== NEVER TAKEN
4000e398: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
4000e39c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000e3a0: 80 a7 00 01 cmp %i4, %g1
4000e3a4: 02 bf ff f0 be 4000e364 <fifo_open+0x2bc> <== NEVER TAKEN
4000e3a8: 01 00 00 00 nop
4000e3ac: 30 80 00 42 b,a 4000e4b4 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4000e3b0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000e3b4: 82 00 60 01 inc %g1
4000e3b8: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000e3bc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000e3c0: 84 00 60 01 add %g1, 1, %g2
4000e3c4: 80 a0 60 00 cmp %g1, 0
4000e3c8: 12 80 00 05 bne 4000e3dc <fifo_open+0x334> <== NEVER TAKEN
4000e3cc: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
4000e3d0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e3d4: 40 00 05 b7 call 4000fab0 <rtems_barrier_release>
4000e3d8: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000e3dc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e3e0: 80 a0 60 00 cmp %g1, 0
4000e3e4: 12 80 00 34 bne 4000e4b4 <fifo_open+0x40c>
4000e3e8: 01 00 00 00 nop
4000e3ec: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000e3f0: 80 88 60 01 btst 1, %g1
4000e3f4: 22 80 00 07 be,a 4000e410 <fifo_open+0x368>
4000e3f8: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
PIPE_UNLOCK(pipe);
4000e3fc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e400: 7f ff ec a7 call 4000969c <rtems_semaphore_release>
4000e404: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
4000e408: 10 80 00 31 b 4000e4cc <fifo_open+0x424>
4000e40c: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4000e410: 7f ff ec a3 call 4000969c <rtems_semaphore_release>
4000e414: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
4000e418: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000e41c: 40 00 05 bb call 4000fb08 <rtems_barrier_wait>
4000e420: 92 10 20 00 clr %o1
4000e424: 80 a2 20 00 cmp %o0, 0
4000e428: 12 80 00 27 bne 4000e4c4 <fifo_open+0x41c> <== NEVER TAKEN
4000e42c: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
4000e430: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e434: 7f ff ec 51 call 40009578 <rtems_semaphore_obtain>
4000e438: 94 10 20 00 clr %o2
4000e43c: 80 a2 20 00 cmp %o0, 0
4000e440: 32 80 00 22 bne,a 4000e4c8 <fifo_open+0x420> <== NEVER TAKEN
4000e444: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
4000e448: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000e44c: 80 a7 00 01 cmp %i4, %g1
4000e450: 02 bf ff f0 be 4000e410 <fifo_open+0x368> <== NEVER TAKEN
4000e454: 01 00 00 00 nop
4000e458: 30 80 00 17 b,a 4000e4b4 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4000e45c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000e460: 82 00 60 01 inc %g1
4000e464: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000e468: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e46c: 84 00 60 01 add %g1, 1, %g2
4000e470: 80 a0 60 00 cmp %g1, 0
4000e474: 12 80 00 05 bne 4000e488 <fifo_open+0x3e0> <== NEVER TAKEN
4000e478: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
4000e47c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000e480: 40 00 05 8c call 4000fab0 <rtems_barrier_release>
4000e484: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
4000e488: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000e48c: 82 00 60 01 inc %g1
4000e490: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000e494: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000e498: 84 00 60 01 add %g1, 1, %g2
4000e49c: 80 a0 60 00 cmp %g1, 0
4000e4a0: 12 80 00 05 bne 4000e4b4 <fifo_open+0x40c> <== NEVER TAKEN
4000e4a4: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
4000e4a8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e4ac: 40 00 05 81 call 4000fab0 <rtems_barrier_release>
4000e4b0: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
4000e4b4: 7f ff ec 7a call 4000969c <rtems_semaphore_release>
4000e4b8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
return 0;
4000e4bc: 81 c7 e0 08 ret
4000e4c0: 81 e8 00 00 restore
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
4000e4c4: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4000e4c8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000e4cc: 7f ff fe ca call 4000dff4 <pipe_release>
4000e4d0: 92 10 00 19 mov %i1, %o1
return err;
4000e4d4: 81 c7 e0 08 ret
4000e4d8: 81 e8 00 00 restore
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
if (pipe == NULL) {
4000e4dc: 80 a7 60 00 cmp %i5, 0
4000e4e0: 32 bf ff 6d bne,a 4000e294 <fifo_open+0x1ec>
4000e4e4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e4e8: 30 bf ff 1a b,a 4000e150 <fifo_open+0xa8>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000e4ec: 10 bf ff 7a b 4000e2d4 <fifo_open+0x22c> <== NOT EXECUTED
4000e4f0: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4000e4f4: 10 bf ff 67 b 4000e290 <fifo_open+0x1e8>
4000e4f8: c2 2f 23 40 stb %g1, [ %i4 + 0x340 ]
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
4000e4fc: 81 c7 e0 08 ret
4000e500: 81 e8 00 00 restore
4000a2a8 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
4000a2a8: 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);
4000a2ac: 03 10 00 4a sethi %hi(0x40012800), %g1
4000a2b0: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40012b78 <rtems_libio_number_iops>
4000a2b4: 80 a6 00 01 cmp %i0, %g1
4000a2b8: 2a 80 00 03 bcs,a 4000a2c4 <fpathconf+0x1c>
4000a2bc: 83 2e 20 03 sll %i0, 3, %g1
4000a2c0: 30 80 00 0a b,a 4000a2e8 <fpathconf+0x40>
iop = rtems_libio_iop(fd);
4000a2c4: b1 2e 20 06 sll %i0, 6, %i0
4000a2c8: b0 26 00 01 sub %i0, %g1, %i0
4000a2cc: 03 10 00 4d sethi %hi(0x40013400), %g1
4000a2d0: c2 00 61 44 ld [ %g1 + 0x144 ], %g1 ! 40013544 <rtems_libio_iops>
4000a2d4: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_is_open(iop);
4000a2d8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000a2dc: 80 88 61 00 btst 0x100, %g1
4000a2e0: 32 80 00 06 bne,a 4000a2f8 <fpathconf+0x50> <== ALWAYS TAKEN
4000a2e4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000a2e8: 40 00 08 d4 call 4000c638 <__errno>
4000a2ec: 01 00 00 00 nop
4000a2f0: 10 80 00 32 b 4000a3b8 <fpathconf+0x110>
4000a2f4: 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 ) {
4000a2f8: 80 a6 60 0b cmp %i1, 0xb
4000a2fc: 18 80 00 2c bgu 4000a3ac <fpathconf+0x104>
4000a300: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
4000a304: b3 2e 60 02 sll %i1, 2, %i1
4000a308: 05 10 00 28 sethi %hi(0x4000a000), %g2
4000a30c: 84 10 a2 78 or %g2, 0x278, %g2 ! 4000a278 <_close_r+0x10>
4000a310: c4 00 80 19 ld [ %g2 + %i1 ], %g2
4000a314: 81 c0 80 00 jmp %g2
4000a318: 01 00 00 00 nop
case _PC_LINK_MAX:
return_value = the_limits->link_max;
4000a31c: f0 00 40 00 ld [ %g1 ], %i0
break;
4000a320: 81 c7 e0 08 ret
4000a324: 81 e8 00 00 restore
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
4000a328: f0 00 60 04 ld [ %g1 + 4 ], %i0
break;
4000a32c: 81 c7 e0 08 ret
4000a330: 81 e8 00 00 restore
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
4000a334: f0 00 60 08 ld [ %g1 + 8 ], %i0
break;
4000a338: 81 c7 e0 08 ret
4000a33c: 81 e8 00 00 restore
case _PC_NAME_MAX:
return_value = the_limits->name_max;
4000a340: f0 00 60 0c ld [ %g1 + 0xc ], %i0
break;
4000a344: 81 c7 e0 08 ret
4000a348: 81 e8 00 00 restore
case _PC_PATH_MAX:
return_value = the_limits->path_max;
4000a34c: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
break;
4000a350: 81 c7 e0 08 ret
4000a354: 81 e8 00 00 restore
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
4000a358: f0 00 60 14 ld [ %g1 + 0x14 ], %i0
break;
4000a35c: 81 c7 e0 08 ret
4000a360: 81 e8 00 00 restore
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
4000a364: f0 00 60 1c ld [ %g1 + 0x1c ], %i0
break;
4000a368: 81 c7 e0 08 ret
4000a36c: 81 e8 00 00 restore
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
4000a370: f0 00 60 20 ld [ %g1 + 0x20 ], %i0
break;
4000a374: 81 c7 e0 08 ret
4000a378: 81 e8 00 00 restore
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
4000a37c: f0 00 60 2c ld [ %g1 + 0x2c ], %i0
break;
4000a380: 81 c7 e0 08 ret
4000a384: 81 e8 00 00 restore
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
4000a388: f0 00 60 18 ld [ %g1 + 0x18 ], %i0
break;
4000a38c: 81 c7 e0 08 ret
4000a390: 81 e8 00 00 restore
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
4000a394: f0 00 60 24 ld [ %g1 + 0x24 ], %i0
break;
4000a398: 81 c7 e0 08 ret
4000a39c: 81 e8 00 00 restore
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
4000a3a0: f0 00 60 28 ld [ %g1 + 0x28 ], %i0
break;
4000a3a4: 81 c7 e0 08 ret
4000a3a8: 81 e8 00 00 restore
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4000a3ac: 40 00 08 a3 call 4000c638 <__errno>
4000a3b0: 01 00 00 00 nop
4000a3b4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4000a3b8: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
4000a3bc: 81 c7 e0 08 ret
4000a3c0: 91 e8 3f ff restore %g0, -1, %o0
40004024 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004024: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
40004028: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000402c: 82 10 63 00 or %g1, 0x300, %g1 ! 4001f300 <rtems_malloc_statistics>
40004030: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
40004034: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
40004038: 84 00 a0 01 inc %g2
if ( !ptr )
4000403c: 80 a6 20 00 cmp %i0, 0
40004040: 02 80 00 21 be 400040c4 <free+0xa0>
40004044: 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()) &&
40004048: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000404c: c2 00 61 88 ld [ %g1 + 0x188 ], %g1 ! 4001f988 <_System_state_Current>
40004050: 80 a0 60 03 cmp %g1, 3
40004054: 12 80 00 09 bne 40004078 <free+0x54> <== NEVER TAKEN
40004058: 03 10 00 7b sethi %hi(0x4001ec00), %g1
!malloc_is_system_state_OK() ) {
4000405c: 40 00 00 78 call 4000423c <malloc_is_system_state_OK>
40004060: 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()) &&
40004064: 80 8a 20 ff btst 0xff, %o0
40004068: 12 80 00 04 bne 40004078 <free+0x54>
4000406c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
40004070: 40 00 00 8c call 400042a0 <malloc_deferred_free>
40004074: 81 e8 00 00 restore
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40004078: c2 00 62 60 ld [ %g1 + 0x260 ], %g1
4000407c: 80 a0 60 00 cmp %g1, 0
40004080: 02 80 00 06 be 40004098 <free+0x74>
40004084: 3b 10 00 79 sethi %hi(0x4001e400), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
40004088: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000408c: 9f c0 40 00 call %g1
40004090: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
40004094: 3b 10 00 79 sethi %hi(0x4001e400), %i5
40004098: d0 07 63 30 ld [ %i5 + 0x330 ], %o0 ! 4001e730 <RTEMS_Malloc_Heap>
4000409c: 40 00 17 1e call 40009d14 <_Protected_heap_Free>
400040a0: 92 10 00 19 mov %i1, %o1
400040a4: 80 8a 20 ff btst 0xff, %o0
400040a8: 12 80 00 07 bne 400040c4 <free+0xa0>
400040ac: c2 07 63 30 ld [ %i5 + 0x330 ], %g1
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
400040b0: 31 10 00 74 sethi %hi(0x4001d000), %i0
400040b4: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
400040b8: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
400040bc: 40 00 03 68 call 40004e5c <printk>
400040c0: 91 ee 20 e8 restore %i0, 0xe8, %o0
400040c4: 81 c7 e0 08 ret
400040c8: 81 e8 00 00 restore
4001b974 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
4001b974: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
4001b978: 80 a6 60 00 cmp %i1, 0
4001b97c: 32 80 00 06 bne,a 4001b994 <fstat+0x20> <== ALWAYS TAKEN
4001b980: 03 10 00 79 sethi %hi(0x4001e400), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
4001b984: 7f ff d0 58 call 4000fae4 <__errno> <== NOT EXECUTED
4001b988: 01 00 00 00 nop <== NOT EXECUTED
4001b98c: 10 80 00 12 b 4001b9d4 <fstat+0x60> <== NOT EXECUTED
4001b990: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
4001b994: c2 00 63 74 ld [ %g1 + 0x374 ], %g1
4001b998: 80 a6 00 01 cmp %i0, %g1
4001b99c: 1a 80 00 0b bcc 4001b9c8 <fstat+0x54>
4001b9a0: 83 2e 20 03 sll %i0, 3, %g1
4001b9a4: b1 2e 20 06 sll %i0, 6, %i0
4001b9a8: b0 26 00 01 sub %i0, %g1, %i0
4001b9ac: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001b9b0: c2 00 62 f4 ld [ %g1 + 0x2f4 ], %g1 ! 4001f2f4 <rtems_libio_iops>
4001b9b4: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
4001b9b8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001b9bc: 80 88 61 00 btst 0x100, %g1
4001b9c0: 12 80 00 08 bne 4001b9e0 <fstat+0x6c>
4001b9c4: 94 10 20 48 mov 0x48, %o2
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
4001b9c8: 7f ff d0 47 call 4000fae4 <__errno>
4001b9cc: 01 00 00 00 nop
4001b9d0: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4001b9d4: c2 22 00 00 st %g1, [ %o0 ]
4001b9d8: 81 c7 e0 08 ret
4001b9dc: 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) );
4001b9e0: 90 10 00 19 mov %i1, %o0
4001b9e4: 7f ff d2 ce call 4001051c <memset>
4001b9e8: 92 10 20 00 clr %o1
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
4001b9ec: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001b9f0: 90 06 20 14 add %i0, 0x14, %o0
4001b9f4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4001b9f8: 9f c0 40 00 call %g1
4001b9fc: 92 10 00 19 mov %i1, %o1
}
4001ba00: 81 c7 e0 08 ret
4001ba04: 91 e8 00 08 restore %g0, %o0, %o0
40004074 <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) {
40004074: 03 10 00 6c sethi %hi(0x4001b000), %g1
40004078: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 4001b310 <disktab_size>
4000407c: 80 a2 00 01 cmp %o0, %g1
40004080: 1a 80 00 1e bcc 400040f8 <get_disk_entry+0x84> <== NEVER TAKEN
40004084: 03 10 00 6c sethi %hi(0x4001b000), %g1
40004088: c2 00 63 14 ld [ %g1 + 0x314 ], %g1 ! 4001b314 <disktab>
4000408c: 80 a0 60 00 cmp %g1, 0
40004090: 22 80 00 1b be,a 400040fc <get_disk_entry+0x88> <== NEVER TAKEN
40004094: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_disk_device_table *dtab = disktab + major;
40004098: 91 2a 20 03 sll %o0, 3, %o0
4000409c: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
400040a0: c4 00 a0 04 ld [ %g2 + 4 ], %g2
400040a4: 80 a2 40 02 cmp %o1, %g2
400040a8: 3a 80 00 15 bcc,a 400040fc <get_disk_entry+0x88> <== NEVER TAKEN
400040ac: 90 10 20 00 clr %o0 <== NOT EXECUTED
400040b0: c2 00 40 08 ld [ %g1 + %o0 ], %g1
400040b4: 80 a0 60 00 cmp %g1, 0
400040b8: 02 80 00 10 be 400040f8 <get_disk_entry+0x84> <== NEVER TAKEN
400040bc: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
400040c0: 80 a2 a0 01 cmp %o2, 1
400040c4: 02 80 00 0e be 400040fc <get_disk_entry+0x88>
400040c8: d0 00 40 09 ld [ %g1 + %o1 ], %o0
400040cc: 80 a2 20 00 cmp %o0, 0
400040d0: 02 80 00 0b be 400040fc <get_disk_entry+0x88> <== NEVER TAKEN
400040d4: 01 00 00 00 nop
if (!dd->deleted) {
400040d8: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
400040dc: 80 a0 60 00 cmp %g1, 0
400040e0: 32 80 00 07 bne,a 400040fc <get_disk_entry+0x88>
400040e4: 90 10 20 00 clr %o0
++dd->uses;
400040e8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
400040ec: 82 00 60 01 inc %g1
400040f0: 81 c3 e0 08 retl
400040f4: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
400040f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
400040fc: 81 c3 e0 08 retl
400052d8 <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,
400052d8: 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);
400052dc: 40 00 04 fd call 400066d0 <malloc>
400052e0: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
400052e4: 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)
400052e8: 80 a2 20 00 cmp %o0, 0
400052ec: 02 80 00 0f be 40005328 <get_sector.part.0+0x50> <== NEVER TAKEN
400052f0: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
400052f4: 90 10 00 18 mov %i0, %o0
400052f8: 92 07 60 04 add %i5, 4, %o1
400052fc: 40 00 07 97 call 40007158 <read>
40005300: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
40005304: 80 a2 22 00 cmp %o0, 0x200
40005308: 22 80 00 06 be,a 40005320 <get_sector.part.0+0x48> <== ALWAYS TAKEN
4000530c: f2 27 40 00 st %i1, [ %i5 ]
{
free(s);
40005310: 40 00 03 5f call 4000608c <free> <== NOT EXECUTED
40005314: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
40005318: 10 80 00 04 b 40005328 <get_sector.part.0+0x50> <== NOT EXECUTED
4000531c: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
}
s->sector_num = sector_num;
*sector = s;
40005320: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
40005324: 82 10 20 00 clr %g1
}
40005328: 81 c7 e0 08 ret
4000532c: 91 e8 00 01 restore %g0, %g1, %o0
400319fc <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
400319fc: 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 );
40031a00: 03 10 00 de sethi %hi(0x40037800), %g1
40031a04: c2 00 61 fc ld [ %g1 + 0x1fc ], %g1 ! 400379fc <rtems_libio_number_iops>
40031a08: 80 a6 00 01 cmp %i0, %g1
40031a0c: 1a 80 00 08 bcc 40031a2c <getdents+0x30> <== NEVER TAKEN
40031a10: ba 10 20 00 clr %i5
40031a14: 83 2e 20 03 sll %i0, 3, %g1
40031a18: b1 2e 20 06 sll %i0, 6, %i0
40031a1c: b0 26 00 01 sub %i0, %g1, %i0
40031a20: 03 10 01 21 sethi %hi(0x40048400), %g1
40031a24: fa 00 62 e4 ld [ %g1 + 0x2e4 ], %i5 ! 400486e4 <rtems_libio_iops>
40031a28: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
40031a2c: 7f ff 63 08 call 4000a64c <rtems_filesystem_node_type>
40031a30: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
40031a34: 80 a2 20 00 cmp %o0, 0
40031a38: 22 80 00 08 be,a 40031a58 <getdents+0x5c>
40031a3c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_set_errno_and_return_minus_one( ENOTDIR );
40031a40: 7f ff bd df call 400211bc <__errno>
40031a44: b0 10 3f ff mov -1, %i0
40031a48: 82 10 20 14 mov 0x14, %g1
40031a4c: c2 22 00 00 st %g1, [ %o0 ]
40031a50: 81 c7 e0 08 ret
40031a54: 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 );
40031a58: 90 10 00 1d mov %i5, %o0
40031a5c: c2 00 60 08 ld [ %g1 + 8 ], %g1
40031a60: 92 10 00 19 mov %i1, %o1
40031a64: 9f c0 40 00 call %g1
40031a68: 94 10 00 1a mov %i2, %o2
}
40031a6c: 81 c7 e0 08 ret
40031a70: 91 e8 00 08 restore %g0, %o0, %o0
400248a4 <init_etc_passwd_group>:
/**
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
400248a4: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
400248a8: 03 10 01 8e sethi %hi(0x40063800), %g1
400248ac: c4 48 63 40 ldsb [ %g1 + 0x340 ], %g2 ! 40063b40 <etc_passwd_initted.7068>
400248b0: 80 a0 a0 00 cmp %g2, 0
400248b4: 12 80 00 2f bne 40024970 <init_etc_passwd_group+0xcc>
400248b8: 84 10 20 01 mov 1, %g2
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
400248bc: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
400248c0: c4 28 63 40 stb %g2, [ %g1 + 0x340 ]
mkdir("/etc", 0777);
400248c4: 11 10 01 6c sethi %hi(0x4005b000), %o0
400248c8: 7f ff 7d b1 call 40003f8c <mkdir>
400248cc: 90 12 21 28 or %o0, 0x128, %o0 ! 4005b128 <rtems_status_assoc+0x168>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
400248d0: 3b 10 01 6c sethi %hi(0x4005b000), %i5
400248d4: 13 10 01 7e sethi %hi(0x4005f800), %o1
400248d8: 90 17 61 30 or %i5, 0x130, %o0
400248dc: 40 00 4d 1f call 40037d58 <fopen>
400248e0: 92 12 60 40 or %o1, 0x40, %o1
400248e4: 80 a2 20 00 cmp %o0, 0
400248e8: 22 80 00 03 be,a 400248f4 <init_etc_passwd_group+0x50>
400248ec: 90 17 61 30 or %i5, 0x130, %o0
400248f0: 30 80 00 0b b,a 4002491c <init_etc_passwd_group+0x78>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
400248f4: 13 10 01 62 sethi %hi(0x40058800), %o1
400248f8: 40 00 4d 18 call 40037d58 <fopen>
400248fc: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 40058bf8 <rtems_rtc_shell_usage+0x4e8>
40024900: ba 92 20 00 orcc %o0, 0, %i5
40024904: 02 80 00 08 be 40024924 <init_etc_passwd_group+0x80> <== NEVER TAKEN
40024908: 11 10 01 6c sethi %hi(0x4005b000), %o0
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
4002490c: 92 10 00 1d mov %i5, %o1
40024910: 40 00 4d 75 call 40037ee4 <fputs>
40024914: 90 12 21 40 or %o0, 0x140, %o0
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
40024918: 90 10 00 1d mov %i5, %o0
4002491c: 40 00 4a b1 call 400373e0 <fclose>
40024920: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
40024924: 3b 10 01 6c sethi %hi(0x4005b000), %i5
40024928: 13 10 01 7e sethi %hi(0x4005f800), %o1
4002492c: 90 17 61 a8 or %i5, 0x1a8, %o0
40024930: 40 00 4d 0a call 40037d58 <fopen>
40024934: 92 12 60 40 or %o1, 0x40, %o1
40024938: b0 92 20 00 orcc %o0, 0, %i0
4002493c: 12 80 00 0b bne 40024968 <init_etc_passwd_group+0xc4>
40024940: 90 17 61 a8 or %i5, 0x1a8, %o0
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
40024944: 13 10 01 62 sethi %hi(0x40058800), %o1
40024948: 40 00 4d 04 call 40037d58 <fopen>
4002494c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 40058bf8 <rtems_rtc_shell_usage+0x4e8>
40024950: b0 92 20 00 orcc %o0, 0, %i0
40024954: 02 80 00 07 be 40024970 <init_etc_passwd_group+0xcc> <== NEVER TAKEN
40024958: 11 10 01 6c sethi %hi(0x4005b000), %o0
fprintf( fp, "root:x:0:root\n"
4002495c: 92 10 00 18 mov %i0, %o1
40024960: 40 00 4d 61 call 40037ee4 <fputs>
40024964: 90 12 21 b8 or %o0, 0x1b8, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
40024968: 40 00 4a 9e call 400373e0 <fclose>
4002496c: 81 e8 00 00 restore
40024970: 81 c7 e0 08 ret
40024974: 81 e8 00 00 restore
40006aac <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
40006aac: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
40006ab0: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
40006ab4: 80 88 60 20 btst 0x20, %g1
40006ab8: 32 80 00 02 bne,a 40006ac0 <iproc+0x14> <== NEVER TAKEN
40006abc: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
40006ac0: 80 88 62 00 btst 0x200, %g1
40006ac4: 02 80 00 0c be 40006af4 <iproc+0x48>
40006ac8: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
40006acc: 05 10 00 7a sethi %hi(0x4001e800), %g2
40006ad0: c4 00 a1 30 ld [ %g2 + 0x130 ], %g2 ! 4001e930 <__ctype_ptr__>
40006ad4: 84 00 80 18 add %g2, %i0, %g2
40006ad8: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
40006adc: 84 08 a0 03 and %g2, 3, %g2
40006ae0: 80 a0 a0 01 cmp %g2, 1
40006ae4: 22 80 00 02 be,a 40006aec <iproc+0x40>
40006ae8: b0 06 20 20 add %i0, 0x20, %i0
40006aec: b0 0e 20 ff and %i0, 0xff, %i0
if (c == '\r') {
40006af0: 80 a6 20 0d cmp %i0, 0xd
40006af4: 12 80 00 0b bne 40006b20 <iproc+0x74>
40006af8: 80 a6 20 0a cmp %i0, 0xa
if (tty->termios.c_iflag & IGNCR)
40006afc: 80 88 60 80 btst 0x80, %g1
40006b00: 02 80 00 04 be 40006b10 <iproc+0x64> <== ALWAYS TAKEN
40006b04: 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;
40006b08: 81 c7 e0 08 ret <== NOT EXECUTED
40006b0c: 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)
40006b10: 32 80 00 0d bne,a 40006b44 <iproc+0x98> <== ALWAYS TAKEN
40006b14: 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)) {
40006b18: 10 80 00 0c b 40006b48 <iproc+0x9c> <== NOT EXECUTED
40006b1c: 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)) {
40006b20: 12 80 00 07 bne 40006b3c <iproc+0x90>
40006b24: 80 a6 20 00 cmp %i0, 0
40006b28: 80 88 60 40 btst 0x40, %g1
40006b2c: 32 80 00 06 bne,a 40006b44 <iproc+0x98> <== NEVER TAKEN
40006b30: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40006b34: 10 80 00 05 b 40006b48 <iproc+0x9c>
40006b38: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006b3c: 02 80 00 51 be 40006c80 <iproc+0x1d4> <== NEVER TAKEN
40006b40: 03 10 00 79 sethi %hi(0x4001e400), %g1
40006b44: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006b48: 80 88 60 02 btst 2, %g1
40006b4c: 22 80 00 4d be,a 40006c80 <iproc+0x1d4>
40006b50: 03 10 00 79 sethi %hi(0x4001e400), %g1
if (c == tty->termios.c_cc[VERASE]) {
40006b54: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
40006b58: 80 a0 80 18 cmp %g2, %i0
40006b5c: 32 80 00 08 bne,a 40006b7c <iproc+0xd0>
40006b60: 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)
40006b64: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40006b68: 80 a0 60 00 cmp %g1, 0
40006b6c: 02 80 00 57 be 40006cc8 <iproc+0x21c>
40006b70: 90 10 00 19 mov %i1, %o0
40006b74: 10 80 00 1d b 40006be8 <iproc+0x13c>
40006b78: 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]) {
40006b7c: 80 a0 80 18 cmp %g2, %i0
40006b80: 32 80 00 1d bne,a 40006bf4 <iproc+0x148>
40006b84: 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)
40006b88: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40006b8c: 80 a0 a0 00 cmp %g2, 0
40006b90: 02 80 00 4e be 40006cc8 <iproc+0x21c> <== NEVER TAKEN
40006b94: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
40006b98: 12 80 00 04 bne 40006ba8 <iproc+0xfc> <== ALWAYS TAKEN
40006b9c: 90 10 00 19 mov %i1, %o0
tty->ccount = 0;
40006ba0: 10 80 00 4a b 40006cc8 <iproc+0x21c> <== NOT EXECUTED
40006ba4: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
40006ba8: 80 88 60 10 btst 0x10, %g1
40006bac: 12 80 00 0f bne 40006be8 <iproc+0x13c> <== ALWAYS TAKEN
40006bb0: 92 10 20 01 mov 1, %o1
tty->ccount = 0;
40006bb4: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
40006bb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006bbc: 7f ff ff 2d call 40006870 <echo> <== NOT EXECUTED
40006bc0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
40006bc4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
40006bc8: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40006bcc: 22 80 00 42 be,a 40006cd4 <iproc+0x228> <== NOT EXECUTED
40006bd0: b0 10 20 00 clr %i0 <== NOT EXECUTED
echo ('\n', tty);
40006bd4: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
40006bd8: 7f ff ff 26 call 40006870 <echo> <== NOT EXECUTED
40006bdc: 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;
40006be0: 81 c7 e0 08 ret <== NOT EXECUTED
40006be4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40006be8: 7f ff ff 43 call 400068f4 <erase.part.2>
40006bec: b0 10 20 00 clr %i0
40006bf0: 30 80 00 39 b,a 40006cd4 <iproc+0x228>
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
40006bf4: 80 a0 80 18 cmp %g2, %i0
40006bf8: 02 80 00 36 be 40006cd0 <iproc+0x224> <== NEVER TAKEN
40006bfc: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
40006c00: 32 80 00 0d bne,a 40006c34 <iproc+0x188>
40006c04: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
if (tty->termios.c_lflag & (ECHO | ECHONL))
40006c08: 80 88 60 48 btst 0x48, %g1
40006c0c: 22 80 00 06 be,a 40006c24 <iproc+0x178> <== NEVER TAKEN
40006c10: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40006c14: 90 10 20 0a mov 0xa, %o0
40006c18: 7f ff ff 16 call 40006870 <echo>
40006c1c: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
40006c20: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40006c24: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
40006c28: 86 10 20 0a mov 0xa, %g3
40006c2c: 10 80 00 12 b 40006c74 <iproc+0x1c8>
40006c30: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
40006c34: 80 a0 80 18 cmp %g2, %i0
40006c38: 02 80 00 07 be 40006c54 <iproc+0x1a8> <== NEVER TAKEN
40006c3c: 80 88 60 08 btst 8, %g1
40006c40: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
40006c44: 80 a0 80 18 cmp %g2, %i0
40006c48: 32 80 00 0e bne,a 40006c80 <iproc+0x1d4> <== ALWAYS TAKEN
40006c4c: 03 10 00 79 sethi %hi(0x4001e400), %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
40006c50: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40006c54: 22 80 00 06 be,a 40006c6c <iproc+0x1c0> <== NOT EXECUTED
40006c58: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40006c5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006c60: 7f ff ff 04 call 40006870 <echo> <== NOT EXECUTED
40006c64: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
40006c68: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40006c6c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
40006c70: f0 28 80 01 stb %i0, [ %g2 + %g1 ] <== NOT EXECUTED
40006c74: 82 00 60 01 inc %g1
40006c78: 10 80 00 16 b 40006cd0 <iproc+0x224>
40006c7c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
40006c80: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40006c84: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1
40006c88: 82 00 7f ff add %g1, -1, %g1
40006c8c: 80 a0 80 01 cmp %g2, %g1
40006c90: 3a 80 00 11 bcc,a 40006cd4 <iproc+0x228> <== NEVER TAKEN
40006c94: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
40006c98: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006c9c: 80 88 60 08 btst 8, %g1
40006ca0: 22 80 00 06 be,a 40006cb8 <iproc+0x20c> <== NEVER TAKEN
40006ca4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40006ca8: 90 10 00 18 mov %i0, %o0
40006cac: 7f ff fe f1 call 40006870 <echo>
40006cb0: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
40006cb4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40006cb8: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
40006cbc: f0 28 80 01 stb %i0, [ %g2 + %g1 ]
40006cc0: 82 00 60 01 inc %g1
40006cc4: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
return 0;
40006cc8: 81 c7 e0 08 ret
40006ccc: 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;
40006cd0: b0 10 20 01 mov 1, %i0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
40006cd4: 81 c7 e0 08 ret
40006cd8: 81 e8 00 00 restore
4001bdac <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
4001bdac: 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() )
4001bdb0: 7f ff ff 1b call 4001ba1c <getpid>
4001bdb4: 01 00 00 00 nop
4001bdb8: 80 a6 00 08 cmp %i0, %o0
4001bdbc: 02 80 00 06 be 4001bdd4 <killinfo+0x28>
4001bdc0: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
4001bdc4: 7f ff cf 48 call 4000fae4 <__errno>
4001bdc8: 01 00 00 00 nop
4001bdcc: 10 80 00 a6 b 4001c064 <killinfo+0x2b8>
4001bdd0: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
/*
* Validate the signal passed.
*/
if ( !sig )
4001bdd4: 32 80 00 03 bne,a 4001bde0 <killinfo+0x34>
4001bdd8: ba 06 7f ff add %i1, -1, %i5
4001bddc: 30 80 00 04 b,a 4001bdec <killinfo+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001bde0: 80 a7 60 1f cmp %i5, 0x1f
4001bde4: 28 80 00 06 bleu,a 4001bdfc <killinfo+0x50>
4001bde8: 83 2e 60 02 sll %i1, 2, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
4001bdec: 7f ff cf 3e call 4000fae4 <__errno>
4001bdf0: 01 00 00 00 nop
4001bdf4: 10 80 00 9c b 4001c064 <killinfo+0x2b8>
4001bdf8: 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 )
4001bdfc: 85 2e 60 04 sll %i1, 4, %g2
4001be00: 84 20 80 01 sub %g2, %g1, %g2
4001be04: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001be08: 82 10 61 f0 or %g1, 0x1f0, %g1 ! 4001f9f0 <_POSIX_signals_Vectors>
4001be0c: 82 00 40 02 add %g1, %g2, %g1
4001be10: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001be14: 80 a0 60 01 cmp %g1, 1
4001be18: 02 80 00 9f be 4001c094 <killinfo+0x2e8>
4001be1c: 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 ) )
4001be20: 02 80 00 06 be 4001be38 <killinfo+0x8c>
4001be24: 80 a6 60 08 cmp %i1, 8
4001be28: 02 80 00 04 be 4001be38 <killinfo+0x8c>
4001be2c: 80 a6 60 0b cmp %i1, 0xb
4001be30: 12 80 00 08 bne 4001be50 <killinfo+0xa4>
4001be34: 82 10 20 01 mov 1, %g1
return pthread_kill( pthread_self(), sig );
4001be38: 40 00 01 33 call 4001c304 <pthread_self>
4001be3c: 01 00 00 00 nop
4001be40: 40 00 00 f4 call 4001c210 <pthread_kill>
4001be44: 92 10 00 19 mov %i1, %o1
4001be48: 81 c7 e0 08 ret
4001be4c: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
4001be50: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
4001be54: c2 27 bf f8 st %g1, [ %fp + -8 ]
if ( !value ) {
4001be58: 80 a6 a0 00 cmp %i2, 0
4001be5c: 12 80 00 04 bne 4001be6c <killinfo+0xc0>
4001be60: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_value.sival_int = 0;
4001be64: 10 80 00 04 b 4001be74 <killinfo+0xc8>
4001be68: c0 27 bf fc clr [ %fp + -4 ]
} else {
siginfo->si_value = *value;
4001be6c: c2 06 80 00 ld [ %i2 ], %g1
4001be70: 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;
4001be74: 03 10 00 7d sethi %hi(0x4001f400), %g1
4001be78: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 4001f480 <_Thread_Dispatch_disable_level>
++level;
4001be7c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4001be80: c4 20 60 80 st %g2, [ %g1 + 0x80 ]
*/
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 );
4001be84: 11 10 00 7a sethi %hi(0x4001e800), %o0
4001be88: 7f ff b2 bb call 40008974 <_API_extensions_Add_post_switch>
4001be8c: 90 12 20 7c or %o0, 0x7c, %o0 ! 4001e87c <_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;
4001be90: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001be94: d0 00 61 a0 ld [ %g1 + 0x1a0 ], %o0 ! 4001f9a0 <_Per_CPU_Information+0x10>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
4001be98: c4 02 21 50 ld [ %o0 + 0x150 ], %g2
4001be9c: c4 00 a0 d0 ld [ %g2 + 0xd0 ], %g2
4001bea0: 80 af 40 02 andncc %i5, %g2, %g0
4001bea4: 12 80 00 52 bne 4001bfec <killinfo+0x240>
4001bea8: 03 10 00 7e sethi %hi(0x4001f800), %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 );
4001beac: 05 10 00 7e sethi %hi(0x4001f800), %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001beb0: c2 00 63 7c ld [ %g1 + 0x37c ], %g1
4001beb4: 10 80 00 0a b 4001bedc <killinfo+0x130>
4001beb8: 84 10 a3 80 or %g2, 0x380, %g2
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
4001bebc: 80 8f 40 04 btst %i5, %g4
4001bec0: 12 80 00 4a bne 4001bfe8 <killinfo+0x23c>
4001bec4: 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)
4001bec8: c6 00 e0 d0 ld [ %g3 + 0xd0 ], %g3
4001becc: 80 af 40 03 andncc %i5, %g3, %g0
4001bed0: 12 80 00 47 bne 4001bfec <killinfo+0x240>
4001bed4: 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 ) {
4001bed8: 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 );
4001bedc: 80 a0 40 02 cmp %g1, %g2
4001bee0: 32 bf ff f7 bne,a 4001bebc <killinfo+0x110>
4001bee4: c8 00 60 30 ld [ %g1 + 0x30 ], %g4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001bee8: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001beec: c6 08 62 ac ldub [ %g1 + 0x2ac ], %g3 ! 4001e6ac <rtems_maximum_priority>
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4001bef0: b8 10 20 02 mov 2, %i4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001bef4: 86 00 e0 01 inc %g3
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
4001bef8: 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 ] )
4001befc: 1b 10 00 7c sethi %hi(0x4001f000), %o5
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
4001bf00: 35 04 00 00 sethi %hi(0x10000000), %i2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
4001bf04: 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 ] )
4001bf08: 88 13 63 e4 or %o5, 0x3e4, %g4
4001bf0c: c4 01 00 02 ld [ %g4 + %g2 ], %g2
4001bf10: 80 a0 a0 00 cmp %g2, 0
4001bf14: 22 80 00 2f be,a 4001bfd0 <killinfo+0x224> <== NEVER TAKEN
4001bf18: b8 07 20 01 inc %i4 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
4001bf1c: 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++ ) {
4001bf20: b6 10 20 01 mov 1, %i3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
4001bf24: d8 10 a0 10 lduh [ %g2 + 0x10 ], %o4
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001bf28: 10 80 00 26 b 4001bfc0 <killinfo+0x214>
4001bf2c: d6 00 a0 1c ld [ %g2 + 0x1c ], %o3
the_thread = (Thread_Control *) object_table[ index ];
4001bf30: c4 02 c0 02 ld [ %o3 + %g2 ], %g2
if ( !the_thread )
4001bf34: 80 a0 a0 00 cmp %g2, 0
4001bf38: 22 80 00 22 be,a 4001bfc0 <killinfo+0x214>
4001bf3c: 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 )
4001bf40: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
4001bf44: 80 a1 00 03 cmp %g4, %g3
4001bf48: 38 80 00 1e bgu,a 4001bfc0 <killinfo+0x214>
4001bf4c: b6 06 e0 01 inc %i3
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
4001bf50: f0 00 a1 50 ld [ %g2 + 0x150 ], %i0
4001bf54: f0 06 20 d0 ld [ %i0 + 0xd0 ], %i0
4001bf58: 80 af 40 18 andncc %i5, %i0, %g0
4001bf5c: 22 80 00 19 be,a 4001bfc0 <killinfo+0x214>
4001bf60: 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 ) {
4001bf64: 80 a1 00 03 cmp %g4, %g3
4001bf68: 2a 80 00 14 bcs,a 4001bfb8 <killinfo+0x20c>
4001bf6c: 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 ) ) {
4001bf70: 80 a0 60 00 cmp %g1, 0
4001bf74: 22 80 00 13 be,a 4001bfc0 <killinfo+0x214> <== NEVER TAKEN
4001bf78: b6 06 e0 01 inc %i3 <== NOT EXECUTED
4001bf7c: de 00 60 10 ld [ %g1 + 0x10 ], %o7
4001bf80: 80 a3 e0 00 cmp %o7, 0
4001bf84: 22 80 00 0f be,a 4001bfc0 <killinfo+0x214> <== NEVER TAKEN
4001bf88: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
4001bf8c: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
4001bf90: 80 a6 20 00 cmp %i0, 0
4001bf94: 22 80 00 09 be,a 4001bfb8 <killinfo+0x20c>
4001bf98: 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) ) {
4001bf9c: 80 8b c0 1a btst %o7, %i2
4001bfa0: 32 80 00 08 bne,a 4001bfc0 <killinfo+0x214>
4001bfa4: b6 06 e0 01 inc %i3
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4001bfa8: 80 8e 00 1a btst %i0, %i2
4001bfac: 22 80 00 05 be,a 4001bfc0 <killinfo+0x214>
4001bfb0: 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 ) ) {
4001bfb4: 86 10 00 04 mov %g4, %g3
4001bfb8: 82 10 00 02 mov %g2, %g1
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001bfbc: b6 06 e0 01 inc %i3
4001bfc0: 80 a6 c0 0c cmp %i3, %o4
4001bfc4: 08 bf ff db bleu 4001bf30 <killinfo+0x184>
4001bfc8: 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++) {
4001bfcc: b8 07 20 01 inc %i4
4001bfd0: 80 a7 20 04 cmp %i4, 4
4001bfd4: 12 bf ff cd bne 4001bf08 <killinfo+0x15c>
4001bfd8: 85 2f 20 02 sll %i4, 2, %g2
}
}
}
}
if ( interested ) {
4001bfdc: 80 a0 60 00 cmp %g1, 0
4001bfe0: 02 80 00 0c be 4001c010 <killinfo+0x264>
4001bfe4: 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)
4001bfe8: 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 ) ) {
4001bfec: 92 10 00 19 mov %i1, %o1
4001bff0: 40 00 00 36 call 4001c0c8 <_POSIX_signals_Unblock_thread>
4001bff4: 94 07 bf f4 add %fp, -12, %o2
4001bff8: 80 8a 20 ff btst 0xff, %o0
4001bffc: 02 80 00 05 be 4001c010 <killinfo+0x264>
4001c000: 01 00 00 00 nop
_Thread_Enable_dispatch();
4001c004: 7f ff ba 25 call 4000a898 <_Thread_Enable_dispatch>
4001c008: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4001c00c: 30 80 00 23 b,a 4001c098 <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 );
4001c010: 40 00 00 24 call 4001c0a0 <_POSIX_signals_Set_process_signals>
4001c014: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
4001c018: 83 2e 60 02 sll %i1, 2, %g1
4001c01c: b3 2e 60 04 sll %i1, 4, %i1
4001c020: b2 26 40 01 sub %i1, %g1, %i1
4001c024: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001c028: 82 10 61 f0 or %g1, 0x1f0, %g1 ! 4001f9f0 <_POSIX_signals_Vectors>
4001c02c: c2 00 40 19 ld [ %g1 + %i1 ], %g1
4001c030: 80 a0 60 02 cmp %g1, 2
4001c034: 12 bf ff f4 bne 4001c004 <killinfo+0x258>
4001c038: 11 10 00 7e sethi %hi(0x4001f800), %o0
psiginfo = (POSIX_signals_Siginfo_node *)
4001c03c: 7f ff b2 b3 call 40008b08 <_Chain_Get>
4001c040: 90 12 23 70 or %o0, 0x370, %o0 ! 4001fb70 <_POSIX_signals_Inactive_siginfo>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
4001c044: ba 92 20 00 orcc %o0, 0, %i5
4001c048: 12 80 00 0a bne 4001c070 <killinfo+0x2c4>
4001c04c: 92 07 bf f4 add %fp, -12, %o1
_Thread_Enable_dispatch();
4001c050: 7f ff ba 12 call 4000a898 <_Thread_Enable_dispatch>
4001c054: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
4001c058: 7f ff ce a3 call 4000fae4 <__errno>
4001c05c: 01 00 00 00 nop
4001c060: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
4001c064: c2 22 00 00 st %g1, [ %o0 ]
4001c068: 81 c7 e0 08 ret
4001c06c: 91 e8 3f ff restore %g0, -1, %o0
}
psiginfo->Info = *siginfo;
4001c070: 90 07 60 08 add %i5, 8, %o0
4001c074: 7f ff d0 ed call 40010428 <memcpy>
4001c078: 94 10 20 0c mov 0xc, %o2
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001c07c: 11 10 00 7e sethi %hi(0x4001f800), %o0
4001c080: 92 10 00 1d mov %i5, %o1
4001c084: 90 12 23 e8 or %o0, 0x3e8, %o0
4001c088: 7f ff b2 94 call 40008ad8 <_Chain_Append>
4001c08c: 90 02 00 19 add %o0, %i1, %o0
4001c090: 30 bf ff dd b,a 4001c004 <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;
4001c094: b0 10 20 00 clr %i0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
4001c098: 81 c7 e0 08 ret
4001c09c: 81 e8 00 00 restore
400048a4 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
400048a4: 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()))
400048a8: 03 10 00 7e sethi %hi(0x4001f800), %g1
400048ac: c2 00 61 88 ld [ %g1 + 0x188 ], %g1 ! 4001f988 <_System_state_Current>
400048b0: 80 a0 60 03 cmp %g1, 3
400048b4: 12 80 00 16 bne 4000490c <libc_wrapup+0x68> <== NEVER TAKEN
400048b8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
400048bc: 39 10 00 7a sethi %hi(0x4001e800), %i4
400048c0: fa 00 60 78 ld [ %g1 + 0x78 ], %i5
400048c4: c2 07 21 38 ld [ %i4 + 0x138 ], %g1
400048c8: 80 a0 40 1d cmp %g1, %i5
400048cc: 22 80 00 06 be,a 400048e4 <libc_wrapup+0x40>
400048d0: 3b 10 00 7a sethi %hi(0x4001e800), %i5
_wrapup_reent(_global_impure_ptr);
400048d4: 40 00 2f b3 call 400107a0 <_wrapup_reent>
400048d8: 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;
400048dc: fa 27 21 38 st %i5, [ %i4 + 0x138 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
400048e0: 3b 10 00 7a sethi %hi(0x4001e800), %i5
400048e4: c2 07 61 38 ld [ %i5 + 0x138 ], %g1 ! 4001e938 <_impure_ptr>
400048e8: 40 00 2c d1 call 4000fc2c <fclose>
400048ec: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
400048f0: c2 07 61 38 ld [ %i5 + 0x138 ], %g1
400048f4: 40 00 2c ce call 4000fc2c <fclose>
400048f8: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
400048fc: c2 07 61 38 ld [ %i5 + 0x138 ], %g1
40004900: f0 00 60 0c ld [ %g1 + 0xc ], %i0
40004904: 40 00 2c ca call 4000fc2c <fclose>
40004908: 81 e8 00 00 restore
4000490c: 81 c7 e0 08 ret <== NOT EXECUTED
40004910: 81 e8 00 00 restore <== NOT EXECUTED
40004374 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
40004374: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
40004378: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000437c: 82 10 63 00 or %g1, 0x300, %g1 ! 4001f300 <rtems_malloc_statistics>
40004380: c4 00 60 04 ld [ %g1 + 4 ], %g2
40004384: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
40004388: 7f ff ff b9 call 4000426c <malloc_deferred_frees_process>
4000438c: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
40004390: 80 a6 20 00 cmp %i0, 0
40004394: 12 80 00 04 bne 400043a4 <malloc+0x30>
40004398: 03 10 00 7e sethi %hi(0x4001f800), %g1
return (void *) 0;
4000439c: 10 80 00 32 b 40004464 <malloc+0xf0>
400043a0: 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()) &&
400043a4: c2 00 61 88 ld [ %g1 + 0x188 ], %g1
400043a8: 80 a0 60 03 cmp %g1, 3
400043ac: 02 80 00 0c be 400043dc <malloc+0x68>
400043b0: 39 10 00 79 sethi %hi(0x4001e400), %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 );
400043b4: d0 07 23 30 ld [ %i4 + 0x330 ], %o0 ! 4001e730 <RTEMS_Malloc_Heap>
400043b8: 92 10 00 18 mov %i0, %o1
400043bc: 94 10 20 00 clr %o2
400043c0: 40 00 16 47 call 40009cdc <_Protected_heap_Allocate_aligned_with_boundary>
400043c4: 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 ) {
400043c8: ba 92 20 00 orcc %o0, 0, %i5
400043cc: 12 80 00 18 bne 4000442c <malloc+0xb8>
400043d0: 03 10 00 7b sethi %hi(0x4001ec00), %g1
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
400043d4: 10 80 00 09 b 400043f8 <malloc+0x84>
400043d8: d0 07 23 30 ld [ %i4 + 0x330 ], %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() )
400043dc: 7f ff ff 98 call 4000423c <malloc_is_system_state_OK>
400043e0: 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()) &&
400043e4: 80 8a 20 ff btst 0xff, %o0
400043e8: 12 bf ff f3 bne 400043b4 <malloc+0x40> <== ALWAYS TAKEN
400043ec: 01 00 00 00 nop
400043f0: 10 80 00 1d b 40004464 <malloc+0xf0> <== NOT EXECUTED
400043f4: 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 );
400043f8: 03 10 00 72 sethi %hi(0x4001c800), %g1
400043fc: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 4001c820 <rtems_malloc_extend_handler>
40004400: 9f c0 40 00 call %g1
40004404: 92 10 00 18 mov %i0, %o1
if ( !return_this ) {
40004408: ba 92 20 00 orcc %o0, 0, %i5
4000440c: 12 80 00 08 bne 4000442c <malloc+0xb8> <== NEVER TAKEN
40004410: 03 10 00 7b sethi %hi(0x4001ec00), %g1
errno = ENOMEM;
40004414: 40 00 2d b4 call 4000fae4 <__errno>
40004418: b0 10 00 1d mov %i5, %i0
4000441c: 82 10 20 0c mov 0xc, %g1
40004420: c2 22 00 00 st %g1, [ %o0 ]
40004424: 81 c7 e0 08 ret
40004428: 81 e8 00 00 restore
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
4000442c: c2 00 62 5c ld [ %g1 + 0x25c ], %g1
40004430: 80 a0 60 00 cmp %g1, 0
40004434: 02 80 00 04 be 40004444 <malloc+0xd0>
40004438: 90 10 00 1d mov %i5, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
4000443c: 9f c0 40 00 call %g1
40004440: 92 10 00 18 mov %i0, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40004444: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40004448: c2 00 62 60 ld [ %g1 + 0x260 ], %g1 ! 4001ee60 <rtems_malloc_statistics_helpers>
4000444c: 80 a0 60 00 cmp %g1, 0
40004450: 22 80 00 06 be,a 40004468 <malloc+0xf4>
40004454: b0 10 00 1d mov %i5, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
40004458: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000445c: 9f c0 40 00 call %g1
40004460: 90 10 00 1d mov %i5, %o0
return return_this;
}
40004464: b0 10 00 1d mov %i5, %i0
40004468: 81 c7 e0 08 ret
4000446c: 81 e8 00 00 restore
4000e23c <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
4000e23c: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
4000e240: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000e244: d2 00 62 f8 ld [ %g1 + 0x2f8 ], %o1 ! 4001eef8 <imfs_memfile_bytes_per_block>
4000e248: 7f ff d6 c4 call 40003d58 <calloc>
4000e24c: 90 10 20 01 mov 1, %o0
if ( memory )
4000e250: b0 92 20 00 orcc %o0, 0, %i0
4000e254: 02 80 00 05 be 4000e268 <memfile_alloc_block+0x2c> <== NEVER TAKEN
4000e258: 03 10 00 7c sethi %hi(0x4001f000), %g1
memfile_blocks_allocated++;
4000e25c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 ! 4001f00c <memfile_blocks_allocated>
4000e260: 84 00 a0 01 inc %g2
4000e264: c4 20 60 0c st %g2, [ %g1 + 0xc ]
return memory;
}
4000e268: 81 c7 e0 08 ret
4000e26c: 81 e8 00 00 restore
4000ed64 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
4000ed64: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4000ed68: 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 )
4000ed6c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
4000ed70: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
4000ed74: 06 80 00 09 bl 4000ed98 <memfile_ftruncate+0x34> <== NOT EXECUTED
4000ed78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000ed7c: 32 80 00 0d bne,a 4000edb0 <memfile_ftruncate+0x4c> <== NOT EXECUTED
4000ed80: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
4000ed84: c2 07 60 54 ld [ %i5 + 0x54 ], %g1 <== NOT EXECUTED
4000ed88: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
4000ed8c: 3a 80 00 09 bcc,a 4000edb0 <memfile_ftruncate+0x4c> <== NOT EXECUTED
4000ed90: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
return IMFS_memfile_extend( the_jnode, true, length );
4000ed94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000ed98: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000ed9c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000eda0: 7f ff fe df call 4000e91c <IMFS_memfile_extend> <== NOT EXECUTED
4000eda4: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4000eda8: 81 c7 e0 08 ret <== NOT EXECUTED
4000edac: 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;
4000edb0: f4 27 60 54 st %i2, [ %i5 + 0x54 ] <== NOT EXECUTED
IMFS_update_atime( the_jnode );
4000edb4: 90 07 bf f8 add %fp, -8, %o0 <== NOT EXECUTED
4000edb8: 7f ff d4 c5 call 400040cc <gettimeofday> <== NOT EXECUTED
4000edbc: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000edc0: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
4000edc4: c2 27 60 40 st %g1, [ %i5 + 0x40 ] <== NOT EXECUTED
return 0;
}
4000edc8: 81 c7 e0 08 ret <== NOT EXECUTED
4000edcc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000ece8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
4000ece8: 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)
4000ecec: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000ecf0: 80 88 60 04 btst 4, %g1
4000ecf4: 12 80 00 04 bne 4000ed04 <memfile_open+0x1c>
4000ecf8: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
4000ecfc: 81 c7 e0 08 ret
4000ed00: 91 e8 20 00 restore %g0, 0, %o0
4000ed04: 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)) {
4000ed08: c2 00 40 00 ld [ %g1 ], %g1
4000ed0c: 80 a0 60 05 cmp %g1, 5
4000ed10: 12 bf ff fb bne 4000ecfc <memfile_open+0x14> <== ALWAYS TAKEN
4000ed14: 03 10 00 75 sethi %hi(0x4001d400), %g1
uint32_t count = the_jnode->info.linearfile.size;
4000ed18: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
4000ed1c: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
4000ed20: 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;
4000ed24: 82 10 62 a4 or %g1, 0x2a4, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
4000ed28: 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;
4000ed2c: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
4000ed30: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
4000ed34: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
4000ed38: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
4000ed3c: 02 bf ff f0 be 4000ecfc <memfile_open+0x14> <== NOT EXECUTED
4000ed40: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4000ed44: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000ed48: 7f ff ff 5d call 4000eabc <IMFS_memfile_write> <== NOT EXECUTED
4000ed4c: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
4000ed50: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
4000ed54: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000ed58: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
4000ed5c: 81 c7 e0 08 ret <== NOT EXECUTED
4000ed60: 81 e8 00 00 restore <== NOT EXECUTED
40004590 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40004590: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
40004594: 80 a6 e0 01 cmp %i3, 1
40004598: 18 80 00 b4 bgu 40004868 <mount+0x2d8>
4000459c: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
400045a0: 40 00 20 d1 call 4000c8e4 <rtems_filesystem_get_mount_handler>
400045a4: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
400045a8: a6 92 20 00 orcc %o0, 0, %l3
400045ac: 02 80 00 af be 40004868 <mount+0x2d8>
400045b0: 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 : "/";
400045b4: 12 80 00 04 bne 400045c4 <mount+0x34>
400045b8: 01 00 00 00 nop
400045bc: 23 10 00 74 sethi %hi(0x4001d000), %l1
400045c0: a2 14 61 20 or %l1, 0x120, %l1 ! 4001d120 <rtems_status_assoc+0x1a0>
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400045c4: 40 00 32 cf call 40011100 <strlen>
400045c8: 90 10 00 1a mov %i2, %o0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400045cc: 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;
400045d0: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400045d4: 02 80 00 06 be 400045ec <mount+0x5c>
400045d8: ac 02 20 01 add %o0, 1, %l6
400045dc: 40 00 32 c9 call 40011100 <strlen>
400045e0: 90 10 00 18 mov %i0, %o0
400045e4: 10 80 00 03 b 400045f0 <mount+0x60>
400045e8: a0 02 20 01 add %o0, 1, %l0
400045ec: 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
400045f0: 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;
400045f4: 40 00 32 c3 call 40011100 <strlen>
400045f8: 90 10 00 11 mov %l1, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
400045fc: 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;
40004600: 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 );
40004604: 90 10 20 01 mov 1, %o0
40004608: 7f ff fd d4 call 40003d58 <calloc>
4000460c: 92 02 40 15 add %o1, %l5, %o1
if ( mt_entry != NULL ) {
40004610: ba 92 20 00 orcc %o0, 0, %i5
40004614: 02 80 00 9d be 40004888 <mount+0x2f8> <== NEVER TAKEN
40004618: 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 );
4000461c: 92 10 00 1a mov %i2, %o1
40004620: 90 10 00 12 mov %l2, %o0
40004624: 40 00 2f 81 call 40010428 <memcpy>
40004628: 94 10 00 16 mov %l6, %o2
mt_entry->type = str;
4000462c: 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 =
40004630: 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 ) {
40004634: 80 a6 20 00 cmp %i0, 0
40004638: 02 80 00 08 be 40004658 <mount+0xc8>
4000463c: b4 04 80 16 add %l2, %l6, %i2
memcpy( str, source_or_null, source_size );
40004640: 90 10 00 1a mov %i2, %o0
40004644: 92 10 00 18 mov %i0, %o1
40004648: 40 00 2f 78 call 40010428 <memcpy>
4000464c: 94 10 00 10 mov %l0, %o2
mt_entry->dev = str;
40004650: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
40004654: b4 06 80 10 add %i2, %l0, %i2
}
memcpy( str, target, target_size );
40004658: 92 10 00 11 mov %l1, %o1
4000465c: 94 10 00 15 mov %l5, %o2
40004660: 40 00 2f 72 call 40010428 <memcpy>
40004664: 90 10 00 1a mov %i2, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
40004668: 82 10 20 01 mov 1, %g1
4000466c: 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;
40004670: 03 10 00 74 sethi %hi(0x4001d000), %g1
40004674: 82 10 61 24 or %g1, 0x124, %g1 ! 4001d124 <rtems_filesystem_default_pathconf>
40004678: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
4000467c: 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 );
40004680: 90 07 60 14 add %i5, 0x14, %o0
40004684: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
40004688: 92 10 00 14 mov %l4, %o1
4000468c: 94 10 20 01 mov 1, %o2
40004690: 96 10 20 24 mov 0x24, %o3
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
40004694: f4 27 60 30 st %i2, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
40004698: e8 27 60 24 st %l4, [ %i5 + 0x24 ]
4000469c: 40 00 11 2a call 40008b44 <_Chain_Initialize>
400046a0: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
400046a4: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
400046a8: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
400046ac: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
400046b0: 9f c4 c0 00 call %l3
400046b4: 92 10 00 1c mov %i4, %o1
if ( rv == 0 ) {
400046b8: b0 92 20 00 orcc %o0, 0, %i0
400046bc: 12 80 00 6f bne 40004878 <mount+0x2e8>
400046c0: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
400046c4: 02 80 00 38 be 400047a4 <mount+0x214>
400046c8: 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 =
400046cc: 94 10 20 1f mov 0x1f, %o2
400046d0: 40 00 02 b0 call 40005190 <rtems_filesystem_eval_path_start>
400046d4: 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;
400046d8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
400046dc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400046e0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
400046e4: 9f c0 80 00 call %g2
400046e8: 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 ) ) {
400046ec: 80 8a 20 ff btst 0xff, %o0
400046f0: 12 80 00 22 bne 40004778 <mount+0x1e8>
400046f4: 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(
400046f8: 40 00 03 a0 call 40005578 <rtems_filesystem_location_copy_and_detach>
400046fc: 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 );
40004700: 40 00 04 16 call 40005758 <rtems_filesystem_location_transform_to_global>
40004704: 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 );
40004708: 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;
4000470c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004710: 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 );
40004714: 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 );
40004718: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
4000471c: 9f c0 40 00 call %g1
40004720: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004724: b0 92 20 00 orcc %o0, 0, %i0
40004728: 12 80 00 11 bne 4000476c <mount+0x1dc>
4000472c: 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 );
40004730: 39 10 00 7c sethi %hi(0x4001f000), %i4
40004734: d0 07 22 fc ld [ %i4 + 0x2fc ], %o0 ! 4001f2fc <rtems_libio_semaphore>
40004738: 40 00 0e 2c call 40007fe8 <rtems_semaphore_obtain>
4000473c: 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;
40004740: 03 10 00 79 sethi %hi(0x4001e400), %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
40004744: d0 07 22 fc ld [ %i4 + 0x2fc ], %o0
40004748: 82 10 63 a0 or %g1, 0x3a0, %g1
4000474c: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
40004750: 86 00 60 04 add %g1, 4, %g3
40004754: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
40004758: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
4000475c: fa 20 80 00 st %i5, [ %g2 ]
40004760: 40 00 0e 6b call 4000810c <rtems_semaphore_release>
40004764: c4 27 60 04 st %g2, [ %i5 + 4 ]
40004768: 30 80 00 08 b,a 40004788 <mount+0x1f8>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
4000476c: 40 00 03 a8 call 4000560c <rtems_filesystem_global_location_release>
40004770: 90 10 00 1c mov %i4, %o0
40004774: 30 80 00 05 b,a 40004788 <mount+0x1f8>
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40004778: 90 07 bf c8 add %fp, -56, %o0
4000477c: 92 10 20 10 mov 0x10, %o1
40004780: 40 00 01 ee call 40004f38 <rtems_filesystem_eval_path_error>
40004784: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40004788: 40 00 02 be call 40005280 <rtems_filesystem_eval_path_cleanup>
4000478c: 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 ) {
40004790: 80 a6 20 00 cmp %i0, 0
40004794: 02 80 00 42 be 4000489c <mount+0x30c>
40004798: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
4000479c: 10 80 00 2f b 40004858 <mount+0x2c8>
400047a0: 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 );
400047a4: 03 10 00 7c sethi %hi(0x4001f000), %g1
400047a8: d0 00 62 fc ld [ %g1 + 0x2fc ], %o0 ! 4001f2fc <rtems_libio_semaphore>
400047ac: 92 10 20 00 clr %o1
400047b0: 40 00 0e 0e call 40007fe8 <rtems_semaphore_obtain>
400047b4: 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;
400047b8: 05 10 00 79 sethi %hi(0x4001e400), %g2
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
400047bc: c6 00 a3 a0 ld [ %g2 + 0x3a0 ], %g3 ! 4001e7a0 <rtems_filesystem_mount_table>
400047c0: 82 10 a3 a0 or %g2, 0x3a0, %g1
400047c4: 84 00 60 04 add %g1, 4, %g2
400047c8: 80 a0 c0 02 cmp %g3, %g2
400047cc: 12 80 00 08 bne 400047ec <mount+0x25c> <== NEVER TAKEN
400047d0: 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;
400047d4: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
400047d8: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
400047dc: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
400047e0: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
400047e4: 10 80 00 06 b 400047fc <mount+0x26c>
400047e8: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
400047ec: 40 00 2c be call 4000fae4 <__errno> <== NOT EXECUTED
400047f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400047f4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
400047f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
400047fc: 03 10 00 7c sethi %hi(0x4001f000), %g1
40004800: 40 00 0e 43 call 4000810c <rtems_semaphore_release>
40004804: d0 00 62 fc ld [ %g1 + 0x2fc ], %o0 ! 4001f2fc <rtems_libio_semaphore>
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
40004808: 80 a6 20 00 cmp %i0, 0
4000480c: 32 80 00 13 bne,a 40004858 <mount+0x2c8> <== NEVER TAKEN
40004810: 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 );
40004814: 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 =
40004818: 40 00 03 9e call 40005690 <rtems_filesystem_global_location_obtain>
4000481c: 90 10 00 1d mov %i5, %o0
40004820: 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 =
40004824: 40 00 03 9b call 40005690 <rtems_filesystem_global_location_obtain>
40004828: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
4000482c: 3b 10 00 79 sethi %hi(0x4001e400), %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 =
40004830: b8 10 00 08 mov %o0, %i4
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
40004834: d0 07 63 c0 ld [ %i5 + 0x3c0 ], %o0
40004838: 92 10 00 1b mov %i3, %o1
4000483c: 40 00 03 8c call 4000566c <rtems_filesystem_global_location_assign>
40004840: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
40004844: d0 07 63 c0 ld [ %i5 + 0x3c0 ], %o0
40004848: 40 00 03 89 call 4000566c <rtems_filesystem_global_location_assign>
4000484c: 92 10 00 1c mov %i4, %o1
40004850: 81 c7 e0 08 ret
40004854: 81 e8 00 00 restore
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004858: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
4000485c: 9f c0 40 00 call %g1
40004860: 90 10 00 1d mov %i5, %o0
40004864: 30 80 00 05 b,a 40004878 <mount+0x2e8>
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
40004868: 40 00 2c 9f call 4000fae4 <__errno>
4000486c: 01 00 00 00 nop
40004870: 10 80 00 09 b 40004894 <mount+0x304>
40004874: 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 );
40004878: 7f ff fd eb call 40004024 <free>
4000487c: 90 10 00 1d mov %i5, %o0
40004880: 81 c7 e0 08 ret
40004884: 81 e8 00 00 restore
}
} else {
errno = ENOMEM;
40004888: 40 00 2c 97 call 4000fae4 <__errno> <== NOT EXECUTED
4000488c: 01 00 00 00 nop <== NOT EXECUTED
40004890: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
40004894: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
40004898: b0 10 3f ff mov -1, %i0
errno = EINVAL;
rv = -1;
}
return rv;
}
4000489c: 81 c7 e0 08 ret
400048a0: 81 e8 00 00 restore
40008ffc <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40008ffc: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
40009000: 90 96 60 00 orcc %i1, 0, %o0
40009004: 02 80 00 09 be 40009028 <mount_and_make_target_path+0x2c>
40009008: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
4000900c: 40 00 02 cd call 40009b40 <rtems_mkdir>
40009010: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
40009014: 80 a2 20 00 cmp %o0, 0
40009018: 12 80 00 09 bne 4000903c <mount_and_make_target_path+0x40><== NEVER TAKEN
4000901c: 01 00 00 00 nop
rv = mount(
40009020: 40 00 00 09 call 40009044 <mount>
40009024: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
40009028: 40 00 60 65 call 400211bc <__errno>
4000902c: 01 00 00 00 nop
40009030: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40009034: c2 22 00 00 st %g1, [ %o0 ]
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
40009038: 90 10 3f ff mov -1, %o0
} else {
errno = EINVAL;
}
return rv;
}
4000903c: 81 c7 e0 08 ret
40009040: 91 e8 00 08 restore %g0, %o0, %o0
40017b14 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
40017b14: 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;
40017b18: 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);
40017b1c: 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;
40017b20: 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;
40017b24: 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);
40017b28: 94 10 20 20 mov 0x20, %o2
40017b2c: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40017b30: 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;
40017b34: e0 06 20 08 ld [ %i0 + 8 ], %l0
fat_file_fd_t *fat_fd = NULL;
40017b38: c0 27 bf 6c clr [ %fp + -148 ]
time_t time_ret = 0;
uint16_t time_val = 0;
40017b3c: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
40017b40: 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;
40017b44: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
40017b48: 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);
40017b4c: 40 00 12 60 call 4001c4cc <memset>
40017b50: 90 07 bf 80 add %fp, -128, %o0
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
40017b54: 90 07 bf c0 add %fp, -64, %o0
40017b58: 92 10 20 00 clr %o1
40017b5c: 40 00 12 5c call 4001c4cc <memset>
40017b60: 94 10 20 40 mov 0x40, %o2
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
40017b64: 80 a6 e1 04 cmp %i3, 0x104
40017b68: 24 80 00 06 ble,a 40017b80 <msdos_creat_node+0x6c> <== ALWAYS TAKEN
40017b6c: 90 10 00 1a mov %i2, %o0
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
40017b70: 40 00 0f 75 call 4001b944 <__errno> <== NOT EXECUTED
40017b74: 01 00 00 00 nop <== NOT EXECUTED
40017b78: 10 80 00 0c b 40017ba8 <msdos_creat_node+0x94> <== NOT EXECUTED
40017b7c: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
40017b80: 92 10 00 1b mov %i3, %o1
40017b84: 94 07 bf 80 add %fp, -128, %o2
40017b88: 40 00 01 45 call 4001809c <msdos_long_to_short>
40017b8c: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
40017b90: a4 92 20 00 orcc %o0, 0, %l2
40017b94: 32 80 00 08 bne,a 40017bb4 <msdos_creat_node+0xa0> <== ALWAYS TAKEN
40017b98: c0 2f bf 8c clrb [ %fp + -116 ]
rtems_set_errno_and_return_minus_one(EINVAL);
40017b9c: 40 00 0f 6a call 4001b944 <__errno> <== NOT EXECUTED
40017ba0: 01 00 00 00 nop <== NOT EXECUTED
40017ba4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40017ba8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40017bac: 10 80 00 ce b 40017ee4 <msdos_creat_node+0x3d0> <== NOT EXECUTED
40017bb0: 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);
40017bb4: 40 00 21 09 call 4001ffd8 <time>
40017bb8: 90 10 20 00 clr %o0
if ( time_ret == -1 )
40017bbc: 80 a2 3f ff cmp %o0, -1
40017bc0: 12 80 00 04 bne 40017bd0 <msdos_creat_node+0xbc> <== ALWAYS TAKEN
40017bc4: 92 07 bf 6a add %fp, -150, %o1
40017bc8: 10 80 00 c7 b 40017ee4 <msdos_creat_node+0x3d0> <== NOT EXECUTED
40017bcc: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
40017bd0: 40 00 0b a0 call 4001aa50 <msdos_date_unix2dos>
40017bd4: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40017bd8: c2 17 bf 68 lduh [ %fp + -152 ], %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40017bdc: 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);
40017be0: 83 28 60 10 sll %g1, 0x10, %g1
40017be4: 85 30 60 08 srl %g1, 8, %g2
40017be8: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40017bec: 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);
40017bf0: 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;
40017bf4: 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);
40017bf8: 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);
40017bfc: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40017c00: 87 30 e0 18 srl %g3, 0x18, %g3
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
40017c04: 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);
40017c08: 82 10 40 03 or %g1, %g3, %g1
40017c0c: 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);
40017c10: 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) {
40017c14: 80 a6 60 00 cmp %i1, 0
40017c18: 12 80 00 05 bne 40017c2c <msdos_creat_node+0x118>
40017c1c: c2 37 bf 92 sth %g1, [ %fp + -110 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
40017c20: c2 0f bf 8b ldub [ %fp + -117 ], %g1
40017c24: 10 80 00 2f b 40017ce0 <msdos_creat_node+0x1cc>
40017c28: 82 10 60 10 or %g1, 0x10, %g1
}
else if (type == MSDOS_HARD_LINK) {
40017c2c: 80 a6 60 02 cmp %i1, 2
40017c30: 12 80 00 2b bne 40017cdc <msdos_creat_node+0x1c8> <== ALWAYS TAKEN
40017c34: 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,
40017c38: 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)) )
40017c3c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40017c40: 32 80 00 08 bne,a 40017c60 <msdos_creat_node+0x14c> <== NOT EXECUTED
40017c44: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
40017c48: c2 0f 20 0e ldub [ %i4 + 0xe ], %g1 <== NOT EXECUTED
40017c4c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40017c50: 22 80 00 04 be,a 40017c60 <msdos_creat_node+0x14c> <== NOT EXECUTED
40017c54: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40017c58: 10 80 00 06 b 40017c70 <msdos_creat_node+0x15c> <== NOT EXECUTED
40017c5c: c4 07 20 20 ld [ %i4 + 0x20 ], %g2 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40017c60: 84 00 bf fe add %g2, -2, %g2 <== NOT EXECUTED
40017c64: 85 28 80 01 sll %g2, %g1, %g2 <== NOT EXECUTED
40017c68: c2 07 20 34 ld [ %i4 + 0x34 ], %g1 <== NOT EXECUTED
40017c6c: 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);
40017c70: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40017c74: d2 0f 20 02 ldub [ %i4 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40017c78: 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);
40017c7c: 93 30 40 09 srl %g1, %o1, %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40017c80: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
40017c84: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40017c88: 92 00 80 09 add %g2, %o1, %o1 <== NOT EXECUTED
40017c8c: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
40017c90: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
40017c94: 7f ff ee 2e call 4001354c <_fat_block_read> <== NOT EXECUTED
40017c98: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
40017c9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017ca0: 06 bf ff c3 bl 40017bac <msdos_creat_node+0x98> <== NOT EXECUTED
40017ca4: 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);
40017ca8: c2 2f bf 8d stb %g1, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40017cac: c2 17 bf ae lduh [ %fp + -82 ], %g1 <== NOT EXECUTED
40017cb0: c2 37 bf 8e sth %g1, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
40017cb4: c2 17 bf b0 lduh [ %fp + -80 ], %g1 <== NOT EXECUTED
40017cb8: 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);
40017cbc: c2 07 bf bc ld [ %fp + -68 ], %g1 <== NOT EXECUTED
40017cc0: c2 27 bf 9c st %g1, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
40017cc4: c2 17 bf ba lduh [ %fp + -70 ], %g1 <== NOT EXECUTED
40017cc8: c2 37 bf 9a sth %g1, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
40017ccc: c2 17 bf b4 lduh [ %fp + -76 ], %g1 <== NOT EXECUTED
40017cd0: 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;
40017cd4: 10 80 00 02 b 40017cdc <msdos_creat_node+0x1c8> <== NOT EXECUTED
40017cd8: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40017cdc: 82 10 60 20 or %g1, 0x20, %g1
40017ce0: 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);
40017ce4: 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,
40017ce8: 90 10 00 18 mov %i0, %o0
40017cec: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
40017cf0: 92 10 20 01 mov 1, %o1
40017cf4: 94 10 00 1a mov %i2, %o2
40017cf8: 96 10 00 1b mov %i3, %o3
40017cfc: 98 10 00 12 mov %l2, %o4
40017d00: 40 00 05 fc call 400194f0 <msdos_get_name_node>
40017d04: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
40017d08: ba 92 20 00 orcc %o0, 0, %i5
40017d0c: 12 80 00 76 bne 40017ee4 <msdos_creat_node+0x3d0>
40017d10: 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)
40017d14: 32 80 00 75 bne,a 40017ee8 <msdos_creat_node+0x3d4>
40017d18: b0 10 00 1d mov %i5, %i0
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
40017d1c: 90 10 00 1c mov %i4, %o0
40017d20: 92 07 bf 70 add %fp, -144, %o1
40017d24: 7f ff ea 6c call 400126d4 <fat_file_open>
40017d28: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
40017d2c: ba 92 20 00 orcc %o0, 0, %i5
40017d30: 32 80 00 6a bne,a 40017ed8 <msdos_creat_node+0x3c4> <== NEVER TAKEN
40017d34: 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;
40017d38: fa 07 bf 6c ld [ %fp + -148 ], %i5
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40017d3c: 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,
40017d40: 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;
40017d44: 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,
40017d48: 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;
40017d4c: c0 27 60 18 clr [ %i5 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
40017d50: 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,
40017d54: 40 00 11 a1 call 4001c3d8 <memcpy>
40017d58: 90 07 bf c0 add %fp, -64, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40017d5c: 92 10 00 11 mov %l1, %o1
40017d60: 94 10 20 20 mov 0x20, %o2
40017d64: 40 00 11 9d call 4001c3d8 <memcpy>
40017d68: 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,
40017d6c: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40017d70: d2 00 60 0c ld [ %g1 + 0xc ], %o1 ! 4002c80c <MSDOS_DOT_NAME>
40017d74: 94 10 20 0b mov 0xb, %o2
40017d78: 40 00 11 98 call 4001c3d8 <memcpy>
40017d7c: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40017d80: 03 10 00 b2 sethi %hi(0x4002c800), %g1
40017d84: d2 00 60 08 ld [ %g1 + 8 ], %o1 ! 4002c808 <MSDOS_DOTDOT_NAME>
40017d88: 90 07 bf e0 add %fp, -32, %o0
40017d8c: 40 00 11 93 call 4001c3d8 <memcpy>
40017d90: 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)) &&
40017d94: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
40017d98: 80 a0 60 01 cmp %g1, 1
40017d9c: 32 80 00 0e bne,a 40017dd4 <msdos_creat_node+0x2c0>
40017da0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40017da4: c2 04 20 24 ld [ %l0 + 0x24 ], %g1
40017da8: 80 a0 60 00 cmp %g1, 0
40017dac: 32 80 00 0a bne,a 40017dd4 <msdos_creat_node+0x2c0> <== NEVER TAKEN
40017db0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
40017db4: 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)) &&
40017db8: 82 08 60 04 and %g1, 4, %g1
40017dbc: 80 88 60 ff btst 0xff, %g1
40017dc0: 22 80 00 05 be,a 40017dd4 <msdos_creat_node+0x2c0> <== ALWAYS TAKEN
40017dc4: 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;
40017dc8: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40017dcc: 10 80 00 10 b 40017e0c <msdos_creat_node+0x2f8> <== NOT EXECUTED
40017dd0: 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;
}
40017dd4: 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)) =
40017dd8: 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;
}
40017ddc: 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)) =
40017de0: 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;
}
40017de4: 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));
40017de8: 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));
40017dec: 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;
}
40017df0: 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)) =
40017df4: 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));
40017df8: 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)) =
40017dfc: 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)) =
40017e00: 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)) =
40017e04: 82 10 80 01 or %g2, %g1, %g1
40017e08: 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,
40017e0c: 90 10 00 1c mov %i4, %o0
40017e10: 92 10 00 1d mov %i5, %o1
40017e14: 94 10 20 00 clr %o2
40017e18: 96 10 20 40 mov 0x40, %o3
40017e1c: 7f ff ec 3b call 40012f08 <fat_file_write>
40017e20: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
40017e24: 80 a2 20 00 cmp %o0, 0
40017e28: 06 80 00 27 bl 40017ec4 <msdos_creat_node+0x3b0> <== NEVER TAKEN
40017e2c: 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;
40017e30: c2 17 20 06 lduh [ %i4 + 6 ], %g1
40017e34: 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,
40017e38: 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;
40017e3c: 82 00 80 01 add %g2, %g1, %g1
40017e40: 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));
40017e44: 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;
}
40017e48: 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)) =
40017e4c: 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;
}
40017e50: 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)) =
40017e54: 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;
}
40017e58: 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));
40017e5c: 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));
40017e60: 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;
}
40017e64: 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)) =
40017e68: 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));
40017e6c: 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)) =
40017e70: 83 30 60 08 srl %g1, 8, %g1
40017e74: 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)) =
40017e78: 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)) =
40017e7c: 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,
40017e80: 94 10 20 00 clr %o2
40017e84: 96 10 20 20 mov 0x20, %o3
40017e88: 7f ff ec 20 call 40012f08 <fat_file_write>
40017e8c: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
40017e90: 80 a2 20 00 cmp %o0, 0
40017e94: 06 80 00 0d bl 40017ec8 <msdos_creat_node+0x3b4> <== NEVER TAKEN
40017e98: 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);
40017e9c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40017ea0: 40 00 01 45 call 400183b4 <msdos_set_first_cluster_num>
40017ea4: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
40017ea8: ba 92 20 00 orcc %o0, 0, %i5
40017eac: 12 80 00 08 bne 40017ecc <msdos_creat_node+0x3b8> <== NEVER TAKEN
40017eb0: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
40017eb4: 7f ff eb 1e call 40012b2c <fat_file_close>
40017eb8: 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;
}
40017ebc: 81 c7 e0 08 ret
40017ec0: 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;
40017ec4: 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);
40017ec8: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
40017ecc: 7f ff eb 18 call 40012b2c <fat_file_close> <== NOT EXECUTED
40017ed0: 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);
40017ed4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
40017ed8: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
40017edc: 40 00 01 81 call 400184e0 <msdos_set_first_char4file_name><== NOT EXECUTED
40017ee0: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
return rc;
}
40017ee4: b0 10 00 1d mov %i5, %i0
40017ee8: 81 c7 e0 08 ret
40017eec: 81 e8 00 00 restore
4001ab9c <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;
4001ab9c: 85 32 60 0b srl %o1, 0xb, %g2
4001aba0: 84 08 a0 1f and %g2, 0x1f, %g2
4001aba4: 87 28 a0 03 sll %g2, 3, %g3
4001aba8: 83 28 a0 07 sll %g2, 7, %g1
4001abac: 82 20 40 03 sub %g1, %g3, %g1
4001abb0: 85 28 60 04 sll %g1, 4, %g2
4001abb4: 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
4001abb8: 82 0a 67 e0 and %o1, 0x7e0, %g1
4001abbc: 87 30 60 04 srl %g1, 4, %g3
4001abc0: 82 20 40 03 sub %g1, %g3, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001abc4: 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)
4001abc8: 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;
4001abcc: 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) {
4001abd0: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001abd4: c4 10 61 4a lduh [ %g1 + 0x14a ], %g2 ! 4002d94a <lastdosdate>
4001abd8: 80 a0 80 08 cmp %g2, %o0
4001abdc: 02 80 00 34 be 4001acac <msdos_date_dos2unix+0x110>
4001abe0: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
4001abe4: d0 30 61 4a sth %o0, [ %g1 + 0x14a ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
4001abe8: 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;
4001abec: 82 10 20 00 clr %g1
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
4001abf0: 88 09 20 7f and %g4, 0x7f, %g4
for (y = 0; y < year; y++)
4001abf4: 10 80 00 07 b 4001ac10 <msdos_date_dos2unix+0x74>
4001abf8: 84 10 20 00 clr %g2
days += y & 0x03 ? 365 : 366;
4001abfc: 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++)
4001ac00: 84 00 a0 01 inc %g2
days += y & 0x03 ? 365 : 366;
4001ac04: 86 60 3f ff subx %g0, -1, %g3
4001ac08: 86 00 e1 6d add %g3, 0x16d, %g3
4001ac0c: 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++)
4001ac10: 80 a0 80 04 cmp %g2, %g4
4001ac14: 12 bf ff fa bne 4001abfc <msdos_date_dos2unix+0x60>
4001ac18: 86 08 a0 03 and %g2, 3, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
4001ac1c: 80 a0 e0 00 cmp %g3, 0
4001ac20: 22 80 00 05 be,a 4001ac34 <msdos_date_dos2unix+0x98> <== ALWAYS TAKEN
4001ac24: 09 10 00 b4 sethi %hi(0x4002d000), %g4
4001ac28: 09 10 00 b4 sethi %hi(0x4002d000), %g4 <== NOT EXECUTED
4001ac2c: 10 80 00 03 b 4001ac38 <msdos_date_dos2unix+0x9c> <== NOT EXECUTED
4001ac30: 88 11 21 78 or %g4, 0x178, %g4 ! 4002d178 <regyear> <== NOT EXECUTED
4001ac34: 88 11 21 90 or %g4, 0x190, %g4
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
4001ac38: 86 0a 21 e0 and %o0, 0x1e0, %g3
4001ac3c: 87 30 e0 05 srl %g3, 5, %g3
if (month == 0) {
4001ac40: 80 a0 e0 00 cmp %g3, 0
4001ac44: 22 80 00 02 be,a 4001ac4c <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
4001ac48: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
4001ac4c: 84 10 20 00 clr %g2
4001ac50: 10 80 00 05 b 4001ac64 <msdos_date_dos2unix+0xc8>
4001ac54: 86 00 ff ff add %g3, -1, %g3
days += months[m];
4001ac58: 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++)
4001ac5c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
days += months[m];
4001ac60: 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++)
4001ac64: 80 a0 80 03 cmp %g2, %g3
4001ac68: 0a bf ff fc bcs 4001ac58 <msdos_date_dos2unix+0xbc> <== NEVER TAKEN
4001ac6c: 9b 28 a0 01 sll %g2, 1, %o5
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
4001ac70: 90 0a 20 1f and %o0, 0x1f, %o0
4001ac74: 90 02 3f ff add %o0, -1, %o0
4001ac78: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
4001ac7c: 85 28 60 07 sll %g1, 7, %g2
4001ac80: 83 28 60 09 sll %g1, 9, %g1
4001ac84: 82 20 40 02 sub %g1, %g2, %g1
4001ac88: 85 28 60 04 sll %g1, 4, %g2
4001ac8c: 82 20 80 01 sub %g2, %g1, %g1
4001ac90: 85 28 60 04 sll %g1, 4, %g2
4001ac94: 82 20 80 01 sub %g2, %g1, %g1
4001ac98: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
4001ac9c: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_SIZE+0x128ea600>
4001aca0: 82 00 40 02 add %g1, %g2, %g1
4001aca4: 05 10 00 b6 sethi %hi(0x4002d800), %g2
4001aca8: c2 20 a1 4c st %g1, [ %g2 + 0x14c ] ! 4002d94c <lastseconds>
}
return seconds + lastseconds;
4001acac: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001acb0: d0 00 61 4c ld [ %g1 + 0x14c ], %o0 ! 4002d94c <lastseconds>
}
4001acb4: 81 c3 e0 08 retl
4001acb8: 90 02 40 08 add %o1, %o0, %o0
4001aa50 <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)
{
4001aa50: 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) {
4001aa54: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001aa58: c4 00 61 3c ld [ %g1 + 0x13c ], %g2 ! 4002d93c <lasttime>
4001aa5c: 80 a0 80 18 cmp %g2, %i0
4001aa60: 02 80 00 47 be 4001ab7c <msdos_date_unix2dos+0x12c>
4001aa64: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
4001aa68: f0 20 61 3c st %i0, [ %g1 + 0x13c ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
4001aa6c: 7f ff 9f 33 call 40002738 <.udiv>
4001aa70: 90 10 00 18 mov %i0, %o0
4001aa74: 40 00 38 30 call 40028b34 <.urem>
4001aa78: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
4001aa7c: 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)
4001aa80: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
4001aa84: 7f ff 9f 2d call 40002738 <.udiv>
4001aa88: 90 10 00 18 mov %i0, %o0
4001aa8c: 40 00 38 2a call 40028b34 <.urem>
4001aa90: 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)
4001aa94: 91 2a 20 0b sll %o0, 0xb, %o0
4001aa98: 92 10 20 3c mov 0x3c, %o1
4001aa9c: ba 07 40 08 add %i5, %o0, %i5
4001aaa0: 40 00 38 25 call 40028b34 <.urem>
4001aaa4: 90 10 00 18 mov %i0, %o0
4001aaa8: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001aaac: 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);
4001aab0: 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)
4001aab4: 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);
4001aab8: 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)
4001aabc: fa 30 61 40 sth %i5, [ %g1 + 0x140 ]
/*
* 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);
4001aac0: 7f ff 9f 1e call 40002738 <.udiv>
4001aac4: 90 10 00 18 mov %i0, %o0
if (days != lastday) {
4001aac8: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001aacc: c4 00 61 44 ld [ %g1 + 0x144 ], %g2 ! 4002d944 <lastday>
4001aad0: 80 a2 00 02 cmp %o0, %g2
4001aad4: 22 80 00 2b be,a 4001ab80 <msdos_date_unix2dos+0x130>
4001aad8: 03 10 00 b6 sethi %hi(0x4002d800), %g1
lastday = days;
4001aadc: d0 20 61 44 st %o0, [ %g1 + 0x144 ] ! 4002d944 <lastday>
for (year = 1970;; year++) {
4001aae0: 82 10 27 b2 mov 0x7b2, %g1
inc = year & 0x03 ? 365 : 366;
4001aae4: 84 08 60 03 and %g1, 3, %g2
4001aae8: 80 a0 00 02 cmp %g0, %g2
4001aaec: 86 60 3f ff subx %g0, -1, %g3
4001aaf0: 86 00 e1 6d add %g3, 0x16d, %g3
if (days < inc)
4001aaf4: 80 a2 00 03 cmp %o0, %g3
4001aaf8: 0a 80 00 05 bcs 4001ab0c <msdos_date_unix2dos+0xbc>
4001aafc: 80 a0 a0 00 cmp %g2, 0
break;
days -= inc;
4001ab00: 90 22 00 03 sub %o0, %g3, %o0
}
4001ab04: 10 bf ff f8 b 4001aae4 <msdos_date_unix2dos+0x94>
4001ab08: 82 00 60 01 inc %g1
months = year & 0x03 ? regyear : leapyear;
4001ab0c: 22 80 00 05 be,a 4001ab20 <msdos_date_unix2dos+0xd0> <== ALWAYS TAKEN
4001ab10: 09 10 00 b4 sethi %hi(0x4002d000), %g4
4001ab14: 09 10 00 b4 sethi %hi(0x4002d000), %g4 <== NOT EXECUTED
4001ab18: 10 80 00 03 b 4001ab24 <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
4001ab1c: 88 11 21 78 or %g4, 0x178, %g4 ! 4002d178 <regyear> <== NOT EXECUTED
4001ab20: 88 11 21 90 or %g4, 0x190, %g4
for (month = 0; month < 12; month++) {
4001ab24: 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,
4001ab28: 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])
4001ab2c: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
4001ab30: 80 a2 00 03 cmp %o0, %g3
4001ab34: 2a 80 00 07 bcs,a 4001ab50 <msdos_date_unix2dos+0x100> <== ALWAYS TAKEN
4001ab38: 90 02 20 01 inc %o0
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
4001ab3c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001ab40: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
4001ab44: 12 bf ff f9 bne 4001ab28 <msdos_date_unix2dos+0xd8> <== NOT EXECUTED
4001ab48: 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)
4001ab4c: 90 02 20 01 inc %o0 <== NOT EXECUTED
4001ab50: 84 00 a0 01 inc %g2
4001ab54: 07 10 00 b6 sethi %hi(0x4002d800), %g3
4001ab58: 85 28 a0 05 sll %g2, 5, %g2
4001ab5c: 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)
4001ab60: 80 a0 67 bc cmp %g1, 0x7bc
4001ab64: 08 80 00 06 bleu 4001ab7c <msdos_date_unix2dos+0x12c> <== NEVER TAKEN
4001ab68: d0 30 e1 48 sth %o0, [ %g3 + 0x148 ]
lastddate += (year - 1980) <<
4001ab6c: 82 00 78 44 add %g1, -1980, %g1
4001ab70: 83 28 60 09 sll %g1, 9, %g1
4001ab74: 90 02 00 01 add %o0, %g1, %o0
4001ab78: d0 30 e1 48 sth %o0, [ %g3 + 0x148 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001ab7c: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001ab80: c2 10 61 40 lduh [ %g1 + 0x140 ], %g1 ! 4002d940 <lastdtime>
4001ab84: c2 36 80 00 sth %g1, [ %i2 ]
*ddp = lastddate;
4001ab88: 03 10 00 b6 sethi %hi(0x4002d800), %g1
4001ab8c: c2 10 61 48 lduh [ %g1 + 0x148 ], %g1 ! 4002d948 <lastddate>
4001ab90: c2 36 40 00 sth %g1, [ %i1 ]
4001ab94: 81 c7 e0 08 ret
4001ab98: 81 e8 00 00 restore
40018614 <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
)
{
40018614: 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,
40018618: 23 10 00 b1 sethi %hi(0x4002c400), %l1
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
4001861c: 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)),
40018620: 25 10 00 b1 sethi %hi(0x4002c400), %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;
40018624: 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;
40018628: 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,
4001862c: a2 14 63 c8 or %l1, 0x3c8, %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,
40018630: 10 80 00 33 b 400186fc <msdos_dir_is_empty+0xe8>
40018634: a4 14 a3 d8 or %l2, 0x3d8, %l2
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40018638: 04 80 00 2a ble 400186e0 <msdos_dir_is_empty+0xcc> <== NEVER TAKEN
4001863c: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
40018640: c2 17 40 00 lduh [ %i5 ], %g1
40018644: 80 a2 00 01 cmp %o0, %g1
40018648: 02 80 00 28 be 400186e8 <msdos_dir_is_empty+0xd4> <== ALWAYS TAKEN
4001864c: b8 10 20 00 clr %i4
40018650: 11 10 00 b1 sethi %hi(0x4002c400), %o0 <== NOT EXECUTED
40018654: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
40018658: 17 10 00 b1 sethi %hi(0x4002c400), %o3 <== NOT EXECUTED
4001865c: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
40018660: 92 10 23 65 mov 0x365, %o1 <== NOT EXECUTED
40018664: 94 12 a0 10 or %o2, 0x10, %o2 <== NOT EXECUTED
40018668: 7f ff b4 d6 call 400059c0 <__assert_func> <== NOT EXECUTED
4001866c: 96 12 e3 a8 or %o3, 0x3a8, %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)) ==
40018670: e0 08 40 1c ldub [ %g1 + %i4 ], %l0
40018674: 80 a4 20 e5 cmp %l0, 0xe5
40018678: 02 80 00 14 be 400186c8 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
4001867c: b0 00 40 1c add %g1, %i4, %i0
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40018680: 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) ||
40018684: 82 08 60 3f and %g1, 0x3f, %g1
40018688: 80 a0 60 0f cmp %g1, 0xf
4001868c: 02 80 00 0f be 400186c8 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
40018690: 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,
40018694: 92 10 00 11 mov %l1, %o1
40018698: 40 00 13 c2 call 4001d5a0 <strncmp>
4001869c: 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) ||
400186a0: 80 a2 20 00 cmp %o0, 0
400186a4: 22 80 00 12 be,a 400186ec <msdos_dir_is_empty+0xd8>
400186a8: 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)),
400186ac: 90 10 00 18 mov %i0, %o0
400186b0: 92 10 00 12 mov %l2, %o1
400186b4: 40 00 13 bb call 4001d5a0 <strncmp>
400186b8: 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) ||
400186bc: 80 a2 20 00 cmp %o0, 0
400186c0: 12 80 00 04 bne 400186d0 <msdos_dir_is_empty+0xbc>
400186c4: 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)
400186c8: 10 80 00 09 b 400186ec <msdos_dir_is_empty+0xd8>
400186cc: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
400186d0: 12 80 00 04 bne 400186e0 <msdos_dir_is_empty+0xcc>
400186d4: b0 10 20 00 clr %i0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
400186d8: 82 10 20 01 mov 1, %g1
400186dc: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
400186e0: 81 c7 e0 08 ret
400186e4: 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;
400186e8: 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;
400186ec: 80 a7 00 13 cmp %i4, %l3
400186f0: 2a bf ff e0 bcs,a 40018670 <msdos_dir_is_empty+0x5c> <== ALWAYS TAKEN
400186f4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
400186f8: 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,
400186fc: f8 17 40 00 lduh [ %i5 ], %i4
40018700: 90 10 00 1b mov %i3, %o0
40018704: 7f ff a7 d3 call 40002650 <.umul>
40018708: 92 10 00 1c mov %i4, %o1
4001870c: d8 07 60 a0 ld [ %i5 + 0xa0 ], %o4
40018710: 94 10 00 08 mov %o0, %o2
40018714: 92 10 00 19 mov %i1, %o1
40018718: 90 10 00 1d mov %i5, %o0
4001871c: 7f ff e8 51 call 40012860 <fat_file_read>
40018720: 96 10 00 1c mov %i4, %o3
40018724: 80 a2 20 00 cmp %o0, 0
40018728: 32 bf ff c4 bne,a 40018638 <msdos_dir_is_empty+0x24> <== ALWAYS TAKEN
4001872c: 80 a2 20 1f cmp %o0, 0x1f
*/
return RC_OK;
}
j++;
}
*ret_val = true;
40018730: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40018734: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED
40018738: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
4001873c: 81 c7 e0 08 ret <== NOT EXECUTED
40018740: 81 e8 00 00 restore <== NOT EXECUTED
4001ae38 <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)
{
4001ae38: 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;
4001ae3c: 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);
4001ae40: 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;
4001ae44: 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);
4001ae48: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001ae4c: 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)
{
4001ae50: 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;
4001ae54: 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);
4001ae58: 7f ff 9d 13 call 400022a4 <__divdi3> <== NOT EXECUTED
4001ae5c: 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;
4001ae60: 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);
4001ae64: a6 10 00 09 mov %o1, %l3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001ae68: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001ae6c: 7f ff 9e 33 call 40002738 <.udiv> <== NOT EXECUTED
4001ae70: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
4001ae74: a5 2a 20 03 sll %o0, 3, %l2 <== NOT EXECUTED
4001ae78: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
4001ae7c: a4 04 80 08 add %l2, %o0, %l2 <== NOT EXECUTED
4001ae80: 85 2c a0 03 sll %l2, 3, %g2 <== NOT EXECUTED
4001ae84: 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 :
4001ae88: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
4001ae8c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
4001ae90: 32 80 00 0b bne,a 4001aebc <msdos_dir_read+0x84> <== NOT EXECUTED
4001ae94: 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) &&
4001ae98: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
4001ae9c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001aea0: 32 80 00 07 bne,a 4001aebc <msdos_dir_read+0x84> <== NOT EXECUTED
4001aea4: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
4001aea8: 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) &&
4001aeac: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
4001aeb0: 22 80 00 03 be,a 4001aebc <msdos_dir_read+0x84> <== NOT EXECUTED
4001aeb4: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
4001aeb8: 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,
4001aebc: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
4001aec0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001aec4: 7f ff bc 46 call 40009fdc <rtems_semaphore_obtain> <== NOT EXECUTED
4001aec8: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001aecc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001aed0: 22 80 00 fe be,a 4001b2c8 <msdos_dir_read+0x490> <== NOT EXECUTED
4001aed4: a2 10 20 00 clr %l1 <== NOT EXECUTED
4001aed8: 30 80 00 0b b,a 4001af04 <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),
4001aedc: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
4001aee0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001aee4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4001aee8: 7f ff de 5e call 40012860 <fat_file_read> <== NOT EXECUTED
4001aeec: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001aef0: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
4001aef4: 14 80 00 ee bg 4001b2ac <msdos_dir_read+0x474> <== NOT EXECUTED
4001aef8: d0 27 be cc st %o0, [ %fp + -308 ] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
4001aefc: 7f ff bc 81 call 4000a100 <rtems_semaphore_release> <== NOT EXECUTED
4001af00: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4001af04: 40 00 02 90 call 4001b944 <__errno> <== NOT EXECUTED
4001af08: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001af0c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001af10: 10 80 01 07 b 4001b32c <msdos_dir_read+0x4f4> <== NOT EXECUTED
4001af14: 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;
4001af18: ae 00 c0 1c add %g3, %i4, %l7 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001af1c: c6 08 c0 1c ldub [ %g3 + %i4 ], %g3 <== NOT EXECUTED
4001af20: 88 88 e0 ff andcc %g3, 0xff, %g4 <== NOT EXECUTED
4001af24: 12 80 00 04 bne 4001af34 <msdos_dir_read+0xfc> <== NOT EXECUTED
4001af28: 80 a1 20 e5 cmp %g4, 0xe5 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
4001af2c: 10 80 00 ef b 4001b2e8 <msdos_dir_read+0x4b0> <== NOT EXECUTED
4001af30: 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)
4001af34: 22 80 00 df be,a 4001b2b0 <msdos_dir_read+0x478> <== NOT EXECUTED
4001af38: 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) &&
4001af3c: c8 0d e0 0b ldub [ %l7 + 0xb ], %g4 <== NOT EXECUTED
4001af40: 9e 09 20 08 and %g4, 8, %o7 <== NOT EXECUTED
4001af44: 80 8b e0 ff btst 0xff, %o7 <== NOT EXECUTED
4001af48: 22 80 00 07 be,a 4001af64 <msdos_dir_read+0x12c> <== NOT EXECUTED
4001af4c: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
4001af50: 9e 09 20 3f and %g4, 0x3f, %o7 <== NOT EXECUTED
4001af54: 80 a3 e0 0f cmp %o7, 0xf <== NOT EXECUTED
4001af58: 32 80 00 d6 bne,a 4001b2b0 <msdos_dir_read+0x478> <== NOT EXECUTED
4001af5c: 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) ==
4001af60: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
4001af64: 80 a1 20 0f cmp %g4, 0xf <== NOT EXECUTED
4001af68: 12 80 00 3e bne 4001b060 <msdos_dir_read+0x228> <== NOT EXECUTED
4001af6c: 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)
4001af70: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
4001af74: 32 80 00 0f bne,a 4001afb0 <msdos_dir_read+0x178> <== NOT EXECUTED
4001af78: 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) &
4001af7c: 88 08 e0 40 and %g3, 0x40, %g4 <== NOT EXECUTED
4001af80: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
4001af84: 22 80 00 cb be,a 4001b2b0 <msdos_dir_read+0x478> <== NOT EXECUTED
4001af88: 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)
4001af8c: 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) &
4001af90: ba 08 e0 3f and %g3, 0x3f, %i5 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
4001af94: 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);
4001af98: e8 0d e0 0d ldub [ %l7 + 0xd ], %l4 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
4001af9c: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001afa0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001afa4: 40 00 05 4a call 4001c4cc <memset> <== NOT EXECUTED
4001afa8: 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) &
4001afac: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
4001afb0: 86 08 e0 3f and %g3, 0x3f, %g3 <== NOT EXECUTED
4001afb4: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
4001afb8: 32 80 00 bb bne,a 4001b2a4 <msdos_dir_read+0x46c> <== NOT EXECUTED
4001afbc: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
4001afc0: c6 0d e0 0d ldub [ %l7 + 0xd ], %g3 <== NOT EXECUTED
4001afc4: 88 0d 20 ff and %l4, 0xff, %g4 <== NOT EXECUTED
4001afc8: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
4001afcc: 32 80 00 b6 bne,a 4001b2a4 <msdos_dir_read+0x46c> <== NOT EXECUTED
4001afd0: 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--;
4001afd4: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001afd8: 87 2f 60 02 sll %i5, 2, %g3 <== NOT EXECUTED
4001afdc: 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)
4001afe0: 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;
4001afe4: 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;
4001afe8: 84 05 e0 01 add %l7, 1, %g2 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001afec: 88 01 00 1d add %g4, %i5, %g4 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
4001aff0: 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)
4001aff4: 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))
4001aff8: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
4001affc: 80 a3 60 fe cmp %o5, 0xfe <== NOT EXECUTED
4001b000: 18 80 00 a3 bgu 4001b28c <msdos_dir_read+0x454> <== NOT EXECUTED
4001b004: 9a 03 c0 03 add %o7, %g3, %o5 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
4001b008: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
4001b00c: d8 2b 60 14 stb %o4, [ %o5 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
4001b010: da 48 80 00 ldsb [ %g2 ], %o5 <== NOT EXECUTED
4001b014: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
4001b018: 02 80 00 9d be 4001b28c <msdos_dir_read+0x454> <== NOT EXECUTED
4001b01c: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
break;
switch (q)
4001b020: 02 80 00 06 be 4001b038 <msdos_dir_read+0x200> <== NOT EXECUTED
4001b024: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
4001b028: 32 80 00 08 bne,a 4001b048 <msdos_dir_read+0x210> <== NOT EXECUTED
4001b02c: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
4001b030: 10 80 00 04 b 4001b040 <msdos_dir_read+0x208> <== NOT EXECUTED
4001b034: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED
switch (q)
{
case 4:
p += 5;
break;
4001b038: 10 80 00 04 b 4001b048 <msdos_dir_read+0x210> <== NOT EXECUTED
4001b03c: 84 00 a0 05 add %g2, 5, %g2 <== NOT EXECUTED
case 10:
p += 4;
break;
4001b040: 10 80 00 03 b 4001b04c <msdos_dir_read+0x214> <== NOT EXECUTED
4001b044: 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++)
4001b048: 86 00 e0 01 inc %g3 <== NOT EXECUTED
4001b04c: 80 a0 e0 0d cmp %g3, 0xd <== NOT EXECUTED
4001b050: 12 bf ff eb bne 4001affc <msdos_dir_read+0x1c4> <== NOT EXECUTED
4001b054: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
4001b058: 10 80 00 8e b 4001b290 <msdos_dir_read+0x458> <== NOT EXECUTED
4001b05c: 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)
4001b060: 02 80 00 04 be 4001b070 <msdos_dir_read+0x238> <== NOT EXECUTED
4001b064: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
4001b068: 10 80 00 8e b 4001b2a0 <msdos_dir_read+0x468> <== NOT EXECUTED
4001b06c: 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,
4001b070: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001b074: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001b078: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001b07c: 7f ff de d9 call 40012be0 <fat_file_ioctl> <== NOT EXECUTED
4001b080: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
4001b084: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001b088: 12 80 00 7d bne 4001b27c <msdos_dir_read+0x444> <== NOT EXECUTED
4001b08c: 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;
4001b090: 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;
4001b094: c6 27 be d8 st %g3, [ %fp + -296 ] <== NOT EXECUTED
4001b098: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001b09c: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
4001b0a0: f8 27 be dc st %i4, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
4001b0a4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
4001b0a8: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
4001b0ac: 7f ff dd 8a call 400126d4 <fat_file_open> <== NOT EXECUTED
4001b0b0: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
4001b0b4: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001b0b8: 12 80 00 71 bne 4001b27c <msdos_dir_read+0x444> <== NOT EXECUTED
4001b0bc: 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);
4001b0c0: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
4001b0c4: 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;
4001b0c8: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
4001b0cc: f4 27 be f4 st %i2, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
4001b0d0: 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)
4001b0d4: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
4001b0d8: 02 80 00 1d be 4001b14c <msdos_dir_read+0x314> <== NOT EXECUTED
4001b0dc: c6 27 be e8 st %g3, [ %fp + -280 ] <== NOT EXECUTED
4001b0e0: 88 10 20 00 clr %g4 <== NOT EXECUTED
4001b0e4: 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;
4001b0e8: da 0d c0 04 ldub [ %l7 + %g4 ], %o5 <== NOT EXECUTED
4001b0ec: 9e 08 e0 01 and %g3, 1, %o7 <== NOT EXECUTED
4001b0f0: 80 a0 00 0f cmp %g0, %o7 <== NOT EXECUTED
4001b0f4: 86 08 e0 ff and %g3, 0xff, %g3 <== NOT EXECUTED
4001b0f8: 9e 40 3f ff addx %g0, -1, %o7 <== NOT EXECUTED
4001b0fc: 87 30 e0 01 srl %g3, 1, %g3 <== NOT EXECUTED
4001b100: 9e 0b e0 80 and %o7, 0x80, %o7 <== NOT EXECUTED
4001b104: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
4001b108: 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++)
4001b10c: 88 01 20 01 inc %g4 <== NOT EXECUTED
4001b110: 80 a1 20 0b cmp %g4, 0xb <== NOT EXECUTED
4001b114: 12 bf ff f5 bne 4001b0e8 <msdos_dir_read+0x2b0> <== NOT EXECUTED
4001b118: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
4001b11c: 86 18 c0 14 xor %g3, %l4, %g3 <== NOT EXECUTED
4001b120: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
4001b124: 12 80 00 0b bne 4001b150 <msdos_dir_read+0x318> <== NOT EXECUTED
4001b128: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
4001b12c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4001b130: 12 80 00 09 bne 4001b154 <msdos_dir_read+0x31c> <== NOT EXECUTED
4001b134: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
4001b138: 30 80 00 70 b,a 4001b2f8 <msdos_dir_read+0x4c0> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001b13c: 32 80 00 06 bne,a 4001b154 <msdos_dir_read+0x31c> <== NOT EXECUTED
4001b140: 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++));
4001b144: 10 80 00 09 b 4001b168 <msdos_dir_read+0x330> <== NOT EXECUTED
4001b148: 03 10 00 b4 sethi %hi(0x4002d000), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001b14c: 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)
4001b150: 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) &&
4001b154: c8 49 3f ff ldsb [ %g4 + -1 ], %g4 <== NOT EXECUTED
4001b158: 80 a1 20 20 cmp %g4, 0x20 <== NOT EXECUTED
4001b15c: 22 bf ff f8 be,a 4001b13c <msdos_dir_read+0x304> <== NOT EXECUTED
4001b160: 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++));
4001b164: 03 10 00 b4 sethi %hi(0x4002d000), %g1 <== NOT EXECUTED
4001b168: b6 10 20 00 clr %i3 <== NOT EXECUTED
4001b16c: da 00 61 a8 ld [ %g1 + 0x1a8 ], %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(
4001b170: 10 80 00 0b b 4001b19c <msdos_dir_read+0x364> <== NOT EXECUTED
4001b174: 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++));
4001b178: 98 03 40 0f add %o5, %o7, %o4 <== NOT EXECUTED
4001b17c: d8 0b 20 01 ldub [ %o4 + 1 ], %o4 <== NOT EXECUTED
4001b180: 98 0b 20 03 and %o4, 3, %o4 <== NOT EXECUTED
4001b184: 80 a3 20 01 cmp %o4, 1 <== NOT EXECUTED
4001b188: 22 80 00 02 be,a 4001b190 <msdos_dir_read+0x358> <== NOT EXECUTED
4001b18c: 9e 03 e0 20 add %o7, 0x20, %o7 <== NOT EXECUTED
4001b190: de 29 00 00 stb %o7, [ %g4 ] <== NOT EXECUTED
4001b194: b6 06 e0 01 inc %i3 <== NOT EXECUTED
4001b198: 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)
4001b19c: 9e 20 c0 1b sub %g3, %i3, %o7 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
4001b1a0: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
4001b1a4: 34 bf ff f5 bg,a 4001b178 <msdos_dir_read+0x340> <== NOT EXECUTED
4001b1a8: 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) &&
4001b1ac: f6 4d e0 0a ldsb [ %l7 + 0xa ], %i3 <== NOT EXECUTED
4001b1b0: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
4001b1b4: 12 80 00 55 bne 4001b308 <msdos_dir_read+0x4d0> <== NOT EXECUTED
4001b1b8: b6 10 20 03 mov 3, %i3 <== NOT EXECUTED
4001b1bc: f6 4d e0 09 ldsb [ %l7 + 9 ], %i3 <== NOT EXECUTED
4001b1c0: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
4001b1c4: 12 80 00 51 bne 4001b308 <msdos_dir_read+0x4d0> <== NOT EXECUTED
4001b1c8: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED
4001b1cc: f6 4d e0 08 ldsb [ %l7 + 8 ], %i3 <== NOT EXECUTED
4001b1d0: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
4001b1d4: 22 80 00 18 be,a 4001b234 <msdos_dir_read+0x3fc> <== NOT EXECUTED
4001b1d8: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
4001b1dc: 10 80 00 4b b 4001b308 <msdos_dir_read+0x4d0> <== NOT EXECUTED
4001b1e0: 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++));
4001b1e4: da 0b 60 08 ldub [ %o5 + 8 ], %o5 <== NOT EXECUTED
4001b1e8: 94 03 00 0d add %o4, %o5, %o2 <== NOT EXECUTED
4001b1ec: d4 0a a0 01 ldub [ %o2 + 1 ], %o2 <== NOT EXECUTED
4001b1f0: 94 0a a0 03 and %o2, 3, %o2 <== NOT EXECUTED
4001b1f4: 80 a2 a0 01 cmp %o2, 1 <== NOT EXECUTED
4001b1f8: 22 80 00 02 be,a 4001b200 <msdos_dir_read+0x3c8> <== NOT EXECUTED
4001b1fc: 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)
4001b200: 94 01 00 0f add %g4, %o7, %o2 <== NOT EXECUTED
4001b204: 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++));
4001b208: 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)
4001b20c: 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) {
4001b210: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
4001b214: 14 bf ff f4 bg 4001b1e4 <msdos_dir_read+0x3ac> <== NOT EXECUTED
4001b218: 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)
4001b21c: 84 38 00 1b xnor %g0, %i3, %g2 <== NOT EXECUTED
4001b220: 85 38 a0 1f sra %g2, 0x1f, %g2 <== NOT EXECUTED
4001b224: b6 0e c0 02 and %i3, %g2, %i3 <== NOT EXECUTED
4001b228: 88 02 c0 1b add %o3, %i3, %g4 <== NOT EXECUTED
4001b22c: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
4001b230: 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(
4001b234: c6 37 be fa sth %g3, [ %fp + -262 ] <== NOT EXECUTED
4001b238: 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));
4001b23c: c2 07 a0 48 ld [ %fp + 0x48 ], %g1 <== NOT EXECUTED
4001b240: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
4001b244: 90 00 40 1a add %g1, %i2, %o0 <== NOT EXECUTED
4001b248: 40 00 04 64 call 4001c3d8 <memcpy> <== NOT EXECUTED
4001b24c: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
4001b250: 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);
4001b254: 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);
4001b258: 9a 80 e1 18 addcc %g3, 0x118, %o5 <== NOT EXECUTED
4001b25c: 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);
4001b260: 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);
4001b264: 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);
4001b268: 7f ff de 31 call 40012b2c <fat_file_close> <== NOT EXECUTED
4001b26c: b4 06 a1 18 add %i2, 0x118, %i2 <== NOT EXECUTED
if (rc != RC_OK)
4001b270: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001b274: 02 80 00 06 be 4001b28c <msdos_dir_read+0x454> <== NOT EXECUTED
4001b278: a4 04 be e8 add %l2, -280, %l2 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
4001b27c: 7f ff bb a1 call 4000a100 <rtems_semaphore_release> <== NOT EXECUTED
4001b280: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
4001b284: 81 c7 e0 08 ret <== NOT EXECUTED
4001b288: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
4001b28c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001b290: 32 80 00 08 bne,a 4001b2b0 <msdos_dir_read+0x478> <== NOT EXECUTED
4001b294: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
4001b298: 10 80 00 10 b 4001b2d8 <msdos_dir_read+0x4a0> <== NOT EXECUTED
4001b29c: 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;
4001b2a0: 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)
4001b2a4: 10 80 00 03 b 4001b2b0 <msdos_dir_read+0x478> <== NOT EXECUTED
4001b2a8: 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)
4001b2ac: 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)
4001b2b0: c2 07 be cc ld [ %fp + -308 ], %g1 <== NOT EXECUTED
4001b2b4: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
4001b2b8: 2a bf ff 18 bcs,a 4001af18 <msdos_dir_read+0xe0> <== NOT EXECUTED
4001b2bc: c6 05 a0 a0 ld [ %l6 + 0xa0 ], %g3 <== NOT EXECUTED
4001b2c0: 10 80 00 06 b 4001b2d8 <msdos_dir_read+0x4a0> <== NOT EXECUTED
4001b2c4: 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)
4001b2c8: ba 10 20 00 clr %i5 <== NOT EXECUTED
4001b2cc: a8 10 20 00 clr %l4 <== NOT EXECUTED
4001b2d0: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
4001b2d4: b4 10 20 00 clr %i2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
4001b2d8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001b2dc: 32 bf ff 00 bne,a 4001aedc <msdos_dir_read+0xa4> <== NOT EXECUTED
4001b2e0: d8 05 a0 a0 ld [ %l6 + 0xa0 ], %o4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
4001b2e4: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
4001b2e8: 7f ff bb 86 call 4000a100 <rtems_semaphore_release> <== NOT EXECUTED
4001b2ec: b2 10 00 1a mov %i2, %i1 <== NOT EXECUTED
return cmpltd;
}
4001b2f0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b2f4: 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);
4001b2f8: 40 00 08 78 call 4001d4d8 <strlen> <== NOT EXECUTED
4001b2fc: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001b300: 10 bf ff cf b 4001b23c <msdos_dir_read+0x404> <== NOT EXECUTED
4001b304: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001b308: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
4001b30c: 9e 06 e0 01 add %i3, 1, %o7 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001b310: c2 29 00 00 stb %g1, [ %g4 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
4001b314: 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++));
4001b318: 03 10 00 b4 sethi %hi(0x4002d000), %g1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001b31c: 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++));
4001b320: d8 00 61 a8 ld [ %g1 + 0x1a8 ], %o4 <== NOT EXECUTED
4001b324: 10 bf ff ba b 4001b20c <msdos_dir_read+0x3d4> <== NOT EXECUTED
4001b328: 9e 10 20 00 clr %o7 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
4001b32c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
4001b330: 81 c7 e0 08 ret <== NOT EXECUTED
4001b334: 81 e8 00 00 restore <== NOT EXECUTED
4001b338 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001b338: 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;
4001b33c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001b340: 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;
4001b344: 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,
4001b348: 92 10 20 00 clr %o1
4001b34c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001b350: 7f ff bb 23 call 40009fdc <rtems_semaphore_obtain>
4001b354: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b358: 80 a2 20 00 cmp %o0, 0
4001b35c: 22 80 00 08 be,a 4001b37c <msdos_dir_stat+0x44> <== ALWAYS TAKEN
4001b360: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
4001b364: 40 00 01 78 call 4001b944 <__errno> <== NOT EXECUTED
4001b368: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b36c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b370: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b374: 81 c7 e0 08 ret <== NOT EXECUTED
4001b378: 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);
4001b37c: 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);
4001b380: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
4001b384: 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);
4001b388: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
4001b38c: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
4001b390: 03 00 00 10 sethi %hi(0x4000), %g1
4001b394: 82 10 61 ff or %g1, 0x1ff, %g1 ! 41ff <PROM_START+0x41ff>
4001b398: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001b39c: 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;
4001b3a0: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
4001b3a4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
4001b3a8: 83 30 60 09 srl %g1, 9, %g1
4001b3ac: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
4001b3b0: 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;
4001b3b4: 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;
4001b3b8: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001b3bc: 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;
4001b3c0: 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;
4001b3c4: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
4001b3c8: 7f ff bb 4e call 4000a100 <rtems_semaphore_release>
4001b3cc: b0 10 20 00 clr %i0
return RC_OK;
}
4001b3d0: 81 c7 e0 08 ret
4001b3d4: 81 e8 00 00 restore
40017f04 <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40017f04: 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] == '.';
40017f08: 82 10 20 00 clr %g1
40017f0c: 80 a6 e0 01 cmp %i3, 1
40017f10: 12 80 00 06 bne 40017f28 <msdos_eval_token+0x24>
40017f14: ba 10 00 18 mov %i0, %i5
40017f18: c2 4e 80 00 ldsb [ %i2 ], %g1
40017f1c: 82 18 60 2e xor %g1, 0x2e, %g1
40017f20: 80 a0 00 01 cmp %g0, %g1
40017f24: 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)) {
40017f28: 80 a0 60 00 cmp %g1, 0
40017f2c: 02 80 00 05 be 40017f40 <msdos_eval_token+0x3c>
40017f30: 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;
40017f34: c0 27 60 0c clr [ %i5 + 0xc ]
40017f38: 81 c7 e0 08 ret
40017f3c: 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);
40017f40: 90 07 60 18 add %i5, 0x18, %o0
40017f44: 92 10 00 1a mov %i2, %o1
40017f48: 40 00 05 aa call 400195f0 <msdos_find_name>
40017f4c: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
40017f50: 80 a2 20 00 cmp %o0, 0
40017f54: 12 80 00 12 bne 40017f9c <msdos_eval_token+0x98>
40017f58: 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)
40017f5c: 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;
40017f60: 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)
40017f64: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
40017f68: c0 27 60 0c clr [ %i5 + 0xc ]
40017f6c: 80 a0 a0 00 cmp %g2, 0
40017f70: 12 80 00 04 bne 40017f80 <msdos_eval_token+0x7c>
40017f74: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
40017f78: 10 80 00 03 b 40017f84 <msdos_eval_token+0x80>
40017f7c: c2 00 60 94 ld [ %g1 + 0x94 ], %g1
else
loc->handlers = fs_info->file_handlers;
40017f80: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
40017f84: 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)) {
40017f88: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40017f8c: 80 a0 00 01 cmp %g0, %g1
40017f90: b0 60 3f ff subx %g0, -1, %i0
40017f94: 81 c7 e0 08 ret
40017f98: 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) {
40017f9c: 82 10 61 01 or %g1, 0x101, %g1
40017fa0: 80 a2 00 01 cmp %o0, %g1
40017fa4: 02 bf ff e5 be 40017f38 <msdos_eval_token+0x34> <== ALWAYS TAKEN
40017fa8: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
40017fac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40017fb0: 92 10 20 00 clr %o1 <== NOT EXECUTED
40017fb4: 7f ff bb 4d call 40006ce8 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40017fb8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return status;
}
40017fbc: 81 c7 e0 08 ret <== NOT EXECUTED
40017fc0: 81 e8 00 00 restore <== NOT EXECUTED
4001b434 <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)
{
4001b434: 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;
4001b438: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b43c: 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;
4001b440: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b444: 94 10 20 00 clr %o2
4001b448: 7f ff ba e5 call 40009fdc <rtems_semaphore_obtain>
4001b44c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b450: 80 a2 20 00 cmp %o0, 0
4001b454: 02 80 00 08 be 4001b474 <msdos_file_close+0x40> <== ALWAYS TAKEN
4001b458: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
4001b45c: 40 00 01 3a call 4001b944 <__errno> <== NOT EXECUTED
4001b460: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001b464: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b468: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b46c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b470: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
4001b474: 7f ff ff d9 call 4001b3d8 <msdos_file_update>
4001b478: 90 10 00 18 mov %i0, %o0
4001b47c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
4001b480: 7f ff bb 20 call 4000a100 <rtems_semaphore_release>
4001b484: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001b488: 81 c7 e0 08 ret
4001b48c: 81 e8 00 00 restore
4001b698 <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)
{
4001b698: 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;
4001b69c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001b6a0: 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;
4001b6a4: 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,
4001b6a8: 92 10 20 00 clr %o1
4001b6ac: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001b6b0: 7f ff ba 4b call 40009fdc <rtems_semaphore_obtain>
4001b6b4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b6b8: 80 a2 20 00 cmp %o0, 0
4001b6bc: 02 80 00 08 be 4001b6dc <msdos_file_ftruncate+0x44> <== ALWAYS TAKEN
4001b6c0: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
4001b6c4: 40 00 00 a0 call 4001b944 <__errno> <== NOT EXECUTED
4001b6c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b6cc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b6d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b6d4: 81 c7 e0 08 ret <== NOT EXECUTED
4001b6d8: 81 e8 00 00 restore <== NOT EXECUTED
old_length = fat_fd->fat_file_size;
if (length < old_length) {
4001b6dc: 14 80 00 08 bg 4001b6fc <msdos_file_ftruncate+0x64> <== NEVER TAKEN
4001b6e0: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
4001b6e4: 80 a2 00 19 cmp %o0, %i1
4001b6e8: 12 80 00 0d bne 4001b71c <msdos_file_ftruncate+0x84> <== NEVER TAKEN
4001b6ec: 90 10 00 1d mov %i5, %o0
4001b6f0: 80 a6 c0 1a cmp %i3, %i2
4001b6f4: 08 80 00 0b bleu 4001b720 <msdos_file_ftruncate+0x88>
4001b6f8: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
4001b6fc: 90 10 00 1d mov %i5, %o0
4001b700: 92 10 00 1c mov %i4, %o1
4001b704: 7f ff dc c5 call 40012a18 <fat_file_truncate>
4001b708: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
4001b70c: b0 92 20 00 orcc %o0, 0, %i0
4001b710: 22 80 00 18 be,a 4001b770 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
4001b714: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
4001b718: 30 80 00 16 b,a 4001b770 <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,
4001b71c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001b720: 94 10 20 01 mov 1, %o2
4001b724: 96 10 00 1a mov %i2, %o3
4001b728: 7f ff dd 62 call 40012cb0 <fat_file_extend>
4001b72c: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
4001b730: b0 92 20 00 orcc %o0, 0, %i0
4001b734: 12 80 00 0f bne 4001b770 <msdos_file_ftruncate+0xd8> <== NEVER TAKEN
4001b738: 80 a6 60 00 cmp %i1, 0
4001b73c: 12 80 00 05 bne 4001b750 <msdos_file_ftruncate+0xb8> <== NEVER TAKEN
4001b740: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b744: 80 a6 80 01 cmp %i2, %g1
4001b748: 22 80 00 0a be,a 4001b770 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
4001b74c: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
4001b750: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001b754: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001b758: 7f ff dc b0 call 40012a18 <fat_file_truncate> <== NOT EXECUTED
4001b75c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
4001b760: 40 00 00 79 call 4001b944 <__errno> <== NOT EXECUTED
4001b764: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b768: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
4001b76c: 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);
4001b770: 7f ff ba 64 call 4000a100 <rtems_semaphore_release>
4001b774: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001b778: 81 c7 e0 08 ret
4001b77c: 81 e8 00 00 restore
4001b490 <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)
{
4001b490: 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;
4001b494: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001b498: 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;
4001b49c: 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,
4001b4a0: 92 10 20 00 clr %o1
4001b4a4: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001b4a8: 7f ff ba cd call 40009fdc <rtems_semaphore_obtain>
4001b4ac: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b4b0: 80 a2 20 00 cmp %o0, 0
4001b4b4: 22 80 00 07 be,a 4001b4d0 <msdos_file_read+0x40> <== ALWAYS TAKEN
4001b4b8: d4 06 20 0c ld [ %i0 + 0xc ], %o2
rtems_set_errno_and_return_minus_one(EIO);
4001b4bc: 40 00 01 22 call 4001b944 <__errno> <== NOT EXECUTED
4001b4c0: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001b4c4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b4c8: 10 80 00 10 b 4001b508 <msdos_file_read+0x78> <== NOT EXECUTED
4001b4cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
4001b4d0: 98 10 00 19 mov %i1, %o4
4001b4d4: 90 10 00 10 mov %l0, %o0
4001b4d8: 92 10 00 1d mov %i5, %o1
4001b4dc: 7f ff dc e1 call 40012860 <fat_file_read>
4001b4e0: 96 10 00 1a mov %i2, %o3
buffer);
if (ret > 0)
4001b4e4: b2 92 20 00 orcc %o0, 0, %i1
4001b4e8: 04 80 00 06 ble 4001b500 <msdos_file_read+0x70>
4001b4ec: 85 3e 60 1f sra %i1, 0x1f, %g2
iop->offset += ret;
4001b4f0: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
4001b4f4: b6 87 40 19 addcc %i5, %i1, %i3
4001b4f8: b4 47 00 02 addx %i4, %g2, %i2
4001b4fc: f4 3e 20 08 std %i2, [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
4001b500: 7f ff bb 00 call 4000a100 <rtems_semaphore_release>
4001b504: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001b508: 81 c7 e0 08 ret
4001b50c: 91 e8 00 19 restore %g0, %i1, %o0
4001b5e8 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001b5e8: 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;
4001b5ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001b5f0: 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;
4001b5f4: 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,
4001b5f8: 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;
4001b5fc: f6 17 60 06 lduh [ %i5 + 6 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b600: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001b604: 94 10 20 00 clr %o2
4001b608: 7f ff ba 75 call 40009fdc <rtems_semaphore_obtain>
4001b60c: b6 06 ff ff add %i3, -1, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b610: 80 a2 20 00 cmp %o0, 0
4001b614: 22 80 00 08 be,a 4001b634 <msdos_file_stat+0x4c> <== ALWAYS TAKEN
4001b618: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
4001b61c: 40 00 00 ca call 4001b944 <__errno> <== NOT EXECUTED
4001b620: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b624: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b628: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b62c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b630: 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);
4001b634: 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);
4001b638: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
4001b63c: 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);
4001b640: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
4001b644: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
4001b648: 03 00 00 20 sethi %hi(0x8000), %g1
4001b64c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 81ff <PROM_START+0x81ff>
4001b650: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001b654: 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;
4001b658: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
4001b65c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
4001b660: 82 06 c0 01 add %i3, %g1, %g1
4001b664: b6 28 40 1b andn %g1, %i3, %i3
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
4001b668: 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;
4001b66c: 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;
4001b670: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001b674: 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;
4001b678: c0 26 60 20 clr [ %i1 + 0x20 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
4001b67c: b7 36 e0 09 srl %i3, 9, %i3
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
4001b680: 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)
4001b684: 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);
4001b688: 7f ff ba 9e call 4000a100 <rtems_semaphore_release>
4001b68c: b0 10 20 00 clr %i0
return RC_OK;
}
4001b690: 81 c7 e0 08 ret
4001b694: 81 e8 00 00 restore
4001b780 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
4001b780: 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;
4001b784: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b788: 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;
4001b78c: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b790: 94 10 20 00 clr %o2
4001b794: 7f ff ba 12 call 40009fdc <rtems_semaphore_obtain>
4001b798: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b79c: 80 a2 20 00 cmp %o0, 0
4001b7a0: 02 80 00 08 be 4001b7c0 <msdos_file_sync+0x40> <== ALWAYS TAKEN
4001b7a4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
4001b7a8: 40 00 00 67 call 4001b944 <__errno> <== NOT EXECUTED
4001b7ac: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001b7b0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b7b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b7b8: 81 c7 e0 08 ret <== NOT EXECUTED
4001b7bc: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
4001b7c0: 7f ff ff 06 call 4001b3d8 <msdos_file_update>
4001b7c4: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4001b7c8: b0 92 20 00 orcc %o0, 0, %i0
4001b7cc: 12 80 00 04 bne 4001b7dc <msdos_file_sync+0x5c> <== NEVER TAKEN
4001b7d0: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
4001b7d4: 7f ff e2 27 call 40014070 <fat_sync>
4001b7d8: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
4001b7dc: 7f ff ba 49 call 4000a100 <rtems_semaphore_release>
4001b7e0: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return RC_OK;
}
4001b7e4: 81 c7 e0 08 ret
4001b7e8: 81 e8 00 00 restore
4001b3d8 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
4001b3d8: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001b3dc: 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))
4001b3e0: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4001b3e4: 80 88 60 01 btst 1, %g1
4001b3e8: 12 80 00 11 bne 4001b42c <msdos_file_update+0x54> <== NEVER TAKEN
4001b3ec: 90 10 20 00 clr %o0
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
4001b3f0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001b3f4: 7f ff f3 f0 call 400183b4 <msdos_set_first_cluster_num>
4001b3f8: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001b3fc: 80 a2 20 00 cmp %o0, 0
4001b400: 12 80 00 0b bne 4001b42c <msdos_file_update+0x54> <== NEVER TAKEN
4001b404: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
4001b408: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001b40c: 7f ff f4 1c call 4001847c <msdos_set_file_size>
4001b410: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001b414: 80 a2 20 00 cmp %o0, 0
4001b418: 12 80 00 05 bne 4001b42c <msdos_file_update+0x54> <== NEVER TAKEN
4001b41c: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
4001b420: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
4001b424: 7f ff f3 a9 call 400182c8 <msdos_set_dir_wrt_time_and_date>
4001b428: 81 e8 00 00 restore
return rc;
}
}
return rc;
}
4001b42c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b430: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4001b510 <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)
{
4001b510: 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;
4001b514: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001b518: 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;
4001b51c: 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,
4001b520: 92 10 20 00 clr %o1
4001b524: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001b528: 7f ff ba ad call 40009fdc <rtems_semaphore_obtain>
4001b52c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b530: 80 a2 20 00 cmp %o0, 0
4001b534: 22 80 00 07 be,a 4001b550 <msdos_file_write+0x40> <== ALWAYS TAKEN
4001b538: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
4001b53c: 40 00 01 02 call 4001b944 <__errno> <== NOT EXECUTED
4001b540: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001b544: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b548: 10 80 00 14 b 4001b598 <msdos_file_write+0x88> <== NOT EXECUTED
4001b54c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
4001b550: 80 88 62 00 btst 0x200, %g1
4001b554: 22 80 00 06 be,a 4001b56c <msdos_file_write+0x5c>
4001b558: d4 06 20 0c ld [ %i0 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
4001b55c: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
4001b560: c0 26 20 08 clr [ %i0 + 8 ]
4001b564: c2 26 20 0c st %g1, [ %i0 + 0xc ]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
4001b568: d4 06 20 0c ld [ %i0 + 0xc ], %o2
4001b56c: 98 10 00 19 mov %i1, %o4
4001b570: 90 10 00 10 mov %l0, %o0
4001b574: 92 10 00 11 mov %l1, %o1
4001b578: 7f ff de 64 call 40012f08 <fat_file_write>
4001b57c: 96 10 00 1a mov %i2, %o3
buffer);
if (ret < 0)
4001b580: b2 92 20 00 orcc %o0, 0, %i1
4001b584: 36 80 00 07 bge,a 4001b5a0 <msdos_file_write+0x90> <== ALWAYS TAKEN
4001b588: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
{
rtems_semaphore_release(fs_info->vol_sema);
4001b58c: 7f ff ba dd call 4000a100 <rtems_semaphore_release> <== NOT EXECUTED
4001b590: d0 04 20 9c ld [ %l0 + 0x9c ], %o0 <== NOT EXECUTED
return -1;
4001b594: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001b598: 81 c7 e0 08 ret <== NOT EXECUTED
4001b59c: 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;
4001b5a0: b9 3e 60 1f sra %i1, 0x1f, %i4
4001b5a4: 86 86 40 1b addcc %i1, %i3, %g3
4001b5a8: 84 47 00 1a addx %i4, %i2, %g2
4001b5ac: c4 3e 20 08 std %g2, [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
4001b5b0: 80 a0 a0 00 cmp %g2, 0
4001b5b4: 14 80 00 07 bg 4001b5d0 <msdos_file_write+0xc0> <== NEVER TAKEN
4001b5b8: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
4001b5bc: 80 a0 a0 00 cmp %g2, 0
4001b5c0: 12 80 00 05 bne 4001b5d4 <msdos_file_write+0xc4> <== NEVER TAKEN
4001b5c4: 80 a0 c0 01 cmp %g3, %g1
4001b5c8: 08 80 00 03 bleu 4001b5d4 <msdos_file_write+0xc4>
4001b5cc: 01 00 00 00 nop
fat_fd->fat_file_size = iop->offset;
4001b5d0: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
rtems_semaphore_release(fs_info->vol_sema);
4001b5d4: 7f ff ba cb call 4000a100 <rtems_semaphore_release>
4001b5d8: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001b5dc: b0 10 00 19 mov %i1, %i0
4001b5e0: 81 c7 e0 08 ret
4001b5e4: 81 e8 00 00 restore
4001acbc <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
4001acbc: 82 10 20 00 clr %g1
dn[i] = ' ';
4001acc0: 84 10 20 20 mov 0x20, %g2
4001acc4: 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++)
4001acc8: 82 00 60 01 inc %g1
4001accc: 80 a0 60 0b cmp %g1, 0xb
4001acd0: 32 bf ff fe bne,a 4001acc8 <msdos_filename_unix2dos+0xc>
4001acd4: 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) {
4001acd8: c2 4a 00 00 ldsb [ %o0 ], %g1
4001acdc: 80 a0 60 2e cmp %g1, 0x2e
4001ace0: 12 80 00 12 bne 4001ad28 <msdos_filename_unix2dos+0x6c> <== ALWAYS TAKEN
4001ace4: 80 a2 60 00 cmp %o1, 0
4001ace8: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
4001acec: 32 80 00 04 bne,a 4001acfc <msdos_filename_unix2dos+0x40><== NOT EXECUTED
4001acf0: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
dn[0] = '.';
return 0;
4001acf4: 10 80 00 4f b 4001ae30 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
4001acf8: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
4001acfc: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
4001ad00: 12 80 00 0a bne 4001ad28 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
4001ad04: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4001ad08: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
4001ad0c: 12 80 00 07 bne 4001ad28 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
4001ad10: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
dn[0] = '.';
4001ad14: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
4001ad18: 10 80 00 46 b 4001ae30 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
4001ad1c: 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--;
4001ad20: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
4001ad24: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4001ad28: 32 80 00 05 bne,a 4001ad3c <msdos_filename_unix2dos+0x80><== ALWAYS TAKEN
4001ad2c: 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++)
4001ad30: 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)
4001ad34: 10 80 00 0d b 4001ad68 <msdos_filename_unix2dos+0xac>
4001ad38: 1b 10 00 b2 sethi %hi(0x4002c800), %o5
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
4001ad3c: 80 a0 60 2e cmp %g1, 0x2e
4001ad40: 22 bf ff f8 be,a 4001ad20 <msdos_filename_unix2dos+0x64> <== NEVER TAKEN
4001ad44: 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++)
4001ad48: 10 bf ff fb b 4001ad34 <msdos_filename_unix2dos+0x78>
4001ad4c: 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)
4001ad50: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
4001ad54: 80 89 20 ff btst 0xff, %g4
4001ad58: 02 80 00 1a be 4001adc0 <msdos_filename_unix2dos+0x104>
4001ad5c: 80 a0 a0 00 cmp %g2, 0
break;
dn[i] = msdos_map[c];
4001ad60: 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++) {
4001ad64: 82 00 60 01 inc %g1
4001ad68: 84 a2 40 01 subcc %o1, %g1, %g2
4001ad6c: 02 80 00 14 be 4001adbc <msdos_filename_unix2dos+0x100>
4001ad70: 86 02 00 01 add %o0, %g1, %g3
4001ad74: 80 a0 60 07 cmp %g1, 7
4001ad78: 04 80 00 03 ble 4001ad84 <msdos_filename_unix2dos+0xc8>
4001ad7c: 88 10 20 01 mov 1, %g4
4001ad80: 88 10 20 00 clr %g4
4001ad84: 80 89 20 ff btst 0xff, %g4
4001ad88: 02 80 00 0e be 4001adc0 <msdos_filename_unix2dos+0x104>
4001ad8c: 80 a0 a0 00 cmp %g2, 0
4001ad90: c8 0a 00 01 ldub [ %o0 + %g1 ], %g4
4001ad94: 80 a1 20 00 cmp %g4, 0
4001ad98: 02 80 00 09 be 4001adbc <msdos_filename_unix2dos+0x100> <== NEVER TAKEN
4001ad9c: 80 a1 20 2e cmp %g4, 0x2e
4001ada0: 12 bf ff ec bne 4001ad50 <msdos_filename_unix2dos+0x94>
4001ada4: 98 13 60 78 or %o5, 0x78, %o4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
4001ada8: 10 80 00 06 b 4001adc0 <msdos_filename_unix2dos+0x104>
4001adac: 80 a0 a0 00 cmp %g2, 0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
4001adb0: 80 a0 60 2e cmp %g1, 0x2e
4001adb4: 02 80 00 09 be 4001add8 <msdos_filename_unix2dos+0x11c>
4001adb8: 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)) {
4001adbc: 80 a0 a0 00 cmp %g2, 0
4001adc0: 02 80 00 07 be 4001addc <msdos_filename_unix2dos+0x120>
4001adc4: 82 10 20 08 mov 8, %g1
4001adc8: c2 08 c0 00 ldub [ %g3 ], %g1
4001adcc: 80 a0 60 00 cmp %g1, 0
4001add0: 32 bf ff f8 bne,a 4001adb0 <msdos_filename_unix2dos+0xf4><== ALWAYS TAKEN
4001add4: 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++)
4001add8: 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)
4001addc: 10 80 00 08 b 4001adfc <msdos_filename_unix2dos+0x140>
4001ade0: 1b 10 00 b2 sethi %hi(0x4002c800), %o5
4001ade4: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
4001ade8: 80 89 20 ff btst 0xff, %g4
4001adec: 02 80 00 11 be 4001ae30 <msdos_filename_unix2dos+0x174>
4001adf0: 84 00 bf ff add %g2, -1, %g2
break;
dn[i] = msdos_map[c];
4001adf4: 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++) {
4001adf8: 82 00 60 01 inc %g1
4001adfc: 80 a0 a0 00 cmp %g2, 0
4001ae00: 02 80 00 0c be 4001ae30 <msdos_filename_unix2dos+0x174>
4001ae04: 80 a0 60 0a cmp %g1, 0xa
4001ae08: 04 80 00 03 ble 4001ae14 <msdos_filename_unix2dos+0x158> <== ALWAYS TAKEN
4001ae0c: 88 10 20 01 mov 1, %g4
4001ae10: 88 10 20 00 clr %g4 <== NOT EXECUTED
4001ae14: 80 89 20 ff btst 0xff, %g4
4001ae18: 02 80 00 06 be 4001ae30 <msdos_filename_unix2dos+0x174> <== NEVER TAKEN
4001ae1c: 88 00 c0 01 add %g3, %g1, %g4
4001ae20: c8 09 3f f8 ldub [ %g4 + -8 ], %g4
4001ae24: 80 a1 20 00 cmp %g4, 0
4001ae28: 12 bf ff ef bne 4001ade4 <msdos_filename_unix2dos+0x128> <== ALWAYS TAKEN
4001ae2c: 98 13 60 78 or %o5, 0x78, %o4
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
4001ae30: 81 c3 e0 08 retl
4001ae34: 90 10 20 00 clr %o0
400195f0 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
400195f0: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
400195f4: 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);
400195f8: 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;
400195fc: 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);
40019600: 92 10 20 00 clr %o1
40019604: 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;
40019608: 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);
4001960c: 40 00 0b b0 call 4001c4cc <memset>
40019610: 90 10 00 1c mov %i4, %o0
name_type = msdos_long_to_short (name,
40019614: 92 10 00 1a mov %i2, %o1
40019618: 94 10 00 1c mov %i4, %o2
4001961c: 96 10 20 0b mov 0xb, %o3
40019620: 7f ff fa 9f call 4001809c <msdos_long_to_short>
40019624: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
40019628: 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,
4001962c: 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,
40019630: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
40019634: 90 10 00 18 mov %i0, %o0
40019638: 92 10 20 00 clr %o1
4001963c: 94 10 00 19 mov %i1, %o2
40019640: 96 10 00 1a mov %i2, %o3
40019644: 7f ff ff ab call 400194f0 <msdos_get_name_node>
40019648: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
4001964c: b0 92 20 00 orcc %o0, 0, %i0
40019650: 12 80 00 68 bne 400197f0 <msdos_find_name+0x200>
40019654: 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;
40019658: 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) ||
4001965c: 84 08 60 08 and %g1, 8, %g2
40019660: 80 88 a0 ff btst 0xff, %g2
40019664: 12 80 00 63 bne 400197f0 <msdos_find_name+0x200> <== NEVER TAKEN
40019668: b0 16 21 01 or %i0, 0x101, %i0
4001966c: 82 08 60 3f and %g1, 0x3f, %g1
40019670: 80 a0 60 0f cmp %g1, 0xf
40019674: 02 80 00 5f be 400197f0 <msdos_find_name+0x200> <== NEVER TAKEN
40019678: 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);
4001967c: 92 07 bf d0 add %fp, -48, %o1
40019680: 7f ff e4 15 call 400126d4 <fat_file_open>
40019684: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
40019688: b0 92 20 00 orcc %o0, 0, %i0
4001968c: 12 80 00 59 bne 400197f0 <msdos_find_name+0x200> <== NEVER TAKEN
40019690: f8 07 bf cc ld [ %fp + -52 ], %i4
return rc;
fat_fd->dir_pos = dir_pos;
40019694: 92 07 bf d0 add %fp, -48, %o1
40019698: 90 07 20 20 add %i4, 0x20, %o0
4001969c: 40 00 0b 4f call 4001c3d8 <memcpy>
400196a0: 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)
400196a4: c2 07 20 08 ld [ %i4 + 8 ], %g1
400196a8: 80 a0 60 01 cmp %g1, 1
400196ac: 32 80 00 49 bne,a 400197d0 <msdos_find_name+0x1e0>
400196b0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
400196b4: c2 17 bf f4 lduh [ %fp + -12 ], %g1
400196b8: 83 28 60 10 sll %g1, 0x10, %g1
400196bc: 85 30 60 18 srl %g1, 0x18, %g2
400196c0: 87 30 60 08 srl %g1, 8, %g3
400196c4: 03 00 00 3f sethi %hi(0xfc00), %g1
400196c8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
400196cc: 86 08 c0 01 and %g3, %g1, %g3
400196d0: 86 10 80 03 or %g2, %g3, %g3
400196d4: c4 17 bf fa lduh [ %fp + -6 ], %g2
400196d8: 87 28 e0 10 sll %g3, 0x10, %g3
400196dc: 85 28 a0 10 sll %g2, 0x10, %g2
400196e0: 89 30 a0 18 srl %g2, 0x18, %g4
400196e4: 85 30 a0 08 srl %g2, 8, %g2
400196e8: 84 08 80 01 and %g2, %g1, %g2
400196ec: 84 11 00 02 or %g4, %g2, %g2
400196f0: 84 10 c0 02 or %g3, %g2, %g2
400196f4: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
400196f8: c4 17 bf f8 lduh [ %fp + -8 ], %g2
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
400196fc: 85 28 a0 10 sll %g2, 0x10, %g2
40019700: 91 30 a0 18 srl %g2, 0x18, %o0
40019704: 85 30 a0 08 srl %g2, 8, %g2
40019708: 86 08 80 01 and %g2, %g1, %g3
4001970c: c4 17 bf f6 lduh [ %fp + -10 ], %g2
40019710: 90 12 00 03 or %o0, %g3, %o0
40019714: 85 28 a0 10 sll %g2, 0x10, %g2
40019718: 93 30 a0 18 srl %g2, 0x18, %o1
4001971c: 85 30 a0 08 srl %g2, 8, %g2
40019720: 82 08 80 01 and %g2, %g1, %g1
40019724: 40 00 05 1e call 4001ab9c <msdos_date_dos2unix>
40019728: 92 12 40 01 or %o1, %g1, %o1
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
4001972c: 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));
40019730: d0 27 20 40 st %o0, [ %i4 + 0x40 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
40019734: 82 08 60 10 and %g1, 0x10, %g1
40019738: 80 88 60 ff btst 0xff, %g1
4001973c: 02 80 00 0e be 40019774 <msdos_find_name+0x184>
40019740: f8 07 bf cc ld [ %fp + -52 ], %i4
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40019744: 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;
40019748: c0 27 20 10 clr [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001974c: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
40019750: 90 10 00 1d mov %i5, %o0
40019754: 7f ff e6 8d call 40013188 <fat_file_size>
40019758: 92 10 00 1c mov %i4, %o1
if (rc != RC_OK)
4001975c: b0 92 20 00 orcc %o0, 0, %i0
40019760: 02 80 00 0d be 40019794 <msdos_find_name+0x1a4> <== ALWAYS TAKEN
40019764: c2 07 bf cc ld [ %fp + -52 ], %g1
{
fat_file_close(&fs_info->fat, fat_fd);
40019768: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001976c: 10 80 00 1f b 400197e8 <msdos_find_name+0x1f8> <== NOT EXECUTED
40019770: 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));
40019774: 7f ff fa 30 call 40018034 <CPU_swap_u32>
40019778: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_fd->fat_file_type = FAT_FILE;
4001977c: 82 10 20 04 mov 4, %g1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
40019780: d0 27 20 18 st %o0, [ %i4 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
40019784: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
40019788: 82 10 3f ff mov -1, %g1
4001978c: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
40019790: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_fd->map.disk_cln = fat_fd->cln;
40019794: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ((fat_fd->fat_file_size != 0) &&
40019798: 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;
4001979c: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
400197a0: 80 a0 e0 00 cmp %g3, 0
400197a4: 02 80 00 08 be 400197c4 <msdos_find_name+0x1d4>
400197a8: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
400197ac: 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) &&
400197b0: 80 a0 c0 04 cmp %g3, %g4
400197b4: 38 80 00 05 bgu,a 400197c8 <msdos_find_name+0x1d8>
400197b8: 84 10 3f ff mov -1, %g2
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
400197bc: 10 80 00 04 b 400197cc <msdos_find_name+0x1dc>
400197c0: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
400197c4: 84 10 3f ff mov -1, %g2
400197c8: 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);
400197cc: d2 06 e0 08 ld [ %i3 + 8 ], %o1
400197d0: 7f ff e4 d7 call 40012b2c <fat_file_close>
400197d4: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
400197d8: b0 92 20 00 orcc %o0, 0, %i0
400197dc: 02 80 00 07 be 400197f8 <msdos_find_name+0x208> <== ALWAYS TAKEN
400197e0: d2 07 bf cc ld [ %fp + -52 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
400197e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400197e8: 7f ff e4 d1 call 40012b2c <fat_file_close> <== NOT EXECUTED
400197ec: 01 00 00 00 nop <== NOT EXECUTED
400197f0: 81 c7 e0 08 ret
400197f4: 81 e8 00 00 restore
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
400197f8: d2 26 e0 08 st %o1, [ %i3 + 8 ]
return rc;
}
400197fc: 81 c7 e0 08 ret
40019800: 81 e8 00 00 restore
40018744 <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
)
{
40018744: 9d e3 bf 60 save %sp, -160, %sp
40018748: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4001874c: 84 10 00 1a mov %i2, %g2
40018750: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
40018754: 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);
40018758: 80 a7 20 00 cmp %i4, 0
4001875c: 14 80 00 0a bg 40018784 <msdos_find_name_in_fat_file+0x40><== ALWAYS TAKEN
40018760: e0 06 20 08 ld [ %i0 + 8 ], %l0
40018764: 11 10 00 b1 sethi %hi(0x4002c400), %o0 <== NOT EXECUTED
40018768: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4001876c: 17 10 00 b1 sethi %hi(0x4002c400), %o3 <== NOT EXECUTED
40018770: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
40018774: 92 10 23 c9 mov 0x3c9, %o1 <== NOT EXECUTED
40018778: 94 12 a0 28 or %o2, 0x28, %o2 <== NOT EXECUTED
4001877c: 10 80 00 3e b 40018874 <msdos_find_name_in_fat_file+0x130><== NOT EXECUTED
40018780: 96 12 e3 e8 or %o3, 0x3e8, %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;
40018784: 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;
40018788: c0 24 80 00 clr [ %l2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001878c: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40018790: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
40018794: c2 27 bf fc st %g1, [ %fp + -4 ]
40018798: 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))
4001879c: 82 1f 60 01 xor %i5, 1, %g1
400187a0: 80 a0 00 01 cmp %g0, %g1
400187a4: b4 60 3f ff subx %g0, -1, %i2
400187a8: 80 8e a0 ff btst 0xff, %i2
400187ac: 02 80 00 05 be 400187c0 <msdos_find_name_in_fat_file+0x7c>
400187b0: c0 24 a0 04 clr [ %l2 + 4 ]
400187b4: 80 a0 a0 00 cmp %g2, 0
400187b8: 12 80 00 08 bne 400187d8 <msdos_find_name_in_fat_file+0x94>
400187bc: a6 10 20 00 clr %l3
lfn_entries = 0;
else
lfn_entries =
400187c0: c4 27 bf d0 st %g2, [ %fp + -48 ]
400187c4: 90 07 20 0c add %i4, 0xc, %o0
400187c8: 7f ff a7 de call 40002740 <.div>
400187cc: 92 10 20 0d mov 0xd, %o1
400187d0: c4 07 bf d0 ld [ %fp + -48 ], %g2
400187d4: 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) &&
400187d8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400187dc: 80 a0 60 01 cmp %g1, 1
400187e0: 32 80 00 0b bne,a 4001880c <msdos_find_name_in_fat_file+0xc8>
400187e4: e2 14 20 06 lduh [ %l0 + 6 ], %l1
400187e8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
400187ec: 80 a0 60 00 cmp %g1, 0
400187f0: 32 80 00 07 bne,a 4001880c <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
400187f4: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
400187f8: 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) &&
400187fc: 80 88 60 03 btst 3, %g1
40018800: 22 80 00 03 be,a 4001880c <msdos_find_name_in_fat_file+0xc8>
40018804: e2 14 20 06 lduh [ %l0 + 6 ], %l1
40018808: 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 ||
4001880c: 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))
40018810: 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),
40018814: 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;
40018818: 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;
4001881c: 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;
40018820: 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;
40018824: 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;
40018828: 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;
4001882c: 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;
40018830: 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;
40018834: 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 ||
40018838: 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),
4001883c: 10 80 00 eb b 40018be8 <msdos_find_name_in_fat_file+0x4a4>
40018840: 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)
40018844: 80 a2 20 1f cmp %o0, 0x1f
40018848: 04 80 02 02 ble 40019050 <msdos_find_name_in_fat_file+0x90c><== NEVER TAKEN
4001884c: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
40018850: 22 80 00 0b be,a 4001887c <msdos_find_name_in_fat_file+0x138><== ALWAYS TAKEN
40018854: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
40018858: 11 10 00 b1 sethi %hi(0x4002c400), %o0 <== NOT EXECUTED
4001885c: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
40018860: 17 10 00 b1 sethi %hi(0x4002c400), %o3 <== NOT EXECUTED
40018864: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
40018868: 92 10 23 f9 mov 0x3f9, %o1 <== NOT EXECUTED
4001886c: 94 12 a0 28 or %o2, 0x28, %o2 <== NOT EXECUTED
40018870: 96 12 e3 f8 or %o3, 0x3f8, %o3 <== NOT EXECUTED
40018874: 7f ff b4 53 call 400059c0 <__assert_func> <== NOT EXECUTED
40018878: 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;
4001887c: 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)
40018880: 80 a6 20 00 cmp %i0, 0
40018884: 12 80 00 04 bne 40018894 <msdos_find_name_in_fat_file+0x150>
40018888: de 0d 40 00 ldub [ %l5 ], %o7
4001888c: ae 10 00 1a mov %i2, %l7
40018890: ac 10 00 1b mov %i3, %l6
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
40018894: 98 8b e0 ff andcc %o7, 0xff, %o4
40018898: 12 80 00 11 bne 400188dc <msdos_find_name_in_fat_file+0x198>
4001889c: 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)
400188a0: 80 a0 a0 00 cmp %g2, 0
400188a4: 12 80 00 06 bne 400188bc <msdos_find_name_in_fat_file+0x178>
400188a8: c4 0f bf e7 ldub [ %fp + -25 ], %g2
return MSDOS_NAME_NOT_FOUND_ERR;
400188ac: 31 00 00 1f sethi %hi(0x7c00), %i0
400188b0: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
400188b4: 81 c7 e0 08 ret
400188b8: 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)
400188bc: 80 88 a0 ff btst 0xff, %g2
400188c0: 12 80 00 dc bne 40018c30 <msdos_find_name_in_fat_file+0x4ec>
400188c4: 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;
400188c8: 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);
400188cc: b5 36 a0 05 srl %i2, 5, %i2
400188d0: 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 +=
400188d4: 10 80 00 d7 b 40018c30 <msdos_find_name_in_fat_file+0x4ec>
400188d8: 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)
400188dc: 12 80 00 0c bne 4001890c <msdos_find_name_in_fat_file+0x1c8>
400188e0: c2 0f bf e7 ldub [ %fp + -25 ], %g1
{
if (create_node)
400188e4: 80 a0 a0 00 cmp %g2, 0
400188e8: 22 80 00 bb be,a 40018bd4 <msdos_find_name_in_fat_file+0x490>
400188ec: 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))
400188f0: c2 07 bf d8 ld [ %fp + -40 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
400188f4: b0 06 20 01 inc %i0
if (empty_space_count == (lfn_entries + 1))
400188f8: 80 a6 00 01 cmp %i0, %g1
400188fc: 32 80 00 b6 bne,a 40018bd4 <msdos_find_name_in_fat_file+0x490>
40018900: b4 06 a0 20 add %i2, 0x20, %i2
empty_space_found = true;
40018904: 10 80 00 b2 b 40018bcc <msdos_find_name_in_fat_file+0x488>
40018908: 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)
4001890c: 98 18 60 01 xor %g1, 1, %o4
40018910: 80 8b 20 ff btst 0xff, %o4
40018914: 02 80 00 07 be 40018930 <msdos_find_name_in_fat_file+0x1ec><== NEVER TAKEN
40018918: d8 0d 60 0b ldub [ %l5 + 0xb ], %o4
4001891c: 80 a0 a0 00 cmp %g2, 0
40018920: 02 80 00 04 be 40018930 <msdos_find_name_in_fat_file+0x1ec>
40018924: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
40018928: 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;
4001892c: 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) ==
40018930: 98 0b 20 3f and %o4, 0x3f, %o4
40018934: 80 a3 20 0f cmp %o4, 0xf
40018938: 12 80 00 54 bne 40018a88 <msdos_find_name_in_fat_file+0x344>
4001893c: 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)
40018940: d8 07 bf f8 ld [ %fp + -8 ], %o4
40018944: 80 a3 3f ff cmp %o4, -1
40018948: 32 80 00 10 bne,a 40018988 <msdos_find_name_in_fat_file+0x244>
4001894c: de 0d 40 00 ldub [ %l5 ], %o7
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
40018950: 98 0b e0 40 and %o7, 0x40, %o4
40018954: 80 8b 20 ff btst 0xff, %o4
40018958: 02 80 00 9e be 40018bd0 <msdos_find_name_in_fat_file+0x48c>
4001895c: 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) &
40018960: 9e 0b e0 3f and %o7, 0x3f, %o7
40018964: 80 a4 c0 0f cmp %l3, %o7
40018968: 32 80 00 9b bne,a 40018bd4 <msdos_find_name_in_fat_file+0x490>
4001896c: b4 06 a0 20 add %i2, 0x20, %i2
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
40018970: f6 27 bf f8 st %i3, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
40018974: f4 27 bf fc st %i2, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
40018978: c6 0d 60 0d ldub [ %l5 + 0xd ], %g3
4001897c: c6 2f bf ef stb %g3, [ %fp + -17 ]
40018980: 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) &
40018984: de 0d 40 00 ldub [ %l5 ], %o7
40018988: 9e 0b e0 3f and %o7, 0x3f, %o7
4001898c: 80 a0 c0 0f cmp %g3, %o7
40018990: 12 80 00 07 bne 400189ac <msdos_find_name_in_fat_file+0x268><== NEVER TAKEN
40018994: 82 10 3f ff mov -1, %g1
MSDOS_LAST_LONG_ENTRY_MASK)) ||
40018998: d8 0f bf ef ldub [ %fp + -17 ], %o4
4001899c: de 0d 60 0d ldub [ %l5 + 0xd ], %o7
400189a0: 80 a3 00 0f cmp %o4, %o7
400189a4: 02 80 00 04 be 400189b4 <msdos_find_name_in_fat_file+0x270><== ALWAYS TAKEN
400189a8: 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;
400189ac: 10 80 00 89 b 40018bd0 <msdos_find_name_in_fat_file+0x48c><== NOT EXECUTED
400189b0: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
400189b4: 9f 2b 20 02 sll %o4, 2, %o7
400189b8: 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(
400189bc: 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;
400189c0: 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++)
400189c4: 9e 10 20 00 clr %o7
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
400189c8: 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')
400189cc: d4 4b 40 00 ldsb [ %o5 ], %o2
400189d0: 80 a2 a0 00 cmp %o2, 0
400189d4: 12 80 00 0b bne 40018a00 <msdos_find_name_in_fat_file+0x2bc>
400189d8: 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) &&
400189dc: 80 a0 c0 13 cmp %g3, %l3
400189e0: 12 80 00 22 bne 40018a68 <msdos_find_name_in_fat_file+0x324><== NEVER TAKEN
400189e4: 80 a3 20 00 cmp %o4, 0
((o + i) != name_len))
400189e8: 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) &&
400189ec: 80 a3 c0 1c cmp %o7, %i4
400189f0: 02 80 00 1e be 40018a68 <msdos_find_name_in_fat_file+0x324><== ALWAYS TAKEN
400189f4: 80 a3 20 00 cmp %o4, 0
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
400189f8: 10 80 00 0b b 40018a24 <msdos_find_name_in_fat_file+0x2e0><== NOT EXECUTED
400189fc: 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]))
40018a00: 80 a2 40 1c cmp %o1, %i4
40018a04: 16 80 00 07 bge 40018a20 <msdos_find_name_in_fat_file+0x2dc>
40018a08: 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(
40018a0c: 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]))
40018a10: d2 4a 40 0f ldsb [ %o1 + %o7 ], %o1
40018a14: 80 a2 80 09 cmp %o2, %o1
40018a18: 02 80 00 05 be 40018a2c <msdos_find_name_in_fat_file+0x2e8>
40018a1c: 80 a3 e0 04 cmp %o7, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
40018a20: 86 10 3f ff mov -1, %g3
break;
40018a24: 10 80 00 10 b 40018a64 <msdos_find_name_in_fat_file+0x320>
40018a28: c6 27 bf f8 st %g3, [ %fp + -8 ]
}
switch (i)
40018a2c: 02 80 00 06 be 40018a44 <msdos_find_name_in_fat_file+0x300>
40018a30: 80 a3 e0 0a cmp %o7, 0xa
40018a34: 32 80 00 08 bne,a 40018a54 <msdos_find_name_in_fat_file+0x310>
40018a38: 9a 03 60 02 add %o5, 2, %o5
{
case 4:
p += 5;
break;
case 10:
p += 4;
40018a3c: 10 80 00 04 b 40018a4c <msdos_find_name_in_fat_file+0x308>
40018a40: 9a 03 60 04 add %o5, 4, %o5
switch (i)
{
case 4:
p += 5;
break;
40018a44: 10 80 00 04 b 40018a54 <msdos_find_name_in_fat_file+0x310>
40018a48: 9a 03 60 05 add %o5, 5, %o5
case 10:
p += 4;
break;
40018a4c: 10 80 00 03 b 40018a58 <msdos_find_name_in_fat_file+0x314>
40018a50: 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++)
40018a54: 9e 03 e0 01 inc %o7
40018a58: 80 a3 e0 0d cmp %o7, 0xd
40018a5c: 32 bf ff dd bne,a 400189d0 <msdos_find_name_in_fat_file+0x28c>
40018a60: d4 4b 40 00 ldsb [ %o5 ], %o2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
40018a64: 80 a3 20 00 cmp %o4, 0
40018a68: 12 80 00 06 bne 40018a80 <msdos_find_name_in_fat_file+0x33c>
40018a6c: 9a 10 20 00 clr %o5
40018a70: c6 07 bf f8 ld [ %fp + -8 ], %g3
40018a74: 86 38 00 03 xnor %g0, %g3, %g3
40018a78: 80 a0 00 03 cmp %g0, %g3
40018a7c: 9a 40 20 00 addx %g0, 0, %o5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
40018a80: 10 80 00 54 b 40018bd0 <msdos_find_name_in_fat_file+0x48c>
40018a84: 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)
40018a88: 02 80 01 85 be 4001909c <msdos_find_name_in_fat_file+0x958>
40018a8c: c2 07 bf dc ld [ %fp + -36 ], %g1
40018a90: 9a 10 20 00 clr %o5
40018a94: 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;
40018a98: d6 0d 40 0d ldub [ %l5 + %o5 ], %o3
40018a9c: 98 0b e0 01 and %o7, 1, %o4
40018aa0: 80 a0 00 0c cmp %g0, %o4
40018aa4: 9e 0b e0 ff and %o7, 0xff, %o7
40018aa8: 98 40 3f ff addx %g0, -1, %o4
40018aac: 9f 33 e0 01 srl %o7, 1, %o7
40018ab0: 98 0b 20 80 and %o4, 0x80, %o4
40018ab4: 9e 02 c0 0f add %o3, %o7, %o7
40018ab8: 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++)
40018abc: 9a 03 60 01 inc %o5
40018ac0: 80 a3 60 0b cmp %o5, 0xb
40018ac4: 12 bf ff f5 bne 40018a98 <msdos_find_name_in_fat_file+0x354>
40018ac8: 9e 03 c0 0c add %o7, %o4, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
40018acc: c2 0f bf ef ldub [ %fp + -17 ], %g1
40018ad0: 9e 1b c0 01 xor %o7, %g1, %o7
40018ad4: 80 8b e0 ff btst 0xff, %o7
40018ad8: 12 80 01 71 bne 4001909c <msdos_find_name_in_fat_file+0x958><== NEVER TAKEN
40018adc: c2 07 bf dc ld [ %fp + -36 ], %g1
40018ae0: 80 a0 e0 00 cmp %g3, 0
40018ae4: 12 80 01 6f bne 400190a0 <msdos_find_name_in_fat_file+0x95c><== NEVER TAKEN
40018ae8: 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,
40018aec: 90 10 00 10 mov %l0, %o0
40018af0: 92 10 00 19 mov %i1, %o1
40018af4: 94 10 20 01 mov 1, %o2
40018af8: 96 10 00 04 mov %g4, %o3
40018afc: 7f ff e8 39 call 40012be0 <fat_file_ioctl>
40018b00: 98 10 00 12 mov %l2, %o4
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
40018b04: b0 92 20 00 orcc %o0, 0, %i0
40018b08: 02 80 00 13 be 40018b54 <msdos_find_name_in_fat_file+0x410><== ALWAYS TAKEN
40018b0c: d2 07 bf f8 ld [ %fp + -8 ], %o1
40018b10: 81 c7 e0 08 ret <== NOT EXECUTED
40018b14: 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) &&
40018b18: 80 a3 ff ff cmp %o7, -1
40018b1c: 12 80 00 29 bne 40018bc0 <msdos_find_name_in_fat_file+0x47c><== NEVER TAKEN
40018b20: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
40018b24: c4 3f bf d0 std %g2, [ %fp + -48 ]
40018b28: c8 27 bf cc st %g4, [ %fp + -52 ]
40018b2c: 90 10 00 15 mov %l5, %o0
40018b30: 92 10 00 14 mov %l4, %o1
40018b34: 40 00 0d ff call 4001c330 <memcmp>
40018b38: 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) &&
40018b3c: c4 1f bf d0 ldd [ %fp + -48 ], %g2
40018b40: 80 a2 20 00 cmp %o0, 0
40018b44: 12 80 00 1e bne 40018bbc <msdos_find_name_in_fat_file+0x478>
40018b48: 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,
40018b4c: 10 bf ff e9 b 40018af0 <msdos_find_name_in_fat_file+0x3ac>
40018b50: 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)
40018b54: 80 a2 7f ff cmp %o1, -1
40018b58: 12 80 00 0c bne 40018b88 <msdos_find_name_in_fat_file+0x444>
40018b5c: f4 24 a0 04 st %i2, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40018b60: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
40018b64: 90 10 00 14 mov %l4, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40018b68: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
40018b6c: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
40018b70: 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;
40018b74: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
memcpy(name_dir_entry, entry,
40018b78: 40 00 0e 18 call 4001c3d8 <memcpy>
40018b7c: 94 10 20 20 mov 0x20, %o2
40018b80: 81 c7 e0 08 ret
40018b84: 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,
40018b88: 7f ff a6 b2 call 40002650 <.umul>
40018b8c: 90 10 00 11 mov %l1, %o0
40018b90: 92 10 00 19 mov %i1, %o1
40018b94: 96 10 00 08 mov %o0, %o3
40018b98: 94 10 20 01 mov 1, %o2
40018b9c: 90 10 00 10 mov %l0, %o0
40018ba0: 7f ff e8 10 call 40012be0 <fat_file_ioctl>
40018ba4: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
40018ba8: 80 a2 20 00 cmp %o0, 0
40018bac: 12 80 01 37 bne 40019088 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
40018bb0: 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,
40018bb4: 10 bf ff ed b 40018b68 <msdos_find_name_in_fat_file+0x424>
40018bb8: 90 10 00 14 mov %l4, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
40018bbc: 82 10 3f ff mov -1, %g1
lfn_matched = false;
40018bc0: 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;
40018bc4: 10 80 00 03 b 40018bd0 <msdos_find_name_in_fat_file+0x48c>
40018bc8: 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;
40018bcc: 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)
40018bd0: 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;
40018bd4: 80 a6 80 11 cmp %i2, %l1
40018bd8: 0a bf ff 2a bcs 40018880 <msdos_find_name_in_fat_file+0x13c>
40018bdc: aa 05 60 20 add %l5, 0x20, %l5
}
if (remainder_empty)
break;
dir_offset++;
40018be0: b6 06 e0 01 inc %i3
40018be4: 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),
40018be8: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
40018bec: 94 10 00 04 mov %g4, %o2
40018bf0: c4 3f bf d0 std %g2, [ %fp + -48 ]
40018bf4: c8 27 bf cc st %g4, [ %fp + -52 ]
40018bf8: da 27 bf c4 st %o5, [ %fp + -60 ]
40018bfc: 90 10 00 10 mov %l0, %o0
40018c00: 92 10 00 19 mov %i1, %o1
40018c04: 7f ff e7 17 call 40012860 <fat_file_read>
40018c08: 96 10 00 11 mov %l1, %o3
40018c0c: c4 1f bf d0 ldd [ %fp + -48 ], %g2
40018c10: 80 a2 20 00 cmp %o0, 0
40018c14: c8 07 bf cc ld [ %fp + -52 ], %g4
40018c18: 12 bf ff 0b bne 40018844 <msdos_find_name_in_fat_file+0x100>
40018c1c: da 07 bf c4 ld [ %fp + -60 ], %o5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
40018c20: 80 a0 a0 00 cmp %g2, 0
40018c24: 22 bf ff 23 be,a 400188b0 <msdos_find_name_in_fat_file+0x16c>
40018c28: 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)
40018c2c: 80 a7 60 02 cmp %i5, 2
40018c30: 12 80 00 2e bne 40018ce8 <msdos_find_name_in_fat_file+0x5a4>
40018c34: 80 a4 e0 00 cmp %l3, 0
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40018c38: 90 10 00 16 mov %l6, %o0
40018c3c: 7f ff a6 85 call 40002650 <.umul>
40018c40: 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 == '.'))
40018c44: 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;
40018c48: 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) /
40018c4c: 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 == '.'))
40018c50: 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) /
40018c54: 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 == '.'))
40018c58: 02 80 00 05 be 40018c6c <msdos_find_name_in_fat_file+0x528><== NEVER TAKEN
40018c5c: ba 07 40 08 add %i5, %o0, %i5
40018c60: 80 a0 a0 20 cmp %g2, 0x20
40018c64: 32 80 00 05 bne,a 40018c78 <msdos_find_name_in_fat_file+0x534>
40018c68: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
*c = '_';
40018c6c: 84 10 20 5f mov 0x5f, %g2
40018c70: 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 == '.'))
40018c74: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
40018c78: 80 a0 a0 2e cmp %g2, 0x2e
40018c7c: 22 80 00 06 be,a 40018c94 <msdos_find_name_in_fat_file+0x550><== NEVER TAKEN
40018c80: 84 10 20 5f mov 0x5f, %g2 <== NOT EXECUTED
40018c84: 80 a0 a0 20 cmp %g2, 0x20
40018c88: 12 80 00 05 bne 40018c9c <msdos_find_name_in_fat_file+0x558>
40018c8c: 86 05 20 02 add %l4, 2, %g3
*c = '_';
40018c90: 84 10 20 5f mov 0x5f, %g2
40018c94: 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++)
40018c98: 86 05 20 02 add %l4, 2, %g3
40018c9c: 84 10 20 00 clr %g2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40018ca0: 35 10 00 af sethi %hi(0x4002bc00), %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(
40018ca4: 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];
40018ca8: b8 16 a3 20 or %i2, 0x320, %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(
40018cac: 89 29 20 02 sll %g4, 2, %g4
40018cb0: 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];
40018cb4: 89 3f 40 04 sra %i5, %g4, %g4
40018cb8: 88 09 20 0f and %g4, 0xf, %g4
40018cbc: c8 0f 00 04 ldub [ %i4 + %g4 ], %g4
40018cc0: 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++)
40018cc4: 84 00 a0 01 inc %g2
40018cc8: 80 a0 a0 04 cmp %g2, 4
40018ccc: 12 bf ff f8 bne 40018cac <msdos_find_name_in_fat_file+0x568>
40018cd0: 88 20 00 02 neg %g2, %g4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
40018cd4: 84 10 20 7e mov 0x7e, %g2
40018cd8: c4 2d 20 06 stb %g2, [ %l4 + 6 ]
*c++ = '1';
40018cdc: 84 10 20 31 mov 0x31, %g2
40018ce0: 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)
40018ce4: 80 a4 e0 00 cmp %l3, 0
40018ce8: 02 80 00 10 be 40018d28 <msdos_find_name_in_fat_file+0x5e4>
40018cec: b8 10 20 00 clr %i4
40018cf0: 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 =
40018cf4: c8 0d 00 02 ldub [ %l4 + %g2 ], %g4
40018cf8: 86 0f 20 01 and %i4, 1, %g3
40018cfc: 80 a0 00 03 cmp %g0, %g3
40018d00: b8 0f 20 ff and %i4, 0xff, %i4
40018d04: 86 40 3f ff addx %g0, -1, %g3
40018d08: b9 37 20 01 srl %i4, 1, %i4
40018d0c: 86 08 e0 80 and %g3, 0x80, %g3
40018d10: b8 01 00 1c add %g4, %i4, %i4
40018d14: 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++)
40018d18: 84 00 a0 01 inc %g2
40018d1c: 80 a0 a0 0b cmp %g2, 0xb
40018d20: 12 bf ff f5 bne 40018cf4 <msdos_find_name_in_fat_file+0x5b0>
40018d24: 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)
40018d28: 80 a6 20 00 cmp %i0, 0
40018d2c: 22 80 00 06 be,a 40018d44 <msdos_find_name_in_fat_file+0x600>
40018d30: 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;
40018d34: 82 1e c0 16 xor %i3, %l6, %g1
40018d38: 80 a0 00 01 cmp %g0, %g1
40018d3c: 10 80 00 04 b 40018d4c <msdos_find_name_in_fat_file+0x608>
40018d40: 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;
40018d44: b4 10 20 01 mov 1, %i2
empty_space_offset = dir_offset;
empty_space_entry = 0;
40018d48: ae 10 20 00 clr %l7
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
40018d4c: 84 10 3f ff mov -1, %g2
40018d50: 90 10 00 16 mov %l6, %o0
40018d54: c4 27 bf fc st %g2, [ %fp + -4 ]
40018d58: c4 27 bf f8 st %g2, [ %fp + -8 ]
40018d5c: 7f ff a6 3d call 40002650 <.umul>
40018d60: 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(
40018d64: c6 07 a0 50 ld [ %fp + 0x50 ], %g3
40018d68: 83 2c e0 02 sll %l3, 2, %g1
40018d6c: 85 2c e0 04 sll %l3, 4, %g2
40018d70: 82 20 80 01 sub %g2, %g1, %g1
40018d74: 82 00 40 13 add %g1, %l3, %g1
40018d78: 82 00 c0 01 add %g3, %g1, %g1
40018d7c: ba 10 00 08 mov %o0, %i5
40018d80: 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;
40018d84: b0 10 20 00 clr %i0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
40018d88: 82 04 e0 01 add %l3, 1, %g1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
40018d8c: 10 80 00 ba b 40019074 <msdos_find_name_in_fat_file+0x930>
40018d90: c2 27 bf ec st %g1, [ %fp + -20 ]
{
int length = 0;
if (read_cluster)
40018d94: 02 80 00 2f be 40018e50 <msdos_find_name_in_fat_file+0x70c>
40018d98: 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,
40018d9c: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
40018da0: 90 10 00 10 mov %l0, %o0
40018da4: 92 10 00 19 mov %i1, %o1
40018da8: 94 10 00 1d mov %i5, %o2
40018dac: 7f ff e6 ad call 40012860 <fat_file_read>
40018db0: 96 10 00 11 mov %l1, %o3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
40018db4: 80 a2 00 11 cmp %o0, %l1
40018db8: 02 80 00 25 be 40018e4c <msdos_find_name_in_fat_file+0x708><== NEVER TAKEN
40018dbc: 80 a2 20 00 cmp %o0, 0
{
if (ret != FAT_EOF)
40018dc0: 22 80 00 03 be,a 40018dcc <msdos_find_name_in_fat_file+0x688><== ALWAYS TAKEN
40018dc4: 90 10 00 10 mov %l0, %o0
40018dc8: 30 80 00 1b b,a 40018e34 <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,
40018dcc: 92 10 00 19 mov %i1, %o1
40018dd0: 94 10 20 00 clr %o2
40018dd4: 96 10 00 1d mov %i5, %o3
40018dd8: 7f ff e7 b6 call 40012cb0 <fat_file_extend>
40018ddc: 98 07 bf f4 add %fp, -12, %o4
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
40018de0: 80 a2 20 00 cmp %o0, 0
40018de4: 12 80 00 a9 bne 40019088 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
40018de8: 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))
40018dec: 80 a0 40 1d cmp %g1, %i5
40018df0: 22 80 00 03 be,a 40018dfc <msdos_find_name_in_fat_file+0x6b8><== ALWAYS TAKEN
40018df4: d0 04 20 a0 ld [ %l0 + 0xa0 ], %o0
40018df8: 30 80 00 0f b,a 40018e34 <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
40018dfc: 92 10 20 00 clr %o1
40018e00: 40 00 0d b3 call 4001c4cc <memset>
40018e04: 94 10 00 11 mov %l1, %o2
ret = fat_file_write(&fs_info->fat, fat_fd,
40018e08: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
40018e0c: 90 10 00 10 mov %l0, %o0
40018e10: 92 10 00 19 mov %i1, %o1
40018e14: 94 10 00 1d mov %i5, %o2
40018e18: 7f ff e8 3c call 40012f08 <fat_file_write>
40018e1c: 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)
40018e20: 80 a2 3f ff cmp %o0, -1
40018e24: 02 80 00 99 be 40019088 <msdos_find_name_in_fat_file+0x944><== ALWAYS TAKEN
40018e28: 80 a2 00 11 cmp %o0, %l1
return ret;
else if (ret != bts2rd)
40018e2c: 02 80 00 09 be 40018e50 <msdos_find_name_in_fat_file+0x70c><== NOT EXECUTED
40018e30: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
40018e34: 40 00 0a c4 call 4001b944 <__errno> <== NOT EXECUTED
40018e38: 01 00 00 00 nop <== NOT EXECUTED
40018e3c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40018e40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40018e44: 10 80 00 91 b 40019088 <msdos_find_name_in_fat_file+0x944><== NOT EXECUTED
40018e48: 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(
40018e4c: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
40018e50: 83 2e 20 02 sll %i0, 2, %g1
40018e54: 97 2e 20 04 sll %i0, 4, %o3
40018e58: 84 06 20 01 add %i0, 1, %g2
40018e5c: 96 22 c0 01 sub %o3, %g1, %o3
40018e60: 9a 10 20 00 clr %o5
40018e64: 96 02 c0 18 add %o3, %i0, %o3
40018e68: b4 10 20 00 clr %i2
40018e6c: 96 20 c0 0b sub %g3, %o3, %o3
40018e70: 10 80 00 68 b 40019010 <msdos_find_name_in_fat_file+0x8cc>
40018e74: 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;
40018e78: 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))
40018e7c: 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;
40018e80: aa 03 00 1b add %o4, %i3, %l5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40018e84: 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))
40018e88: 80 a0 80 01 cmp %g2, %g1
40018e8c: 12 80 00 25 bne 40018f20 <msdos_find_name_in_fat_file+0x7dc>
40018e90: b0 10 00 02 mov %g2, %i0
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40018e94: 90 10 00 10 mov %l0, %o0
40018e98: 92 10 00 19 mov %i1, %o1
40018e9c: 94 10 20 01 mov 1, %o2
40018ea0: 96 10 00 1d mov %i5, %o3
40018ea4: 7f ff e7 4f call 40012be0 <fat_file_ioctl>
40018ea8: 98 10 00 12 mov %l2, %o4
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
40018eac: 80 a2 20 00 cmp %o0, 0
40018eb0: 12 80 00 76 bne 40019088 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
40018eb4: d2 07 bf f8 ld [ %fp + -8 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
40018eb8: 80 a2 7f ff cmp %o1, -1
40018ebc: 12 80 00 0c bne 40018eec <msdos_find_name_in_fat_file+0x7a8>
40018ec0: f6 24 a0 04 st %i3, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40018ec4: 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,
40018ec8: 90 10 00 15 mov %l5, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40018ecc: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
40018ed0: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40018ed4: 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;
40018ed8: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40018edc: 40 00 0d 3f call 4001c3d8 <memcpy>
40018ee0: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
40018ee4: 10 80 00 50 b 40019024 <msdos_find_name_in_fat_file+0x8e0>
40018ee8: 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,
40018eec: 7f ff a5 d9 call 40002650 <.umul>
40018ef0: 90 10 00 11 mov %l1, %o0
40018ef4: 92 10 00 19 mov %i1, %o1
40018ef8: 96 10 00 08 mov %o0, %o3
40018efc: 94 10 20 01 mov 1, %o2
40018f00: 90 10 00 10 mov %l0, %o0
40018f04: 7f ff e7 37 call 40012be0 <fat_file_ioctl>
40018f08: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
40018f0c: 80 a2 20 00 cmp %o0, 0
40018f10: 02 bf ff ee be 40018ec8 <msdos_find_name_in_fat_file+0x784><== ALWAYS TAKEN
40018f14: 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,
40018f18: 81 c7 e0 08 ret <== NOT EXECUTED
40018f1c: 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)
40018f20: c2 07 bf f8 ld [ %fp + -8 ], %g1
40018f24: 80 a0 7f ff cmp %g1, -1
40018f28: 32 80 00 05 bne,a 40018f3c <msdos_find_name_in_fat_file+0x7f8>
40018f2c: d8 3f bf c0 std %o4, [ %fp + -64 ]
{
lfn_start.cln = empty_space_offset;
40018f30: ec 27 bf f8 st %l6, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
40018f34: f6 27 bf fc st %i3, [ %fp + -4 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40018f38: d8 3f bf c0 std %o4, [ %fp + -64 ]
40018f3c: 94 10 20 20 mov 0x20, %o2
40018f40: c4 27 bf d0 st %g2, [ %fp + -48 ]
40018f44: d6 27 bf c8 st %o3, [ %fp + -56 ]
40018f48: 90 10 00 15 mov %l5, %o0
40018f4c: 40 00 0d 60 call 4001c4cc <memset>
40018f50: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
40018f54: 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(
40018f58: d6 07 bf c8 ld [ %fp + -56 ], %o3
40018f5c: 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++)
40018f60: d8 07 bf c0 ld [ %fp + -64 ], %o4
40018f64: 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;
40018f68: 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(
40018f6c: 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;
40018f70: 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++)
40018f74: b0 10 20 00 clr %i0
{
if (*n != 0)
40018f78: d0 4b c0 00 ldsb [ %o7 ], %o0
40018f7c: 80 a2 20 00 cmp %o0, 0
40018f80: 02 80 00 05 be 40018f94 <msdos_find_name_in_fat_file+0x850>
40018f84: d2 0b c0 00 ldub [ %o7 ], %o1
{
*p = *n;
40018f88: d2 28 40 00 stb %o1, [ %g1 ]
n++;
40018f8c: 10 80 00 05 b 40018fa0 <msdos_find_name_in_fat_file+0x85c>
40018f90: 9e 03 e0 01 inc %o7
}
else
{
p [0] = fill;
40018f94: d4 28 40 00 stb %o2, [ %g1 ]
p [1] = fill;
40018f98: d4 28 60 01 stb %o2, [ %g1 + 1 ]
fill = 0xff;
40018f9c: 94 10 3f ff mov -1, %o2
}
switch (i)
40018fa0: 80 a6 20 04 cmp %i0, 4
40018fa4: 02 80 00 06 be 40018fbc <msdos_find_name_in_fat_file+0x878>
40018fa8: 80 a6 20 0a cmp %i0, 0xa
40018fac: 32 80 00 08 bne,a 40018fcc <msdos_find_name_in_fat_file+0x888>
40018fb0: 82 00 60 02 add %g1, 2, %g1
{
case 4:
p += 5;
break;
case 10:
p += 4;
40018fb4: 10 80 00 04 b 40018fc4 <msdos_find_name_in_fat_file+0x880>
40018fb8: 82 00 60 04 add %g1, 4, %g1
switch (i)
{
case 4:
p += 5;
break;
40018fbc: 10 80 00 04 b 40018fcc <msdos_find_name_in_fat_file+0x888>
40018fc0: 82 00 60 05 add %g1, 5, %g1
case 10:
p += 4;
break;
40018fc4: 10 80 00 03 b 40018fd0 <msdos_find_name_in_fat_file+0x88c>
40018fc8: 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++)
40018fcc: b0 06 20 01 inc %i0
40018fd0: 80 a6 20 0d cmp %i0, 0xd
40018fd4: 32 bf ff ea bne,a 40018f7c <msdos_find_name_in_fat_file+0x838>
40018fd8: 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(
40018fdc: c6 07 bf ec ld [ %fp + -20 ], %g3
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
40018fe0: 80 a0 a0 01 cmp %g2, 1
40018fe4: 02 80 00 04 be 40018ff4 <msdos_find_name_in_fat_file+0x8b0>
40018fe8: 82 20 c0 02 sub %g3, %g2, %g1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
40018fec: 10 80 00 04 b 40018ffc <msdos_find_name_in_fat_file+0x8b8>
40018ff0: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
40018ff4: 82 10 60 40 or %g1, 0x40, %g1
40018ff8: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
40018ffc: c2 0d 60 0b ldub [ %l5 + 0xb ], %g1
40019000: 84 00 a0 01 inc %g2
40019004: 82 10 60 0f or %g1, 0xf, %g1
40019008: 9a 03 7f f3 add %o5, -13, %o5
4001900c: 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(
40019010: 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;
40019014: 80 a6 c0 11 cmp %i3, %l1
40019018: 0a bf ff 98 bcs 40018e78 <msdos_find_name_in_fat_file+0x734><== ALWAYS TAKEN
4001901c: 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,
40019020: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4 <== NOT EXECUTED
40019024: 90 10 00 10 mov %l0, %o0
40019028: 92 10 00 19 mov %i1, %o1
4001902c: 94 07 40 17 add %i5, %l7, %o2
40019030: 96 10 00 1a mov %i2, %o3
40019034: 7f ff e7 b5 call 40012f08 <fat_file_write>
40019038: 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)
4001903c: 80 a2 3f ff cmp %o0, -1
40019040: 02 80 00 14 be 40019090 <msdos_find_name_in_fat_file+0x94c><== NEVER TAKEN
40019044: 80 a2 00 1a cmp %o0, %i2
return ret;
else if (ret != length)
40019048: 02 80 00 08 be 40019068 <msdos_find_name_in_fat_file+0x924><== ALWAYS TAKEN
4001904c: ba 07 40 11 add %i5, %l1, %i5
rtems_set_errno_and_return_minus_one(EIO);
40019050: 40 00 0a 3d call 4001b944 <__errno> <== NOT EXECUTED
40019054: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40019058: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001905c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40019060: 81 c7 e0 08 ret <== NOT EXECUTED
40019064: 81 e8 00 00 restore <== NOT EXECUTED
empty_space_offset++;
40019068: ac 05 a0 01 inc %l6
empty_space_entry = 0;
4001906c: ae 10 20 00 clr %l7
read_cluster = true;
40019070: b4 10 20 01 mov 1, %i2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
40019074: 80 a4 c0 18 cmp %l3, %i0
40019078: 16 bf ff 47 bge 40018d94 <msdos_find_name_in_fat_file+0x650>
4001907c: 80 8e a0 ff btst 0xff, %i2
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
40019080: 81 c7 e0 08 ret
40019084: 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,
40019088: 81 c7 e0 08 ret
4001908c: 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)
40019090: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40019094: 81 c7 e0 08 ret <== NOT EXECUTED
40019098: 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 ||
4001909c: 80 a0 60 00 cmp %g1, 0
400190a0: 02 bf fe c8 be 40018bc0 <msdos_find_name_in_fat_file+0x47c>
400190a4: 82 10 3f ff mov -1, %g1
((name_type == MSDOS_NAME_SHORT) &&
400190a8: 10 bf fe 9c b 40018b18 <msdos_find_name_in_fat_file+0x3d4>
400190ac: de 07 bf f8 ld [ %fp + -8 ], %o7
400190b0 <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
)
{
400190b0: 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) &&
400190b4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400190b8: 80 a0 60 01 cmp %g1, 1
400190bc: 12 80 00 0f bne 400190f8 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
400190c0: fa 06 20 08 ld [ %i0 + 8 ], %i5
400190c4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
400190c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400190cc: 32 80 00 07 bne,a 400190e8 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
400190d0: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
400190d4: 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) &&
400190d8: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
400190dc: 22 80 00 03 be,a 400190e8 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
400190e0: 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;
400190e4: 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)
400190e8: 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;
400190ec: 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)
400190f0: 10 80 00 44 b 40019200 <msdos_find_node_by_cluster_num_in_fat_file+0x150>
400190f4: 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;
400190f8: 10 bf ff fc b 400190e8 <msdos_find_node_by_cluster_num_in_fat_file+0x38>
400190fc: 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 )
40019100: 14 80 00 08 bg 40019120 <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
40019104: 80 a2 00 18 cmp %o0, %i0
rtems_set_errno_and_return_minus_one( EIO );
40019108: 40 00 0a 0f call 4001b944 <__errno> <== NOT EXECUTED
4001910c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40019110: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40019114: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40019118: 81 c7 e0 08 ret <== NOT EXECUTED
4001911c: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
40019120: 22 80 00 0a be,a 40019148 <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
40019124: e0 07 60 a0 ld [ %i5 + 0xa0 ], %l0
40019128: 11 10 00 b1 sethi %hi(0x4002c400), %o0 <== NOT EXECUTED
4001912c: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
40019130: 17 10 00 b1 sethi %hi(0x4002c400), %o3 <== NOT EXECUTED
40019134: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
40019138: 92 10 26 4e mov 0x64e, %o1 <== NOT EXECUTED
4001913c: 94 12 a0 48 or %o2, 0x48, %o2 <== NOT EXECUTED
40019140: 7f ff b2 20 call 400059c0 <__assert_func> <== NOT EXECUTED
40019144: 96 12 e3 f8 or %o3, 0x3f8, %o3 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
40019148: a4 10 20 00 clr %l2
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001914c: c2 0c 00 00 ldub [ %l0 ], %g1
40019150: 80 a0 60 00 cmp %g1, 0
40019154: 02 80 00 34 be 40019224 <msdos_find_node_by_cluster_num_in_fat_file+0x174><== NEVER TAKEN
40019158: 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)) ==
4001915c: 22 80 00 25 be,a 400191f0 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
40019160: 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)
40019164: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
40019168: c2 14 20 1a lduh [ %l0 + 0x1a ], %g1
4001916c: 85 28 a0 10 sll %g2, 0x10, %g2
40019170: 87 30 a0 18 srl %g2, 0x18, %g3
40019174: 83 28 60 10 sll %g1, 0x10, %g1
40019178: 85 30 a0 08 srl %g2, 8, %g2
4001917c: 84 08 80 13 and %g2, %l3, %g2
40019180: 84 10 c0 02 or %g3, %g2, %g2
40019184: 87 30 60 18 srl %g1, 0x18, %g3
40019188: 85 28 a0 10 sll %g2, 0x10, %g2
4001918c: 83 30 60 08 srl %g1, 8, %g1
40019190: 82 08 40 13 and %g1, %l3, %g1
40019194: 82 10 c0 01 or %g3, %g1, %g1
40019198: 82 10 80 01 or %g2, %g1, %g1
4001919c: 80 a0 40 1a cmp %g1, %i2
400191a0: 32 80 00 14 bne,a 400191f0 <msdos_find_node_by_cluster_num_in_fat_file+0x140>
400191a4: 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,
400191a8: 90 10 00 1d mov %i5, %o0
400191ac: 92 10 00 19 mov %i1, %o1
400191b0: 94 10 20 01 mov 1, %o2
400191b4: 96 10 00 11 mov %l1, %o3
400191b8: 7f ff e6 8a call 40012be0 <fat_file_ioctl>
400191bc: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
400191c0: b0 92 20 00 orcc %o0, 0, %i0
400191c4: 12 bf ff d5 bne 40019118 <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
400191c8: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
400191cc: e4 26 e0 04 st %l2, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400191d0: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
400191d4: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
400191d8: 90 10 00 1c mov %i4, %o0
400191dc: 92 10 00 10 mov %l0, %o1
400191e0: 40 00 0c 7e call 4001c3d8 <memcpy>
400191e4: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
400191e8: 81 c7 e0 08 ret
400191ec: 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)
400191f0: 80 a4 80 18 cmp %l2, %i0
400191f4: 0a bf ff d6 bcs 4001914c <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
400191f8: a0 04 20 20 add %l0, 0x20, %l0
400191fc: 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,
40019200: d8 07 60 a0 ld [ %i5 + 0xa0 ], %o4
40019204: 90 10 00 1d mov %i5, %o0
40019208: 92 10 00 19 mov %i1, %o1
4001920c: 94 10 00 11 mov %l1, %o2
40019210: 7f ff e5 94 call 40012860 <fat_file_read>
40019214: 96 10 00 18 mov %i0, %o3
40019218: 80 a2 20 00 cmp %o0, 0
4001921c: 12 bf ff b9 bne 40019100 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
40019220: 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;
40019224: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
40019228: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
4001922c: 81 c7 e0 08 ret <== NOT EXECUTED
40019230: 81 e8 00 00 restore <== NOT EXECUTED
4000ddb0 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000ddb0: 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");
4000ddb4: 92 10 20 02 mov 2, %o1
4000ddb8: 90 10 00 19 mov %i1, %o0
4000ddbc: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000ddc0: 7f ff ff 60 call 4000db40 <msdos_format_printf>
4000ddc4: 94 12 a1 20 or %o2, 0x120, %o2 ! 4002c120 <_CPU_Trap_slot_template+0x68>
fd = open(devname, O_RDWR);
4000ddc8: 92 10 20 02 mov 2, %o1
4000ddcc: 7f ff e2 b4 call 4000689c <open>
4000ddd0: 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;
4000ddd4: 82 38 00 08 xnor %g0, %o0, %g1
4000ddd8: 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);
4000dddc: 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;
4000dde0: b6 40 3f ff addx %g0, -1, %i3
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dde4: 90 10 00 19 mov %i1, %o0
4000dde8: 92 10 20 02 mov 2, %o1
4000ddec: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000ddf0: 96 10 00 18 mov %i0, %o3
4000ddf4: 7f ff ff 53 call 4000db40 <msdos_format_printf>
4000ddf8: 94 12 a1 30 or %o2, 0x130, %o2
"stat check: %s\n", devname);
if (ret_val == 0) {
4000ddfc: 80 a6 e0 00 cmp %i3, 0
4000de00: 12 80 00 06 bne 4000de18 <msdos_format+0x68> <== NEVER TAKEN
4000de04: ba 10 3f ff mov -1, %i5
ret_val = fstat(fd, &stat_buf);
4000de08: 90 10 00 1c mov %i4, %o0
4000de0c: 7f ff df 7d call 40005c00 <fstat>
4000de10: 92 07 bd 60 add %fp, -672, %o1
4000de14: ba 10 00 08 mov %o0, %i5
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000de18: 90 10 00 19 mov %i1, %o0
4000de1c: 92 10 20 01 mov 1, %o1
4000de20: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000de24: 96 10 00 18 mov %i0, %o3
4000de28: 7f ff ff 46 call 4000db40 <msdos_format_printf>
4000de2c: 94 12 a1 40 or %o2, 0x140, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4000de30: 80 a7 60 00 cmp %i5, 0
4000de34: 12 80 02 0d bne 4000e668 <msdos_format+0x8b8> <== NEVER TAKEN
4000de38: 80 a0 00 19 cmp %g0, %i1
4000de3c: c4 07 bd 6c ld [ %fp + -660 ], %g2
4000de40: 03 00 00 3c sethi %hi(0xf000), %g1
4000de44: 84 08 80 01 and %g2, %g1, %g2
4000de48: 03 00 00 18 sethi %hi(0x6000), %g1
4000de4c: 80 a0 80 01 cmp %g2, %g1
4000de50: 02 80 03 7d be 4000ec44 <msdos_format+0xe94> <== ALWAYS TAKEN
4000de54: 92 10 20 00 clr %o1
errno = ENOTTY;
4000de58: 40 00 36 bb call 4001b944 <__errno> <== NOT EXECUTED
4000de5c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4000de60: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
4000de64: 10 80 02 00 b 4000e664 <msdos_format+0x8b4> <== NOT EXECUTED
4000de68: 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);
4000de6c: 92 16 e2 05 or %i3, 0x205, %o1
4000de70: 40 00 1c 04 call 40014e80 <ioctl>
4000de74: 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) {
4000de78: ba 92 20 00 orcc %o0, 0, %i5
4000de7c: 12 80 01 67 bne 4000e418 <msdos_format+0x668> <== NEVER TAKEN
4000de80: f0 07 bd ac ld [ %fp + -596 ], %i0
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000de84: fa 07 bd b0 ld [ %fp + -592 ], %i5
4000de88: 92 10 00 18 mov %i0, %o1
4000de8c: 7f ff d1 f1 call 40002650 <.umul>
4000de90: 90 10 00 1d mov %i5, %o0
4000de94: b4 10 20 00 clr %i2
4000de98: b6 10 00 08 mov %o0, %i3
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000de9c: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
4000dea0: f4 3f bd 58 std %i2, [ %fp + -680 ]
4000dea4: 9a 10 20 00 clr %o5
4000dea8: 90 10 00 19 mov %i1, %o0
4000deac: 92 10 20 02 mov 2, %o1
4000deb0: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000deb4: 96 10 00 18 mov %i0, %o3
4000deb8: 94 12 a1 50 or %o2, 0x150, %o2
4000debc: 7f ff ff 21 call 4000db40 <msdos_format_printf>
4000dec0: 98 10 00 1d mov %i5, %o4
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000dec4: 80 a6 60 00 cmp %i1, 0
4000dec8: 02 80 00 0a be 4000def0 <msdos_format+0x140>
4000decc: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
4000ded0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000ded4: 80 a0 60 00 cmp %g1, 0
4000ded8: 12 80 00 04 bne 4000dee8 <msdos_format+0x138>
4000dedc: 80 a0 60 06 cmp %g1, 6
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
4000dee0: 10 80 00 04 b 4000def0 <msdos_format+0x140>
4000dee4: 82 10 20 02 mov 2, %g1
}
else if (rqdata->fat_num <= 6) {
4000dee8: 18 80 00 04 bgu 4000def8 <msdos_format+0x148>
4000deec: 01 00 00 00 nop
fmt_params->fat_num = rqdata->fat_num;
4000def0: 10 80 03 62 b 4000ec78 <msdos_format+0xec8>
4000def4: c2 2f bd dc stb %g1, [ %fp + -548 ]
}
else {
errno = EINVAL;
4000def8: 40 00 36 93 call 4001b944 <__errno>
4000defc: ba 10 3f ff mov -1, %i5
4000df00: 82 10 20 16 mov 0x16, %g1
4000df04: 10 80 01 45 b 4000e418 <msdos_format+0x668>
4000df08: 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) {
4000df0c: 84 90 60 00 orcc %g1, 0, %g2
4000df10: 12 80 00 05 bne 4000df24 <msdos_format+0x174>
4000df14: 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;
4000df18: 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;
4000df1c: 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) {
4000df20: c6 07 bd b0 ld [ %fp + -592 ], %g3
4000df24: 89 28 60 02 sll %g1, 2, %g4
4000df28: bb 28 60 0a sll %g1, 0xa, %i5
4000df2c: 88 27 40 04 sub %i5, %g4, %g4
4000df30: 88 01 00 01 add %g4, %g1, %g4
4000df34: 89 29 20 02 sll %g4, 2, %g4
4000df38: 82 01 00 01 add %g4, %g1, %g1
4000df3c: 80 a0 c0 01 cmp %g3, %g1
4000df40: 3a 80 00 04 bcc,a 4000df50 <msdos_format+0x1a0>
4000df44: 83 28 a0 02 sll %g2, 2, %g1
fmt_params->fattype = FAT_FAT12;
4000df48: 10 80 00 0b b 4000df74 <msdos_format+0x1c4>
4000df4c: 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) {
4000df50: 89 28 a0 0e sll %g2, 0xe, %g4
4000df54: 82 21 00 01 sub %g4, %g1, %g1
4000df58: 82 00 40 02 add %g1, %g2, %g1
4000df5c: 83 28 60 02 sll %g1, 2, %g1
4000df60: 84 00 40 02 add %g1, %g2, %g2
4000df64: 80 a0 c0 02 cmp %g3, %g2
4000df68: 1a 80 00 06 bcc 4000df80 <msdos_format+0x1d0>
4000df6c: 1b 10 00 00 sethi %hi(0x40000000), %o5
fmt_params->fattype = FAT_FAT16;
4000df70: 82 10 20 02 mov 2, %g1
4000df74: c2 2f bd de stb %g1, [ %fp + -546 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000df78: 10 80 00 15 b 4000dfcc <msdos_format+0x21c>
4000df7c: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4000df80: 86 86 c0 0d addcc %i3, %o5, %g3
4000df84: 83 30 e0 1e srl %g3, 0x1e, %g1
4000df88: 98 10 20 00 clr %o4
4000df8c: 84 46 80 0c addx %i2, %o4, %g2
4000df90: 85 28 a0 02 sll %g2, 2, %g2
4000df94: 84 10 80 01 or %g2, %g1, %g2
int b;
fmt_params->fattype = FAT_FAT32;
4000df98: 82 10 20 04 mov 4, %g1
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4000df9c: 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;
4000dfa0: c2 2f bd de stb %g1, [ %fp + -546 ]
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4000dfa4: 82 10 20 1f mov 0x1f, %g1
if ((gigs & (1 << b)) != 0)
4000dfa8: 89 28 c0 01 sll %g3, %g1, %g4
4000dfac: 80 89 00 02 btst %g4, %g2
4000dfb0: 32 80 00 06 bne,a 4000dfc8 <msdos_format+0x218>
4000dfb4: 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--)
4000dfb8: 82 80 7f ff addcc %g1, -1, %g1
4000dfbc: 12 bf ff fc bne 4000dfac <msdos_format+0x1fc>
4000dfc0: 89 28 c0 01 sll %g3, %g1, %g4
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
4000dfc4: 84 10 20 01 mov 1, %g2
4000dfc8: 83 28 80 01 sll %g2, %g1, %g1
4000dfcc: c2 27 bd b8 st %g1, [ %fp + -584 ]
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
4000dfd0: 90 10 00 19 mov %i1, %o0
4000dfd4: 7f ff ff 53 call 4000dd20 <msdos_set_sectors_per_cluster_from_request>
4000dfd8: 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;
4000dfdc: 98 10 20 00 clr %o4
4000dfe0: 1b 10 00 00 sethi %hi(0x40000000), %o5
4000dfe4: 86 86 c0 0d addcc %i3, %o5, %g3
4000dfe8: 84 46 80 0c addx %i2, %o4, %g2
4000dfec: 83 30 e0 1e srl %g3, 0x1e, %g1
4000dff0: 85 28 a0 02 sll %g2, 2, %g2
4000dff4: 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)
4000dff8: 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;
4000dffc: 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 );
4000e000: 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)
4000e004: 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;
4000e008: b4 10 3f ff mov -1, %i2
4000e00c: 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)
4000e010: 10 80 00 f8 b 4000e3f0 <msdos_format+0x640>
4000e014: c2 27 bd 48 st %g1, [ %fp + -696 ]
4000e018: 80 a1 20 00 cmp %g4, 0
4000e01c: 02 80 00 05 be 4000e030 <msdos_format+0x280>
4000e020: d6 07 bd b8 ld [ %fp + -584 ], %o3
fmt_params->skip_alignment = rqdata->skip_alignment;
4000e024: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
4000e028: c2 2f bd fc stb %g1, [ %fp + -516 ]
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000e02c: d6 07 bd b8 ld [ %fp + -584 ], %o3
4000e030: 90 10 00 19 mov %i1, %o0
4000e034: 92 10 20 02 mov 2, %o1
4000e038: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000e03c: 7f ff fe c1 call 4000db40 <msdos_format_printf>
4000e040: 94 12 a1 90 or %o2, 0x190, %o2 ! 4002c190 <_CPU_Trap_slot_template+0xd8>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
4000e044: f4 0f bd de ldub [ %fp + -546 ], %i2
4000e048: 82 0e a0 ff and %i2, 0xff, %g1
4000e04c: 80 a0 60 04 cmp %g1, 4
4000e050: 12 80 00 0a bne 4000e078 <msdos_format+0x2c8>
4000e054: 82 10 20 01 mov 1, %g1
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4000e058: 82 10 20 20 mov 0x20, %g1
4000e05c: 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;
4000e060: 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;
4000e064: c0 27 bd c4 clr [ %fp + -572 ]
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4000e068: c2 27 bd d4 st %g1, [ %fp + -556 ]
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4000e06c: 82 10 20 01 mov 1, %g1
4000e070: 10 80 00 1c b 4000e0e0 <msdos_format+0x330>
4000e074: 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;
4000e078: 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) &&
4000e07c: c2 07 bd 48 ld [ %fp + -696 ], %g1
4000e080: 80 a0 60 00 cmp %g1, 0
4000e084: 02 80 00 08 be 4000e0a4 <msdos_format+0x2f4>
4000e088: 82 0e a0 ff and %i2, 0xff, %g1
(rqdata->files_per_root_dir > 0)) {
4000e08c: 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) &&
4000e090: 80 a0 60 00 cmp %g1, 0
4000e094: 22 80 00 04 be,a 4000e0a4 <msdos_format+0x2f4>
4000e098: 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;
4000e09c: 10 80 00 07 b 4000e0b8 <msdos_format+0x308>
4000e0a0: 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) {
4000e0a4: 80 a0 60 02 cmp %g1, 2
4000e0a8: 32 80 00 03 bne,a 4000e0b4 <msdos_format+0x304>
4000e0ac: 82 10 20 40 mov 0x40, %g1
4000e0b0: 82 10 22 00 mov 0x200, %g1
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
4000e0b4: 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/
4000e0b8: 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 +
4000e0bc: f6 07 bd c4 ld [ %fp + -572 ], %i3
(2*fmt_params->bytes_per_sector/
4000e0c0: 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 +
4000e0c4: b6 06 ff ff add %i3, -1, %i3
(2*fmt_params->bytes_per_sector/
4000e0c8: 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 +
4000e0cc: 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 %
4000e0d0: 40 00 6a 99 call 40028b34 <.urem>
4000e0d4: 90 10 00 1b mov %i3, %o0
4000e0d8: 90 26 c0 08 sub %i3, %o0, %o0
4000e0dc: 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)
4000e0e0: 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)
4000e0e4: d0 07 bd c4 ld [ %fp + -572 ], %o0
+ fmt_params->bytes_per_sector - 1)
4000e0e8: 88 06 ff ff add %i3, -1, %g4
/ fmt_params->bytes_per_sector);
4000e0ec: 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)
4000e0f0: 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)
4000e0f4: 91 2a 20 05 sll %o0, 5, %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
4000e0f8: 7f ff d1 90 call 40002738 <.udiv>
4000e0fc: 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,
4000e100: c2 07 bd b0 ld [ %fp + -592 ], %g1
4000e104: 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);
4000e108: 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 =
4000e10c: 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,
4000e110: b0 0e a0 ff and %i2, 0xff, %i0
4000e114: c2 27 bd 44 st %g1, [ %fp + -700 ]
4000e118: c8 27 bd 50 st %g4, [ %fp + -688 ]
4000e11c: ea 0f bd dc ldub [ %fp + -548 ], %l5
4000e120: ec 07 bd b8 ld [ %fp + -584 ], %l6
4000e124: 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) {
4000e128: 92 10 00 1b mov %i3, %o1
4000e12c: 7f ff d1 83 call 40002738 <.udiv>
4000e130: 11 00 00 20 sethi %hi(0x8000), %o0
4000e134: 10 80 00 03 b 4000e140 <msdos_format+0x390>
4000e138: 80 a2 00 16 cmp %o0, %l6
4000e13c: 80 a2 00 16 cmp %o0, %l6 <== NOT EXECUTED
4000e140: 2a bf ff ff bcs,a 4000e13c <msdos_format+0x38c> <== NEVER TAKEN
4000e144: 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);
4000e148: 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,
4000e14c: 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);
4000e150: 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)
4000e154: a6 0c e0 ff and %l3, 0xff, %l3
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e158: c2 27 bd 3c st %g1, [ %fp + -708 ]
4000e15c: 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,
4000e160: 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)
4000e164: 80 a4 e0 00 cmp %l3, 0
4000e168: 12 80 00 06 bne 4000e180 <msdos_format+0x3d0>
4000e16c: d0 07 bd 50 ld [ %fp + -688 ], %o0
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e170: c8 07 bd 3c ld [ %fp + -708 ], %g4
4000e174: 90 20 00 16 neg %l6, %o0
4000e178: 84 01 00 16 add %g4, %l6, %g2
4000e17c: 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
4000e180: c2 07 bd 44 ld [ %fp + -700 ], %g1
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
4000e184: 80 a6 20 01 cmp %i0, 1
4000e188: 12 80 00 10 bne 4000e1c8 <msdos_format+0x418>
4000e18c: 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)
4000e190: 80 a4 e0 00 cmp %l3, 0
4000e194: 12 80 00 05 bne 4000e1a8 <msdos_format+0x3f8>
4000e198: 84 10 00 12 mov %l2, %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e19c: 84 05 c0 16 add %l7, %l6, %g2
4000e1a0: 86 20 00 16 neg %l6, %g3
4000e1a4: 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;
4000e1a8: 90 22 00 02 sub %o0, %g2, %o0
4000e1ac: 7f ff d1 63 call 40002738 <.udiv>
4000e1b0: 92 10 00 16 mov %l6, %o1
4000e1b4: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 3 / 2;
4000e1b8: 91 2a 20 01 sll %o0, 1, %o0
4000e1bc: 90 02 00 10 add %o0, %l0, %o0
4000e1c0: 10 80 00 14 b 4000e210 <msdos_format+0x460>
4000e1c4: 91 32 20 01 srl %o0, 1, %o0
}
else if (fattype == FAT_FAT16) {
4000e1c8: 80 a6 20 02 cmp %i0, 2
4000e1cc: 12 80 00 0d bne 4000e200 <msdos_format+0x450>
4000e1d0: 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)
4000e1d4: 12 80 00 05 bne 4000e1e8 <msdos_format+0x438>
4000e1d8: 84 10 00 12 mov %l2, %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e1dc: 84 05 c0 16 add %l7, %l6, %g2
4000e1e0: 86 20 00 16 neg %l6, %g3
4000e1e4: 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;
4000e1e8: 90 22 00 02 sub %o0, %g2, %o0
4000e1ec: 7f ff d1 53 call 40002738 <.udiv>
4000e1f0: 92 10 00 16 mov %l6, %o1
4000e1f4: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 2;
4000e1f8: 10 80 00 06 b 4000e210 <msdos_format+0x460>
4000e1fc: 91 2a 20 01 sll %o0, 1, %o0
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
4000e200: 7f ff d1 4e call 40002738 <.udiv>
4000e204: 92 10 00 16 mov %l6, %o1
4000e208: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 4;
4000e20c: 91 2a 20 02 sll %o0, 2, %o0
}
sectors_per_fat = ((fat_capacity
4000e210: c8 07 bd 54 ld [ %fp + -684 ], %g4
4000e214: 92 10 00 1b mov %i3, %o1
4000e218: 7f ff d1 48 call 40002738 <.udiv>
4000e21c: 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,
4000e220: 7f ff d1 0c call 40002650 <.umul>
4000e224: 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)
4000e228: 80 a4 e0 00 cmp %l3, 0
4000e22c: 12 80 00 06 bne 4000e244 <msdos_format+0x494>
4000e230: a2 10 00 08 mov %o0, %l1
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e234: 84 05 bf ff add %l6, -1, %g2
4000e238: a2 00 80 08 add %g2, %o0, %l1
4000e23c: 84 20 00 16 neg %l6, %g2
4000e240: 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))
4000e244: 90 05 bf ff add %l6, -1, %o0
/ sectors_per_cluster));
4000e248: 92 10 00 16 mov %l6, %o1
4000e24c: 7f ff d1 3b call 40002738 <.udiv>
4000e250: 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)) ||
4000e254: 80 a6 20 01 cmp %i0, 1
4000e258: 12 80 00 07 bne 4000e274 <msdos_format+0x4c4>
4000e25c: a0 24 00 08 sub %l0, %o0, %l0
4000e260: 80 a4 2f f5 cmp %l0, 0xff5
4000e264: 08 80 00 10 bleu 4000e2a4 <msdos_format+0x4f4>
4000e268: aa 10 20 01 mov 1, %l5
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
4000e26c: 10 80 00 0b b 4000e298 <msdos_format+0x4e8>
4000e270: 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)) ||
4000e274: 80 a6 20 02 cmp %i0, 2
4000e278: 12 80 00 11 bne 4000e2bc <msdos_format+0x50c>
4000e27c: aa 10 20 01 mov 1, %l5
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
4000e280: 03 00 00 3f sethi %hi(0xfc00), %g1
4000e284: 82 10 63 f5 or %g1, 0x3f5, %g1 ! fff5 <PROM_START+0xfff5>
4000e288: 80 a4 00 01 cmp %l0, %g1
4000e28c: 08 80 00 0d bleu 4000e2c0 <msdos_format+0x510>
4000e290: 90 10 00 16 mov %l6, %o0
sectors_per_cluster *= 2;
4000e294: 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) {
4000e298: 80 a6 20 01 cmp %i0, 1
4000e29c: 12 80 00 08 bne 4000e2bc <msdos_format+0x50c>
4000e2a0: aa 10 20 00 clr %l5
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
4000e2a4: 90 10 00 16 mov %l6, %o0
4000e2a8: 7f ff d0 ea call 40002650 <.umul>
4000e2ac: 92 10 00 1b mov %i3, %o1
4000e2b0: 09 00 00 04 sethi %hi(0x1000), %g4
4000e2b4: 10 80 00 07 b 4000e2d0 <msdos_format+0x520>
4000e2b8: 80 a2 00 04 cmp %o0, %g4
finished = true;
}
} else if ((sectors_per_cluster * bytes_per_sector)
4000e2bc: 90 10 00 16 mov %l6, %o0
4000e2c0: 7f ff d0 e4 call 40002650 <.umul>
4000e2c4: 92 10 00 1b mov %i3, %o1
4000e2c8: 03 00 00 20 sethi %hi(0x8000), %g1
4000e2cc: 80 a2 00 01 cmp %o0, %g1
4000e2d0: 38 80 00 06 bgu,a 4000e2e8 <msdos_format+0x538>
4000e2d4: d2 07 bd 4c ld [ %fp + -692 ], %o1
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
4000e2d8: 80 8d 60 ff btst 0xff, %l5
4000e2dc: 02 bf ff a3 be 4000e168 <msdos_format+0x3b8>
4000e2e0: 80 a4 e0 00 cmp %l3, 0
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000e2e4: d2 07 bd 4c ld [ %fp + -692 ], %o1
4000e2e8: 7f ff d1 14 call 40002738 <.udiv>
4000e2ec: 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 =
4000e2f0: 09 10 00 b0 sethi %hi(0x4002c000), %g4
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000e2f4: 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 =
4000e2f8: d0 01 22 50 ld [ %g4 + 0x250 ], %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;
4000e2fc: 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 =
4000e300: 7f ff d1 0e call 40002738 <.udiv>
4000e304: 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
4000e308: 80 a2 00 16 cmp %o0, %l6
4000e30c: 2a 80 00 06 bcs,a 4000e324 <msdos_format+0x574>
4000e310: 11 00 00 20 sethi %hi(0x8000), %o0
4000e314: 80 a4 2f f4 cmp %l0, 0xff4
4000e318: 08 80 00 0f bleu 4000e354 <msdos_format+0x5a4>
4000e31c: 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 =
4000e320: 11 00 00 20 sethi %hi(0x8000), %o0
4000e324: 92 10 00 1b mov %i3, %o1
4000e328: 7f ff d1 04 call 40002738 <.udiv>
4000e32c: 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
4000e330: 80 a2 00 16 cmp %o0, %l6
4000e334: 2a 80 00 08 bcs,a 4000e354 <msdos_format+0x5a4>
4000e338: 84 10 20 04 mov 4, %g2
4000e33c: 03 00 00 3f sethi %hi(0xfc00), %g1
4000e340: 82 10 63 f4 or %g1, 0x3f4, %g1 ! fff4 <PROM_START+0xfff4>
4000e344: 80 a0 40 10 cmp %g1, %l0
4000e348: 1a 80 00 03 bcc 4000e354 <msdos_format+0x5a4>
4000e34c: 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;
4000e350: 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) {
4000e354: 86 0e a0 ff and %i2, 0xff, %g3
4000e358: 82 08 a0 ff and %g2, 0xff, %g1
4000e35c: 80 a0 c0 01 cmp %g3, %g1
4000e360: 02 80 00 19 be 4000e3c4 <msdos_format+0x614>
4000e364: 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 ) {
4000e368: 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
4000e36c: 82 10 20 1f mov 0x1f, %g1
4000e370: 84 08 a0 ff and %g2, 0xff, %g2
4000e374: 80 a0 a0 01 cmp %g2, 1
4000e378: 18 80 00 04 bgu 4000e388 <msdos_format+0x5d8>
4000e37c: 86 10 20 01 mov 1, %g3
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000e380: 10 80 00 0c b 4000e3b0 <msdos_format+0x600>
4000e384: 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 )
4000e388: c8 07 bd 40 ld [ %fp + -704 ], %g4
4000e38c: 85 28 c0 01 sll %g3, %g1, %g2
4000e390: 80 88 80 04 btst %g2, %g4
4000e394: 12 80 00 06 bne 4000e3ac <msdos_format+0x5fc>
4000e398: 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-- ) {
4000e39c: 82 80 7f ff addcc %g1, -1, %g1
4000e3a0: 12 bf ff fc bne 4000e390 <msdos_format+0x5e0> <== ALWAYS TAKEN
4000e3a4: 85 28 c0 01 sll %g3, %g1, %g2
if ( (gigs & ( 1 << b) ) != 0 )
break;
}
fmt_params->sectors_per_cluster = 1 << b;
4000e3a8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4000e3ac: 83 28 80 01 sll %g2, %g1, %g1
4000e3b0: 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,
4000e3b4: 90 10 00 19 mov %i1, %o0
4000e3b8: 7f ff fe 5a call 4000dd20 <msdos_set_sectors_per_cluster_from_request>
4000e3bc: 92 07 bd ac add %fp, -596, %o1
4000e3c0: ba 10 00 08 mov %o0, %i5
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
4000e3c4: c2 0f bd de ldub [ %fp + -546 ], %g1
4000e3c8: 84 0e a0 ff and %i2, 0xff, %g2
4000e3cc: 80 a0 80 01 cmp %g2, %g1
4000e3d0: 02 80 00 07 be 4000e3ec <msdos_format+0x63c>
4000e3d4: 82 0d 20 ff and %l4, 0xff, %g1
4000e3d8: 80 a0 60 01 cmp %g1, 1
4000e3dc: 08 80 00 04 bleu 4000e3ec <msdos_format+0x63c>
4000e3e0: c2 07 bd b0 ld [ %fp + -592 ], %g1
--fmt_params->totl_sector_cnt;
4000e3e4: 82 00 7f ff add %g1, -1, %g1
4000e3e8: c2 27 bd b0 st %g1, [ %fp + -592 ]
}
}
++iteration_cnt;
4000e3ec: 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
4000e3f0: 80 a7 60 00 cmp %i5, 0
4000e3f4: 12 80 00 09 bne 4000e418 <msdos_format+0x668> <== NEVER TAKEN
4000e3f8: c2 0f bd de ldub [ %fp + -546 ], %g1
&& fmt_params->fattype != fat_type
4000e3fc: b4 0e a0 ff and %i2, 0xff, %i2
4000e400: 80 a0 40 1a cmp %g1, %i2
4000e404: 02 80 00 05 be 4000e418 <msdos_format+0x668>
4000e408: c2 07 bd b0 ld [ %fp + -592 ], %g1
&& fmt_params->totl_sector_cnt > 0 ) {
4000e40c: 80 a0 60 00 cmp %g1, 0
4000e410: 12 bf ff 02 bne 4000e018 <msdos_format+0x268> <== ALWAYS TAKEN
4000e414: c8 07 bd 48 ld [ %fp + -696 ], %g4
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000e418: c2 07 bd b0 ld [ %fp + -592 ], %g1
4000e41c: 80 a0 60 00 cmp %g1, 0
4000e420: 02 80 00 2f be 4000e4dc <msdos_format+0x72c> <== NEVER TAKEN
4000e424: 80 a7 60 00 cmp %i5, 0
{
errno = EINVAL;
ret_val = -1;
}
if (0 == ret_val)
4000e428: 12 80 00 34 bne 4000e4f8 <msdos_format+0x748>
4000e42c: c2 0f bd de ldub [ %fp + -546 ], %g1
{
if (FAT_FAT32 != fmt_params->fattype)
4000e430: 80 a0 60 04 cmp %g1, 4
4000e434: 02 80 00 0e be 4000e46c <msdos_format+0x6bc>
4000e438: 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)
4000e43c: c4 0f bd fc ldub [ %fp + -516 ], %g2
4000e440: 80 a0 a0 00 cmp %g2, 0
4000e444: 12 80 00 06 bne 4000e45c <msdos_format+0x6ac>
4000e448: c2 07 bd b8 ld [ %fp + -584 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e44c: 90 02 00 01 add %o0, %g1, %o0
4000e450: 82 20 00 01 neg %g1
4000e454: 90 02 3f ff add %o0, -1, %o0
4000e458: 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);
4000e45c: d2 07 bd ac ld [ %fp + -596 ], %o1
4000e460: 7f ff d0 7c call 40002650 <.umul>
4000e464: 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,
4000e468: 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)
4000e46c: 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,
4000e470: 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)
4000e474: 80 a0 e0 00 cmp %g3, 0
4000e478: 12 80 00 06 bne 4000e490 <msdos_format+0x6e0>
4000e47c: c4 07 bd b8 ld [ %fp + -584 ], %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e480: 82 00 40 02 add %g1, %g2, %g1
4000e484: 84 20 00 02 neg %g2
4000e488: 82 00 7f ff add %g1, -1, %g1
4000e48c: 82 08 40 02 and %g1, %g2, %g1
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000e490: 80 a6 60 00 cmp %i1, 0
4000e494: 02 80 00 17 be 4000e4f0 <msdos_format+0x740>
4000e498: c2 27 bd b4 st %g1, [ %fp + -588 ]
(rqdata->media != 0)) {
4000e49c: f6 0e 60 14 ldub [ %i1 + 0x14 ], %i3
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000e4a0: b4 8e e0 ff andcc %i3, 0xff, %i2
4000e4a4: 02 80 00 14 be 4000e4f4 <msdos_format+0x744>
4000e4a8: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
const char valid_media_codes[] =
4000e4ac: 94 10 20 09 mov 9, %o2
4000e4b0: 90 07 be 00 add %fp, -512, %o0
4000e4b4: 13 10 00 b0 sethi %hi(0x4002c000), %o1
4000e4b8: 40 00 37 c8 call 4001c3d8 <memcpy>
4000e4bc: 92 12 62 40 or %o1, 0x240, %o1 ! 4002c240 <_CPU_Trap_slot_template+0x188>
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
4000e4c0: 90 07 be 00 add %fp, -512, %o0
4000e4c4: 92 10 00 1a mov %i2, %o1
4000e4c8: 40 00 37 56 call 4001c220 <memchr>
4000e4cc: 94 10 20 09 mov 9, %o2
4000e4d0: 80 a2 20 00 cmp %o0, 0
4000e4d4: 32 80 00 09 bne,a 4000e4f8 <msdos_format+0x748> <== NEVER TAKEN
4000e4d8: f6 2f bd dd stb %i3, [ %fp + -547 ] <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
4000e4dc: 40 00 35 1a call 4001b944 <__errno>
4000e4e0: ba 10 3f ff mov -1, %i5
4000e4e4: 82 10 20 16 mov 0x16, %g1
4000e4e8: 10 80 00 04 b 4000e4f8 <msdos_format+0x748>
4000e4ec: c2 22 00 00 st %g1, [ %o0 ]
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000e4f0: 82 10 3f f8 mov -8, %g1
4000e4f4: c2 2f bd dd stb %g1, [ %fp + -547 ]
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000e4f8: f4 07 bd c8 ld [ %fp + -568 ], %i2
4000e4fc: d0 0f bd dc ldub [ %fp + -548 ], %o0
4000e500: 80 a6 a0 00 cmp %i2, 0
4000e504: 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);
4000e508: 90 0a 20 ff and %o0, 0xff, %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000e50c: 02 80 00 08 be 4000e52c <msdos_format+0x77c>
4000e510: 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);
4000e514: 7f ff d0 4f call 40002650 <.umul>
4000e518: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
4000e51c: 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);
4000e520: 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 =
4000e524: 10 80 00 08 b 4000e544 <msdos_format+0x794>
4000e528: 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);
4000e52c: 7f ff d0 49 call 40002650 <.umul>
4000e530: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000e534: 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);
4000e538: 90 02 00 1b add %o0, %i3, %o0
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000e53c: c2 27 bd d0 st %g1, [ %fp + -560 ]
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
4000e540: 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) {
4000e544: 80 a7 60 00 cmp %i5, 0
4000e548: 12 80 00 48 bne 4000e668 <msdos_format+0x8b8>
4000e54c: 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) &&
4000e550: 80 a6 60 00 cmp %i1, 0
4000e554: 02 80 00 07 be 4000e570 <msdos_format+0x7c0>
4000e558: 03 10 00 b0 sethi %hi(0x4002c000), %g1
(rqdata->OEMName != NULL)) {
4000e55c: 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) &&
4000e560: 80 a0 60 00 cmp %g1, 0
4000e564: 32 80 00 05 bne,a 4000e578 <msdos_format+0x7c8>
4000e568: 05 10 00 b4 sethi %hi(0x4002d000), %g2
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4000e56c: 03 10 00 b0 sethi %hi(0x4002c000), %g1
4000e570: 82 10 60 f8 or %g1, 0xf8, %g1 ! 4002c0f8 <_CPU_Trap_slot_template+0x40>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000e574: 05 10 00 b4 sethi %hi(0x4002d000), %g2
4000e578: 86 10 20 09 mov 9, %g3
4000e57c: f4 00 a1 a8 ld [ %g2 + 0x1a8 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000e580: b0 10 20 20 mov 0x20, %i0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
4000e584: 10 80 00 0f b 4000e5c0 <msdos_format+0x810>
4000e588: 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)) {
4000e58c: 88 0e e0 ff and %i3, 0xff, %g4
4000e590: 88 06 80 04 add %i2, %g4, %g4
4000e594: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
4000e598: 80 89 20 97 btst 0x97, %g4
4000e59c: 02 80 00 06 be 4000e5b4 <msdos_format+0x804>
4000e5a0: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
4000e5a4: f6 28 80 00 stb %i3, [ %g2 ]
4000e5a8: 82 00 60 01 inc %g1
4000e5ac: 10 80 00 04 b 4000e5bc <msdos_format+0x80c>
4000e5b0: 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++=' ';
4000e5b4: f0 28 80 00 stb %i0, [ %g2 ]
4000e5b8: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
4000e5bc: 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;
4000e5c0: 86 80 ff ff addcc %g3, -1, %g3
4000e5c4: 32 bf ff f2 bne,a 4000e58c <msdos_format+0x7dc>
4000e5c8: 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) &&
4000e5cc: 10 80 01 b6 b 4000eca4 <msdos_format+0xef4>
4000e5d0: 80 a6 60 00 cmp %i1, 0
4000e5d4: 80 a0 60 00 cmp %g1, 0
4000e5d8: 22 80 00 05 be,a 4000e5ec <msdos_format+0x83c>
4000e5dc: 03 10 00 b0 sethi %hi(0x4002c000), %g1
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
4000e5e0: 84 10 20 01 mov 1, %g2
4000e5e4: 10 80 00 03 b 4000e5f0 <msdos_format+0x840>
4000e5e8: 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 */
4000e5ec: 82 10 61 a8 or %g1, 0x1a8, %g1
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000e5f0: 05 10 00 b4 sethi %hi(0x4002d000), %g2
4000e5f4: 86 10 20 0c mov 0xc, %g3
4000e5f8: f4 00 a1 a8 ld [ %g2 + 0x1a8 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000e5fc: b0 10 20 20 mov 0x20, %i0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
4000e600: 10 80 00 0f b 4000e63c <msdos_format+0x88c>
4000e604: 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)) {
4000e608: 88 0e e0 ff and %i3, 0xff, %g4
4000e60c: 88 06 80 04 add %i2, %g4, %g4
4000e610: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
4000e614: 80 89 20 97 btst 0x97, %g4
4000e618: 02 80 00 06 be 4000e630 <msdos_format+0x880>
4000e61c: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
4000e620: f6 28 80 00 stb %i3, [ %g2 ]
4000e624: 82 00 60 01 inc %g1
4000e628: 10 80 00 04 b 4000e638 <msdos_format+0x888>
4000e62c: 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++=' ';
4000e630: f0 28 80 00 stb %i0, [ %g2 ]
4000e634: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
4000e638: c0 29 00 00 clrb [ %g4 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
4000e63c: 86 80 ff ff addcc %g3, -1, %g3
4000e640: 32 bf ff f2 bne,a 4000e608 <msdos_format+0x858>
4000e644: f6 08 40 00 ldub [ %g1 ], %i3
4000e648: 30 80 01 9b b,a 4000ecb4 <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;
4000e64c: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
4000e650: 10 80 00 05 b 4000e664 <msdos_format+0x8b4> <== NOT EXECUTED
4000e654: c2 27 bd f8 st %g1, [ %fp + -520 ] <== NOT EXECUTED
}
else {
*volid_ptr = rand();
4000e658: 40 00 3a 1c call 4001cec8 <rand>
4000e65c: 01 00 00 00 nop
4000e660: d0 27 bd f8 st %o0, [ %fp + -520 ]
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
4000e664: 80 a0 00 19 cmp %g0, %i1
4000e668: 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) &&
4000e66c: 80 a7 60 00 cmp %i5, 0
4000e670: 12 80 01 5f bne 4000ebec <msdos_format+0xe3c>
4000e674: b0 10 00 1d mov %i5, %i0
4000e678: 80 8e a0 ff btst 0xff, %i2
4000e67c: 02 80 00 1d be 4000e6f0 <msdos_format+0x940>
4000e680: 80 a7 60 00 cmp %i5, 0
(rqdata != NULL) &&
4000e684: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
4000e688: 80 a0 60 00 cmp %g1, 0
4000e68c: 02 80 00 11 be 4000e6d0 <msdos_format+0x920>
4000e690: 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,
4000e694: 92 10 20 02 mov 2, %o1
4000e698: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000e69c: 7f ff fd 29 call 4000db40 <msdos_format_printf>
4000e6a0: 94 12 a1 b0 or %o2, 0x1b0, %o2 ! 4002c1b0 <_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)) {
4000e6a4: 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,
4000e6a8: 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)) {
4000e6ac: 92 10 20 00 clr %o1
4000e6b0: 94 10 20 00 clr %o2
4000e6b4: 40 00 1a 14 call 40014f04 <lseek>
4000e6b8: 96 10 20 00 clr %o3
4000e6bc: 80 a2 20 00 cmp %o0, 0
4000e6c0: 16 80 01 83 bge 4000eccc <msdos_format+0xf1c> <== ALWAYS TAKEN
4000e6c4: 90 10 00 1c mov %i4, %o0
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
4000e6c8: 10 80 01 89 b 4000ecec <msdos_format+0xf3c> <== NOT EXECUTED
4000e6cc: 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
4000e6d0: d6 07 bd b0 ld [ %fp + -592 ], %o3
4000e6d4: d8 07 bd ac ld [ %fp + -596 ], %o4
4000e6d8: 92 10 00 1c mov %i4, %o1
4000e6dc: 94 10 20 00 clr %o2
4000e6e0: 7f ff fd 45 call 4000dbf4 <msdos_format_fill_sectors>
4000e6e4: 9a 10 3f e5 mov -27, %o5
4000e6e8: ba 10 00 08 mov %o0, %i5
}
/*
* create master boot record
*/
if (ret_val == 0) {
4000e6ec: 80 a7 60 00 cmp %i5, 0
4000e6f0: 12 80 01 3f bne 4000ebec <msdos_format+0xe3c> <== NEVER TAKEN
4000e6f4: 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,
4000e6f8: 10 bf ff e7 b 4000e694 <msdos_format+0x8e4>
4000e6fc: 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;
4000e700: 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);
4000e704: 92 10 20 00 clr %o1
4000e708: 94 10 21 be mov 0x1be, %o2
4000e70c: 40 00 37 70 call 4001c4cc <memset>
4000e710: 90 07 be 00 add %fp, -512, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000e714: 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,
4000e718: c0 37 bf fe clrh [ %fp + -2 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000e71c: 92 07 bd df add %fp, -545, %o1
4000e720: 40 00 37 2e call 4001c3d8 <memcpy>
4000e724: 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);
4000e728: 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);
4000e72c: 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);
4000e730: c2 2f be 0b stb %g1, [ %fp + -501 ]
4000e734: 83 30 60 08 srl %g1, 8, %g1
4000e738: c2 2f be 0c stb %g1, [ %fp + -500 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000e73c: 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);
4000e740: 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);
4000e744: c2 2f be 0d stb %g1, [ %fp + -499 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4000e748: 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);
4000e74c: 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);
4000e750: c2 2f be 0e stb %g1, [ %fp + -498 ]
4000e754: 83 30 60 08 srl %g1, 8, %g1
4000e758: 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);
4000e75c: 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 */
4000e760: 88 10 20 02 mov 2, %g4
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000e764: c2 2f be 11 stb %g1, [ %fp + -495 ]
4000e768: 83 30 60 08 srl %g1, 8, %g1
4000e76c: 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);
4000e770: 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);
4000e774: f6 2f be 13 stb %i3, [ %fp + -493 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4000e778: c2 2f be 15 stb %g1, [ %fp + -491 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4000e77c: 82 10 3f ff mov -1, %g1
4000e780: c2 2f be 18 stb %g1, [ %fp + -488 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4000e784: 82 10 20 06 mov 6, %g1
4000e788: 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);
4000e78c: 82 0f 40 02 and %i5, %g2, %g1
4000e790: 83 30 60 08 srl %g1, 8, %g1
4000e794: c2 2f be 21 stb %g1, [ %fp + -479 ]
4000e798: 83 37 60 10 srl %i5, 0x10, %g1
4000e79c: bb 37 60 18 srl %i5, 0x18, %i5
4000e7a0: fa 2f be 23 stb %i5, [ %fp + -477 ]
if (fmt_params->fattype != FAT_FAT32) {
4000e7a4: 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);
4000e7a8: 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... */
4000e7ac: 86 10 20 01 mov 1, %g3
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000e7b0: 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 */
4000e7b4: 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);
4000e7b8: 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... */
4000e7bc: c6 2f be 1c stb %g3, [ %fp + -484 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4000e7c0: 80 a7 60 04 cmp %i5, 4
4000e7c4: 02 80 00 1c be 4000e834 <msdos_format+0xa84>
4000e7c8: c2 07 bd bc ld [ %fp + -580 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4000e7cc: c2 2f be 16 stb %g1, [ %fp + -490 ]
4000e7d0: 83 30 60 08 srl %g1, 8, %g1
4000e7d4: 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);
4000e7d8: 82 10 20 29 mov 0x29, %g1
4000e7dc: c2 2f be 26 stb %g1, [ %fp + -474 ]
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4000e7e0: c2 07 bd f8 ld [ %fp + -520 ], %g1
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4000e7e4: 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 */
4000e7e8: 84 08 40 02 and %g1, %g2, %g2
4000e7ec: 85 30 a0 08 srl %g2, 8, %g2
4000e7f0: c2 2f be 27 stb %g1, [ %fp + -473 ]
4000e7f4: c4 2f be 28 stb %g2, [ %fp + -472 ]
4000e7f8: 85 30 60 10 srl %g1, 0x10, %g2
4000e7fc: 83 30 60 18 srl %g1, 0x18, %g1
4000e800: c4 2f be 29 stb %g2, [ %fp + -471 ]
4000e804: c2 2f be 2a stb %g1, [ %fp + -470 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4000e808: 90 07 be 2b add %fp, -469, %o0
4000e80c: 40 00 36 f3 call 4001c3d8 <memcpy>
4000e810: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4000e814: 13 10 00 b0 sethi %hi(0x4002c000), %o1
4000e818: 80 a7 60 01 cmp %i5, 1
4000e81c: 12 80 00 04 bne 4000e82c <msdos_format+0xa7c>
4000e820: 92 12 61 10 or %o1, 0x110, %o1
4000e824: 13 10 00 b0 sethi %hi(0x4002c000), %o1
4000e828: 92 12 61 00 or %o1, 0x100, %o1 ! 4002c100 <_CPU_Trap_slot_template+0x48>
4000e82c: 10 80 00 1d b 4000e8a0 <msdos_format+0xaf0>
4000e830: 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);
4000e834: 84 08 40 02 and %g1, %g2, %g2
4000e838: 85 30 a0 08 srl %g2, 8, %g2
4000e83c: c2 2f be 24 stb %g1, [ %fp + -476 ]
4000e840: c4 2f be 25 stb %g2, [ %fp + -475 ]
4000e844: 85 30 60 10 srl %g1, 0x10, %g2
4000e848: 83 30 60 18 srl %g1, 0x18, %g1
4000e84c: 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 */
4000e850: 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);
4000e854: 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 */
4000e858: c2 2f be 32 stb %g1, [ %fp + -462 ]
4000e85c: 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 */
4000e860: c8 2f be 2c stb %g4, [ %fp + -468 ]
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4000e864: 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 */
4000e868: c2 2f be 33 stb %g1, [ %fp + -461 ]
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4000e86c: 92 10 20 00 clr %o1
4000e870: 94 10 20 0c mov 0xc, %o2
4000e874: 40 00 37 16 call 4001c4cc <memset>
4000e878: 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);
4000e87c: 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);
4000e880: 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);
4000e884: 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);
4000e888: 90 07 be 47 add %fp, -441, %o0
4000e88c: 40 00 37 10 call 4001c4cc <memset>
4000e890: 94 10 20 0b mov 0xb, %o2
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000e894: 13 10 00 b0 sethi %hi(0x4002c000), %o1
4000e898: 90 07 be 52 add %fp, -430, %o0
4000e89c: 92 12 61 c8 or %o1, 0x1c8, %o1
4000e8a0: 40 00 36 ce call 4001c3d8 <memcpy>
4000e8a4: 94 10 20 08 mov 8, %o2
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4000e8a8: 82 10 20 55 mov 0x55, %g1
4000e8ac: c2 2f bf fe stb %g1, [ %fp + -2 ]
4000e8b0: 82 10 3f aa mov -86, %g1
4000e8b4: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4000e8b8: 82 10 3f eb mov -21, %g1
4000e8bc: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(mbr,1,0x3c);
4000e8c0: 82 10 20 3c mov 0x3c, %g1
4000e8c4: c2 2f be 01 stb %g1, [ %fp + -511 ]
FAT_SET_VAL8(mbr,2,0x90);
4000e8c8: 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,
4000e8cc: 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);
4000e8d0: 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,
4000e8d4: 92 10 20 02 mov 2, %o1
4000e8d8: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000e8dc: 7f ff fc 99 call 4000db40 <msdos_format_printf>
4000e8e0: 94 12 a1 d8 or %o2, 0x1d8, %o2 ! 4002c1d8 <_CPU_Trap_slot_template+0x120>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000e8e4: d4 07 bd ac ld [ %fp + -596 ], %o2
4000e8e8: 90 10 00 1c mov %i4, %o0
4000e8ec: 92 10 20 00 clr %o1
4000e8f0: 7f ff fc a9 call 4000db94 <msdos_format_write_sec>
4000e8f4: 96 07 be 00 add %fp, -512, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4000e8f8: ba 92 20 00 orcc %o0, 0, %i5
4000e8fc: 12 80 00 fc bne 4000ecec <msdos_format+0xf3c> <== NEVER TAKEN
4000e900: c2 07 bd d4 ld [ %fp + -556 ], %g1
4000e904: 80 a0 60 00 cmp %g1, 0
4000e908: 12 80 00 08 bne 4000e928 <msdos_format+0xb78>
4000e90c: 90 10 00 19 mov %i1, %o0
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
4000e910: fa 07 bd d8 ld [ %fp + -552 ], %i5
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000e914: 80 a7 60 00 cmp %i5, 0
4000e918: 22 80 00 37 be,a 4000e9f4 <msdos_format+0xc44>
4000e91c: d2 07 bd bc ld [ %fp + -580 ], %o1
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4000e920: 10 80 00 10 b 4000e960 <msdos_format+0xbb0>
4000e924: 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,
4000e928: 92 10 20 02 mov 2, %o1
4000e92c: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000e930: 7f ff fc 84 call 4000db40 <msdos_format_printf>
4000e934: 94 12 a1 f0 or %o2, 0x1f0, %o2 ! 4002c1f0 <_CPU_Trap_slot_template+0x138>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000e938: d2 07 bd d4 ld [ %fp + -556 ], %o1
4000e93c: d4 07 bd ac ld [ %fp + -596 ], %o2
4000e940: 90 10 00 1c mov %i4, %o0
4000e944: 7f ff fc 94 call 4000db94 <msdos_format_write_sec>
4000e948: 96 07 be 00 add %fp, -512, %o3
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000e94c: ba 92 20 00 orcc %o0, 0, %i5
4000e950: 22 bf ff f1 be,a 4000e914 <msdos_format+0xb64> <== ALWAYS TAKEN
4000e954: 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;
4000e958: 10 80 00 a5 b 4000ebec <msdos_format+0xe3c> <== NOT EXECUTED
4000e95c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4000e960: 94 10 22 00 mov 0x200, %o2
4000e964: 40 00 36 da call 4001c4cc <memset>
4000e968: 90 07 be 00 add %fp, -512, %o0
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000e96c: 82 10 20 52 mov 0x52, %g1
4000e970: c2 2f be 00 stb %g1, [ %fp + -512 ]
4000e974: c2 2f be 01 stb %g1, [ %fp + -511 ]
4000e978: 82 10 20 61 mov 0x61, %g1
4000e97c: c2 2f be 02 stb %g1, [ %fp + -510 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000e980: c2 2f bf e7 stb %g1, [ %fp + -25 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000e984: 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,
4000e988: 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);
4000e98c: c2 2f bf fe stb %g1, [ %fp + -2 ]
4000e990: 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 );
4000e994: 84 10 20 41 mov 0x41, %g2
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000e998: 86 10 20 72 mov 0x72, %g3
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000e99c: 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,
4000e9a0: 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,
4000e9a4: 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 );
4000e9a8: c4 2f be 03 stb %g2, [ %fp + -509 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000e9ac: c6 2f bf e4 stb %g3, [ %fp + -28 ]
4000e9b0: c6 2f bf e5 stb %g3, [ %fp + -27 ]
4000e9b4: 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,
4000e9b8: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4000e9bc: c2 2f bf e9 stb %g1, [ %fp + -23 ]
4000e9c0: c2 2f bf ea stb %g1, [ %fp + -22 ]
4000e9c4: c2 2f bf eb stb %g1, [ %fp + -21 ]
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
4000e9c8: c2 2f bf ec stb %g1, [ %fp + -20 ]
4000e9cc: c2 2f bf ed stb %g1, [ %fp + -19 ]
4000e9d0: c2 2f bf ee stb %g1, [ %fp + -18 ]
4000e9d4: 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,
4000e9d8: 90 10 00 1c mov %i4, %o0
4000e9dc: 7f ff fc 6e call 4000db94 <msdos_format_write_sec>
4000e9e0: 96 07 be 00 add %fp, -512, %o3
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4000e9e4: ba 92 20 00 orcc %o0, 0, %i5
4000e9e8: 12 80 00 81 bne 4000ebec <msdos_format+0xe3c> <== NEVER TAKEN
4000e9ec: b0 10 00 1d mov %i5, %i0
ret_val = msdos_format_fill_sectors
(rqdata,
4000e9f0: d2 07 bd bc ld [ %fp + -580 ], %o1
4000e9f4: d0 0f bd dc ldub [ %fp + -548 ], %o0
4000e9f8: 7f ff cf 16 call 40002650 <.umul>
4000e9fc: 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
4000ea00: d8 07 bd ac ld [ %fp + -596 ], %o4
(rqdata,
4000ea04: 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
4000ea08: 94 10 00 1d mov %i5, %o2
4000ea0c: 90 10 00 19 mov %i1, %o0
4000ea10: 92 10 00 1c mov %i4, %o1
4000ea14: 7f ff fc 78 call 4000dbf4 <msdos_format_fill_sectors>
4000ea18: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4000ea1c: ba 92 20 00 orcc %o0, 0, %i5
4000ea20: 12 80 00 b3 bne 4000ecec <msdos_format+0xf3c> <== NEVER TAKEN
4000ea24: d4 07 bd cc ld [ %fp + -564 ], %o2
ret_val = msdos_format_fill_sectors
4000ea28: d6 07 bd d0 ld [ %fp + -560 ], %o3
4000ea2c: d8 07 bd ac ld [ %fp + -596 ], %o4
4000ea30: 90 10 00 19 mov %i1, %o0
4000ea34: 92 10 00 1c mov %i4, %o1
4000ea38: 7f ff fc 6f call 4000dbf4 <msdos_format_fill_sectors>
4000ea3c: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4000ea40: ba 92 20 00 orcc %o0, 0, %i5
4000ea44: 12 80 00 aa bne 4000ecec <msdos_format+0xf3c> <== NEVER TAKEN
4000ea48: c2 0f bd f4 ldub [ %fp + -524 ], %g1
4000ea4c: 80 a0 60 00 cmp %g1, 0
4000ea50: 12 80 00 0f bne 4000ea8c <msdos_format+0xcdc>
4000ea54: 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));
4000ea58: 92 10 20 00 clr %o1
4000ea5c: 40 00 36 9c call 4001c4cc <memset>
4000ea60: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
4000ea64: c2 0f bd de ldub [ %fp + -546 ], %g1
4000ea68: 80 a0 60 02 cmp %g1, 2
4000ea6c: 02 80 00 21 be 4000eaf0 <msdos_format+0xd40>
4000ea70: 80 a0 60 04 cmp %g1, 4
4000ea74: 02 80 00 27 be 4000eb10 <msdos_format+0xd60>
4000ea78: 80 a0 60 01 cmp %g1, 1
4000ea7c: 12 80 00 32 bne 4000eb44 <msdos_format+0xd94> <== NEVER TAKEN
4000ea80: 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));
4000ea84: 10 80 00 16 b 4000eadc <msdos_format+0xd2c>
4000ea88: 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));
4000ea8c: 92 10 20 00 clr %o1
4000ea90: 94 10 22 00 mov 0x200, %o2
4000ea94: 40 00 36 8e call 4001c4cc <memset>
4000ea98: 90 07 be 00 add %fp, -512, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4000ea9c: 92 07 bd e8 add %fp, -536, %o1
4000eaa0: 94 10 20 0b mov 0xb, %o2
4000eaa4: 40 00 36 4d call 4001c3d8 <memcpy>
4000eaa8: 90 07 be 00 add %fp, -512, %o0
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
4000eaac: d2 07 bd cc ld [ %fp + -564 ], %o1
4000eab0: 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;
4000eab4: 82 10 20 08 mov 8, %g1
ret_val = msdos_format_write_sec
4000eab8: 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;
4000eabc: c2 2f be 0b stb %g1, [ %fp + -501 ]
ret_val = msdos_format_write_sec
4000eac0: 7f ff fc 35 call 4000db94 <msdos_format_write_sec>
4000eac4: 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) {
4000eac8: b0 92 20 00 orcc %o0, 0, %i0
4000eacc: 12 80 00 49 bne 4000ebf0 <msdos_format+0xe40> <== NEVER TAKEN
4000ead0: 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));
4000ead4: 10 bf ff e1 b 4000ea58 <msdos_format+0xca8>
4000ead8: 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)));
4000eadc: 82 10 3f 8f mov -113, %g1
4000eae0: 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));
4000eae4: 82 10 3f ff mov -1, %g1
break;
4000eae8: 10 80 00 1b b 4000eb54 <msdos_format+0xda4>
4000eaec: 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);
4000eaf0: 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);
4000eaf4: 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);
4000eaf8: 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);
4000eafc: 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);
4000eb00: 82 10 3f ff mov -1, %g1
4000eb04: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
4000eb08: 10 80 00 13 b 4000eb54 <msdos_format+0xda4>
4000eb0c: 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);
4000eb10: c2 0f bd dd ldub [ %fp + -547 ], %g1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000eb14: 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);
4000eb18: c2 2f be 00 stb %g1, [ %fp + -512 ]
4000eb1c: 82 10 3f ff mov -1, %g1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000eb20: 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);
4000eb24: c2 2f be 01 stb %g1, [ %fp + -511 ]
4000eb28: c2 2f be 02 stb %g1, [ %fp + -510 ]
4000eb2c: c2 2f be 03 stb %g1, [ %fp + -509 ]
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000eb30: c2 2f be 05 stb %g1, [ %fp + -507 ]
4000eb34: c2 2f be 06 stb %g1, [ %fp + -506 ]
4000eb38: 82 10 20 0f mov 0xf, %g1
break;
4000eb3c: 10 80 00 06 b 4000eb54 <msdos_format+0xda4>
4000eb40: c2 2f be 07 stb %g1, [ %fp + -505 ]
default:
ret_val = -1;
errno = EINVAL;
4000eb44: 40 00 33 80 call 4001b944 <__errno> <== NOT EXECUTED
4000eb48: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4000eb4c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000eb50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4000eb54: c2 0f bd de ldub [ %fp + -546 ], %g1
4000eb58: 80 a0 60 04 cmp %g1, 4
4000eb5c: 12 80 00 0a bne 4000eb84 <msdos_format+0xdd4>
4000eb60: 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);
4000eb64: 82 10 3f f8 mov -8, %g1
4000eb68: c2 2f be 08 stb %g1, [ %fp + -504 ]
4000eb6c: 82 10 3f ff mov -1, %g1
4000eb70: c2 2f be 09 stb %g1, [ %fp + -503 ]
4000eb74: c2 2f be 0a stb %g1, [ %fp + -502 ]
4000eb78: 82 10 20 0f mov 0xf, %g1
4000eb7c: 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)
4000eb80: 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,
4000eb84: 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)
4000eb88: 80 a0 a0 00 cmp %g2, 0
4000eb8c: 12 80 00 06 bne 4000eba4 <msdos_format+0xdf4>
4000eb90: c2 07 bd b8 ld [ %fp + -584 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000eb94: b6 06 c0 01 add %i3, %g1, %i3
4000eb98: 82 20 00 01 neg %g1
4000eb9c: b6 06 ff ff add %i3, -1, %i3
4000eba0: 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;
4000eba4: b0 10 00 1d mov %i5, %i0
4000eba8: 10 80 00 0b b 4000ebd4 <msdos_format+0xe24>
4000ebac: 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),
4000ebb0: 7f ff ce a8 call 40002650 <.umul>
4000ebb4: 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
4000ebb8: d4 07 bd ac ld [ %fp + -596 ], %o2
(fd,
4000ebbc: 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
4000ebc0: 96 07 be 00 add %fp, -512, %o3
4000ebc4: 90 10 00 1c mov %i4, %o0
4000ebc8: 7f ff fb f3 call 4000db94 <msdos_format_write_sec>
4000ebcc: ba 07 60 01 inc %i5
4000ebd0: 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);
4000ebd4: 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;
4000ebd8: 80 a7 40 01 cmp %i5, %g1
4000ebdc: 16 80 00 04 bge 4000ebec <msdos_format+0xe3c>
4000ebe0: 80 a6 20 00 cmp %i0, 0
(i < fmt_params.fat_num) && (ret_val == 0);
4000ebe4: 02 bf ff f3 be 4000ebb0 <msdos_format+0xe00> <== ALWAYS TAKEN
4000ebe8: d2 07 bd bc ld [ %fp + -580 ], %o1
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
4000ebec: 80 a6 20 00 cmp %i0, 0
4000ebf0: 12 80 00 0f bne 4000ec2c <msdos_format+0xe7c>
4000ebf4: 80 a7 3f ff cmp %i4, -1
4000ebf8: 80 8e a0 ff btst 0xff, %i2
4000ebfc: 02 80 00 0c be 4000ec2c <msdos_format+0xe7c>
4000ec00: 80 a7 3f ff cmp %i4, -1
4000ec04: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1
4000ec08: 80 a0 60 00 cmp %g1, 0
4000ec0c: 02 80 00 08 be 4000ec2c <msdos_format+0xe7c>
4000ec10: 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);
4000ec14: 90 10 00 1c mov %i4, %o0
4000ec18: 13 08 00 10 sethi %hi(0x20004000), %o1
4000ec1c: 40 00 18 99 call 40014e80 <ioctl>
4000ec20: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_SIZE+0x1fc04206>
4000ec24: b0 10 00 08 mov %o0, %i0
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4000ec28: 80 a7 3f ff cmp %i4, -1
4000ec2c: 02 80 00 40 be 4000ed2c <msdos_format+0xf7c> <== NEVER TAKEN
4000ec30: 01 00 00 00 nop
close(fd);
4000ec34: 7f ff db a8 call 40005ad4 <close>
4000ec38: 90 10 00 1c mov %i4, %o0
4000ec3c: 81 c7 e0 08 ret
4000ec40: 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));
4000ec44: 94 10 20 54 mov 0x54, %o2
4000ec48: 40 00 36 21 call 4001c4cc <memset>
4000ec4c: 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);
4000ec50: 90 10 00 1c mov %i4, %o0
4000ec54: 37 10 01 10 sethi %hi(0x40044000), %i3
4000ec58: 94 07 bd ac add %fp, -596, %o2
4000ec5c: 40 00 18 89 call 40014e80 <ioctl>
4000ec60: 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) {
4000ec64: ba 92 20 00 orcc %o0, 0, %i5
4000ec68: 12 bf fd ed bne 4000e41c <msdos_format+0x66c> <== NEVER TAKEN
4000ec6c: 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);
4000ec70: 10 bf fc 7f b 4000de6c <msdos_format+0xbc>
4000ec74: 90 10 00 1c mov %i4, %o0
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000ec78: d6 0f bd dc ldub [ %fp + -548 ], %o3
4000ec7c: 90 10 00 19 mov %i1, %o0
4000ec80: 92 10 20 02 mov 2, %o1
4000ec84: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000ec88: 7f ff fb ae call 4000db40 <msdos_format_printf>
4000ec8c: 94 12 a2 10 or %o2, 0x210, %o2 ! 4002c210 <_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) {
4000ec90: 80 a6 60 00 cmp %i1, 0
4000ec94: 32 bf fc 9e bne,a 4000df0c <msdos_format+0x15c>
4000ec98: 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;
4000ec9c: 10 bf fc a0 b 4000df1c <msdos_format+0x16c>
4000eca0: 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) &&
4000eca4: 32 bf fe 4c bne,a 4000e5d4 <msdos_format+0x824>
4000eca8: 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 */
4000ecac: 10 bf fe 50 b 4000e5ec <msdos_format+0x83c>
4000ecb0: 03 10 00 b0 sethi %hi(0x4002c000), %g1
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
4000ecb4: 40 00 1c 71 call 40015e78 <rtems_clock_get_tod_timeval>
4000ecb8: 90 07 be 00 add %fp, -512, %o0
if (rc == RTEMS_SUCCESSFUL) {
4000ecbc: 80 a2 20 00 cmp %o0, 0
4000ecc0: 02 bf fe 63 be 4000e64c <msdos_format+0x89c> <== NEVER TAKEN
4000ecc4: c2 07 be 00 ld [ %fp + -512 ], %g1
4000ecc8: 30 bf fe 64 b,a 4000e658 <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)) {
4000eccc: 92 07 be 00 add %fp, -512, %o1
4000ecd0: 40 00 19 56 call 40015228 <read>
4000ecd4: 94 10 00 1d mov %i5, %o2
4000ecd8: 80 a2 20 00 cmp %o0, 0
4000ecdc: 16 80 00 08 bge 4000ecfc <msdos_format+0xf4c> <== ALWAYS TAKEN
4000ece0: 90 10 00 19 mov %i1, %o0
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
4000ece4: 10 80 00 04 b 4000ecf4 <msdos_format+0xf44> <== NOT EXECUTED
4000ece8: 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;
4000ecec: 10 bf ff c0 b 4000ebec <msdos_format+0xe3c> <== NOT EXECUTED
4000ecf0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4000ecf4: 10 bf ff be b 4000ebec <msdos_format+0xe3c> <== NOT EXECUTED
4000ecf8: 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,
4000ecfc: 92 10 20 02 mov 2, %o1
4000ed00: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000ed04: 7f ff fb 8f call 4000db40 <msdos_format_printf>
4000ed08: 94 12 a2 28 or %o2, 0x228, %o2 ! 4002c228 <_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) {
4000ed0c: fa 07 bd b0 ld [ %fp + -592 ], %i5
4000ed10: 03 00 00 3f sethi %hi(0xfc00), %g1
4000ed14: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
4000ed18: 80 a7 40 01 cmp %i5, %g1
4000ed1c: 18 bf fe 7a bgu 4000e704 <msdos_format+0x954>
4000ed20: b6 10 20 00 clr %i3
4000ed24: 10 bf fe 77 b 4000e700 <msdos_format+0x950>
4000ed28: b6 10 00 1d mov %i5, %i3
if (fd != -1) {
close(fd);
}
return ret_val;
}
4000ed2c: 81 c7 e0 08 ret <== NOT EXECUTED
4000ed30: 81 e8 00 00 restore <== NOT EXECUTED
4000dbf4 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000dbf4: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4000dbf8: 7f ff e1 22 call 40006080 <malloc>
4000dbfc: 90 10 00 1c mov %i4, %o0
if (fill_buffer == NULL) {
4000dc00: a0 92 20 00 orcc %o0, 0, %l0
4000dc04: 12 80 00 07 bne 4000dc20 <msdos_format_fill_sectors+0x2c> <== ALWAYS TAKEN
4000dc08: 92 10 00 1d mov %i5, %o1
errno = ENOMEM;
4000dc0c: 40 00 37 4e call 4001b944 <__errno> <== NOT EXECUTED
4000dc10: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4000dc14: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000dc18: 10 80 00 05 b 4000dc2c <msdos_format_fill_sectors+0x38> <== NOT EXECUTED
4000dc1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
4000dc20: 94 10 00 1c mov %i4, %o2
4000dc24: 40 00 3a 2a call 4001c4cc <memset>
4000dc28: ba 10 20 00 clr %i5
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dc2c: 90 10 00 18 mov %i0, %o0
4000dc30: 92 10 20 02 mov 2, %o1
4000dc34: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000dc38: 7f ff ff c2 call 4000db40 <msdos_format_printf>
4000dc3c: 94 12 a0 c8 or %o2, 0xc8, %o2 ! 4002c0c8 <_CPU_Trap_slot_template+0x10>
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000dc40: 85 2e e0 02 sll %i3, 2, %g2
4000dc44: 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, ".");
4000dc48: 2b 10 00 af sethi %hi(0x4002bc00), %l5
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000dc4c: 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) &&
4000dc50: a4 10 20 00 clr %l2
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000dc54: 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;
4000dc58: a2 10 3f ff mov -1, %l1
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
4000dc5c: a6 00 40 13 add %g1, %l3, %l3
4000dc60: 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) &&
4000dc64: 10 80 00 15 b 4000dcb8 <msdos_format_fill_sectors+0xc4>
4000dc68: aa 15 60 d0 or %l5, 0xd0, %l5
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
4000dc6c: 7f ff d2 b3 call 40002738 <.udiv>
4000dc70: 92 10 00 1b mov %i3, %o1
if (percent != last_percent) {
4000dc74: 80 a2 00 11 cmp %o0, %l1
4000dc78: 02 80 00 08 be 4000dc98 <msdos_format_fill_sectors+0xa4>
4000dc7c: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
4000dc80: 12 80 00 06 bne 4000dc98 <msdos_format_fill_sectors+0xa4>
4000dc84: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000dc88: 90 10 00 18 mov %i0, %o0
4000dc8c: 92 10 20 02 mov 2, %o1
4000dc90: 7f ff ff ac call 4000db40 <msdos_format_printf>
4000dc94: 94 10 00 15 mov %l5, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000dc98: 92 10 00 1a mov %i2, %o1
4000dc9c: 90 10 00 19 mov %i1, %o0
4000dca0: 94 10 00 1c mov %i4, %o2
4000dca4: 96 10 00 10 mov %l0, %o3
4000dca8: 7f ff ff bb call 4000db94 <msdos_format_write_sec>
4000dcac: b4 06 a0 01 inc %i2
4000dcb0: a4 04 bf 9c add %l2, -100, %l2
4000dcb4: 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) &&
4000dcb8: 80 a5 00 1a cmp %l4, %i2
4000dcbc: 02 80 00 04 be 4000dccc <msdos_format_fill_sectors+0xd8>
4000dcc0: 80 a7 60 00 cmp %i5, 0
4000dcc4: 02 bf ff ea be 4000dc6c <msdos_format_fill_sectors+0x78> <== ALWAYS TAKEN
4000dcc8: 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");
4000dccc: 90 10 00 18 mov %i0, %o0
4000dcd0: 92 10 20 02 mov 2, %o1
4000dcd4: 15 10 00 b0 sethi %hi(0x4002c000), %o2
4000dcd8: 7f ff ff 9a call 4000db40 <msdos_format_printf>
4000dcdc: 94 12 a1 e8 or %o2, 0x1e8, %o2 ! 4002c1e8 <_CPU_Trap_slot_template+0x130>
if (ret_val)
4000dce0: 80 a7 60 00 cmp %i5, 0
4000dce4: 02 80 00 09 be 4000dd08 <msdos_format_fill_sectors+0x114> <== ALWAYS TAKEN
4000dce8: 80 a4 20 00 cmp %l0, 0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000dcec: 15 10 00 b0 sethi %hi(0x4002c000), %o2 <== NOT EXECUTED
4000dcf0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000dcf4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000dcf8: 94 12 a0 d8 or %o2, 0xd8, %o2 <== NOT EXECUTED
4000dcfc: 7f ff ff 91 call 4000db40 <msdos_format_printf> <== NOT EXECUTED
4000dd00: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
4000dd04: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
4000dd08: 02 80 00 04 be 4000dd18 <msdos_format_fill_sectors+0x124> <== NEVER TAKEN
4000dd0c: 01 00 00 00 nop
free(fill_buffer);
4000dd10: 7f ff df 92 call 40005b58 <free>
4000dd14: 90 10 00 10 mov %l0, %o0
fill_buffer = NULL;
}
return ret_val;
}
4000dd18: 81 c7 e0 08 ret
4000dd1c: 91 e8 00 1d restore %g0, %i5, %o0
4000db40 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
4000db40: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
4000db44: 94 07 a0 50 add %fp, 0x50, %o2
4000db48: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000db4c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000db50: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
4000db54: 80 a6 20 00 cmp %i0, 0
4000db58: 02 80 00 0d be 4000db8c <msdos_format_printf+0x4c>
4000db5c: d4 27 bf fc st %o2, [ %fp + -4 ]
4000db60: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000db64: 80 a0 40 19 cmp %g1, %i1
4000db68: 06 80 00 09 bl 4000db8c <msdos_format_printf+0x4c> <== ALWAYS TAKEN
4000db6c: 3b 10 00 b4 sethi %hi(0x4002d000), %i5
{
vfprintf (stdout, format, args);
4000db70: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1 ! 4002d1b0 <_impure_ptr><== NOT EXECUTED
4000db74: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4000db78: 40 00 58 a2 call 40023e00 <vfprintf> <== NOT EXECUTED
4000db7c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
4000db80: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1 <== NOT EXECUTED
4000db84: 40 00 38 73 call 4001bd50 <fflush> <== NOT EXECUTED
4000db88: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
4000db8c: 81 c7 e0 08 ret
4000db90: 81 e8 00 00 restore
4000db94 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000db94: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000db98: 94 10 20 00 clr %o2
4000db9c: 96 10 00 1a mov %i2, %o3
4000dba0: 90 10 20 00 clr %o0
4000dba4: 7f ff d1 8e call 400021dc <__muldi3>
4000dba8: 92 10 00 19 mov %i1, %o1
4000dbac: 84 10 00 08 mov %o0, %g2
4000dbb0: 86 10 00 09 mov %o1, %g3
4000dbb4: 90 10 00 18 mov %i0, %o0
4000dbb8: 92 10 00 02 mov %g2, %o1
4000dbbc: 94 10 00 03 mov %g3, %o2
4000dbc0: 40 00 1c d1 call 40014f04 <lseek>
4000dbc4: 96 10 20 00 clr %o3
4000dbc8: 80 a2 20 00 cmp %o0, 0
4000dbcc: 16 80 00 04 bge 4000dbdc <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
4000dbd0: 90 10 00 18 mov %i0, %o0
4000dbd4: 81 c7 e0 08 ret <== NOT EXECUTED
4000dbd8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
4000dbdc: 92 10 00 1b mov %i3, %o1
4000dbe0: 7f ff ef 1e call 40009858 <write>
4000dbe4: 94 10 00 1a mov %i2, %o2
4000dbe8: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
4000dbec: 81 c7 e0 08 ret
4000dbf0: 81 e8 00 00 restore
40019234 <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
)
{
40019234: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40019238: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
4001923c: 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);
40019240: 90 10 00 1c mov %i4, %o0
40019244: 92 10 00 1a mov %i2, %o1
40019248: 7f ff e5 23 call 400126d4 <fat_file_open>
4001924c: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
40019250: ba 92 20 00 orcc %o0, 0, %i5
40019254: 32 80 00 a5 bne,a 400194e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NEVER TAKEN
40019258: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
fat_fd->cln = cln;
4001925c: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40019260: 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;
40019264: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
40019268: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001926c: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
40019270: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
40019274: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
40019278: 7f ff e7 c4 call 40013188 <fat_file_size>
4001927c: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
40019280: ba 92 20 00 orcc %o0, 0, %i5
40019284: 22 80 00 04 be,a 40019294 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x60><== ALWAYS TAKEN
40019288: 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);
4001928c: 10 80 00 19 b 400192f0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xbc><== NOT EXECUTED
40019290: 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);
40019294: 92 10 20 00 clr %o1
40019298: 90 10 00 1d mov %i5, %o0
4001929c: 40 00 0c 8c call 4001c4cc <memset>
400192a0: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
400192a4: 94 10 00 1d mov %i5, %o2
400192a8: 33 10 00 af sethi %hi(0x4002bc00), %i1
400192ac: 92 10 20 01 mov 1, %o1
400192b0: 96 10 20 0b mov 0xb, %o3
400192b4: 7f ff fb 7a call 4001809c <msdos_long_to_short>
400192b8: 90 16 60 d0 or %i1, 0xd0, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
400192bc: d2 07 bf bc ld [ %fp + -68 ], %o1
400192c0: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
400192c4: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
400192c8: 90 10 00 18 mov %i0, %o0
400192cc: 94 10 20 00 clr %o2
400192d0: 96 16 60 d0 or %i1, 0xd0, %o3
400192d4: 98 10 20 01 mov 1, %o4
400192d8: 7f ff fd 1b call 40018744 <msdos_find_name_in_fat_file>
400192dc: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
400192e0: ba 92 20 00 orcc %o0, 0, %i5
400192e4: 22 80 00 05 be,a 400192f8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc4><== ALWAYS TAKEN
400192e8: ba 07 bf e0 add %fp, -32, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
400192ec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400192f0: 10 80 00 77 b 400194cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
400192f4: 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);
400192f8: 92 10 20 00 clr %o1
400192fc: 90 10 00 1d mov %i5, %o0
40019300: 40 00 0c 73 call 4001c4cc <memset>
40019304: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
40019308: 94 10 00 1d mov %i5, %o2
4001930c: 33 10 00 b1 sethi %hi(0x4002c400), %i1
40019310: 92 10 20 02 mov 2, %o1
40019314: 96 10 20 0b mov 0xb, %o3
40019318: 7f ff fb 61 call 4001809c <msdos_long_to_short>
4001931c: 90 16 61 08 or %i1, 0x108, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
40019320: d2 07 bf bc ld [ %fp + -68 ], %o1
40019324: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40019328: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
4001932c: 90 10 00 18 mov %i0, %o0
40019330: 94 10 20 00 clr %o2
40019334: 96 16 61 08 or %i1, 0x108, %o3
40019338: 98 10 20 02 mov 2, %o4
4001933c: 7f ff fd 02 call 40018744 <msdos_find_name_in_fat_file>
40019340: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
40019344: ba 92 20 00 orcc %o0, 0, %i5
40019348: 02 80 00 04 be 40019358 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x124><== ALWAYS TAKEN
4001934c: 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);
40019350: 10 80 00 5f b 400194cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
40019354: 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);
40019358: e0 17 bf da lduh [ %fp + -38 ], %l0
4001935c: e2 17 bf d4 lduh [ %fp + -44 ], %l1
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
40019360: 7f ff e5 f3 call 40012b2c <fat_file_close>
40019364: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
40019368: ba 92 20 00 orcc %o0, 0, %i5
4001936c: 12 80 00 5e bne 400194e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
40019370: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40019374: 83 28 60 10 sll %g1, 0x10, %g1
40019378: 85 30 60 18 srl %g1, 0x18, %g2
4001937c: 87 30 60 08 srl %g1, 8, %g3
40019380: 03 00 00 3f sethi %hi(0xfc00), %g1
40019384: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40019388: 86 08 c0 01 and %g3, %g1, %g3
4001938c: 86 10 80 03 or %g2, %g3, %g3
40019390: c4 17 bf fa lduh [ %fp + -6 ], %g2
40019394: 87 28 e0 10 sll %g3, 0x10, %g3
40019398: 85 28 a0 10 sll %g2, 0x10, %g2
4001939c: 89 30 a0 18 srl %g2, 0x18, %g4
400193a0: 85 30 a0 08 srl %g2, 8, %g2
400193a4: 82 08 80 01 and %g2, %g1, %g1
400193a8: 82 11 00 01 or %g4, %g1, %g1
400193ac: 80 90 c0 01 orcc %g3, %g1, %g0
400193b0: 12 80 00 08 bne 400193d0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x19c><== ALWAYS TAKEN
400193b4: 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;
400193b8: 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;
400193bc: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400193c0: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
400193c4: 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;
400193c8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400193cc: 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);
400193d0: 92 10 00 1a mov %i2, %o1
400193d4: 7f ff e4 c0 call 400126d4 <fat_file_open>
400193d8: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
400193dc: ba 92 20 00 orcc %o0, 0, %i5
400193e0: 12 80 00 41 bne 400194e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
400193e4: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
400193e8: 33 00 00 3f sethi %hi(0xfc00), %i1
400193ec: 83 28 60 10 sll %g1, 0x10, %g1
400193f0: b2 16 63 ff or %i1, 0x3ff, %i1
400193f4: bb 30 60 18 srl %g1, 0x18, %i5
400193f8: 83 30 60 08 srl %g1, 8, %g1
400193fc: 82 08 40 19 and %g1, %i1, %g1
40019400: ba 17 40 01 or %i5, %g1, %i5
40019404: c2 17 bf fa lduh [ %fp + -6 ], %g1
40019408: bb 2f 60 10 sll %i5, 0x10, %i5
4001940c: 83 28 60 10 sll %g1, 0x10, %g1
40019410: 89 30 60 18 srl %g1, 0x18, %g4
40019414: 83 30 60 08 srl %g1, 8, %g1
40019418: b2 08 40 19 and %g1, %i1, %i1
4001941c: 88 11 00 19 or %g4, %i1, %g4
40019420: 88 97 40 04 orcc %i5, %g4, %g4
40019424: 12 80 00 05 bne 40019438 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204><== ALWAYS TAKEN
40019428: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4001942c: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
40019430: 10 80 00 03 b 4001943c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
40019434: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
40019438: c8 22 60 1c st %g4, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001943c: 03 00 08 00 sethi %hi(0x200000), %g1
40019440: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
40019444: 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;
40019448: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
4001944c: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
40019450: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
40019454: 7f ff e7 4d call 40013188 <fat_file_size>
40019458: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
4001945c: ba 92 20 00 orcc %o0, 0, %i5
40019460: 02 80 00 04 be 40019470 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x23c><== ALWAYS TAKEN
40019464: d2 07 bf bc ld [ %fp + -68 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
40019468: 10 80 00 19 b 400194cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
4001946c: 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);
40019470: 87 2c 60 10 sll %l1, 0x10, %g3
40019474: 03 00 00 3f sethi %hi(0xfc00), %g1
40019478: 95 30 e0 18 srl %g3, 0x18, %o2
4001947c: 82 10 63 ff or %g1, 0x3ff, %g1
40019480: 87 30 e0 08 srl %g3, 8, %g3
40019484: 86 08 c0 01 and %g3, %g1, %g3
40019488: 85 2c 20 10 sll %l0, 0x10, %g2
4001948c: 94 12 80 03 or %o2, %g3, %o2
40019490: 87 30 a0 18 srl %g2, 0x18, %g3
40019494: 85 30 a0 08 srl %g2, 8, %g2
40019498: 82 08 80 01 and %g2, %g1, %g1
4001949c: 82 10 c0 01 or %g3, %g1, %g1
400194a0: 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,
400194a4: 90 10 00 18 mov %i0, %o0
400194a8: 94 12 80 01 or %o2, %g1, %o2
400194ac: 96 10 00 1a mov %i2, %o3
400194b0: 7f ff ff 00 call 400190b0 <msdos_find_node_by_cluster_num_in_fat_file>
400194b4: 98 10 00 1b mov %i3, %o4
400194b8: d2 07 bf bc ld [ %fp + -68 ], %o1
400194bc: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
400194c0: 80 a7 60 00 cmp %i5, 0
400194c4: 02 80 00 05 be 400194d8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a4><== ALWAYS TAKEN
400194c8: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
400194cc: 7f ff e5 98 call 40012b2c <fat_file_close> <== NOT EXECUTED
400194d0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
400194d4: 30 80 00 05 b,a 400194e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NOT EXECUTED
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
400194d8: 7f ff e5 95 call 40012b2c <fat_file_close>
400194dc: 01 00 00 00 nop
400194e0: ba 10 00 08 mov %o0, %i5
return rc;
}
400194e4: b0 10 00 1d mov %i5, %i0
400194e8: 81 c7 e0 08 ret
400194ec: 81 e8 00 00 restore
400194f0 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
400194f0: 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,
400194f4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
400194f8: 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
)
{
400194fc: 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,
40019500: 9a 10 00 1c mov %i4, %o5
40019504: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40019508: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
4001950c: 94 10 00 19 mov %i1, %o2
40019510: 96 10 00 1a mov %i2, %o3
40019514: 7f ff fc 8c call 40018744 <msdos_find_name_in_fat_file>
40019518: 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))
4001951c: 03 00 00 1f sethi %hi(0x7c00), %g1
40019520: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
40019524: 80 a2 00 01 cmp %o0, %g1
40019528: 02 80 00 05 be 4001953c <msdos_get_name_node+0x4c>
4001952c: b8 10 00 08 mov %o0, %i4
40019530: 80 a2 20 00 cmp %o0, 0
40019534: 12 80 00 2d bne 400195e8 <msdos_get_name_node+0xf8>
40019538: 01 00 00 00 nop
return rc;
if (!create_node)
4001953c: 80 a6 60 00 cmp %i1, 0
40019540: 12 80 00 2a bne 400195e8 <msdos_get_name_node+0xf8>
40019544: 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)
40019548: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
4001954c: 80 a7 00 01 cmp %i4, %g1
40019550: 02 80 00 26 be 400195e8 <msdos_get_name_node+0xf8>
40019554: 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)
40019558: 12 80 00 24 bne 400195e8 <msdos_get_name_node+0xf8> <== NEVER TAKEN
4001955c: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
40019560: 13 10 00 b1 sethi %hi(0x4002c400), %o1
40019564: 94 10 20 02 mov 2, %o2
40019568: 40 00 10 0e call 4001d5a0 <strncmp>
4001956c: 92 12 61 08 or %o1, 0x108, %o1
40019570: 80 a2 20 00 cmp %o0, 0
40019574: 12 80 00 1d bne 400195e8 <msdos_get_name_node+0xf8>
40019578: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
4001957c: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
40019580: c8 14 20 14 lduh [ %l0 + 0x14 ], %g4
40019584: 87 28 e0 10 sll %g3, 0x10, %g3
40019588: 89 29 20 10 sll %g4, 0x10, %g4
4001958c: 83 30 e0 18 srl %g3, 0x18, %g1
40019590: b3 31 20 18 srl %g4, 0x18, %i1
40019594: 89 31 20 08 srl %g4, 8, %g4
40019598: 84 10 a3 ff or %g2, 0x3ff, %g2
4001959c: 87 30 e0 08 srl %g3, 8, %g3
400195a0: 88 09 00 02 and %g4, %g2, %g4
400195a4: 84 08 c0 02 and %g3, %g2, %g2
400195a8: b2 16 40 04 or %i1, %g4, %i1
400195ac: 82 10 40 02 or %g1, %g2, %g1
400195b0: b3 2e 60 10 sll %i1, 0x10, %i1
/* are we right under root dir ? */
if (dotdot_cln == 0)
400195b4: b2 96 40 01 orcc %i1, %g1, %i1
400195b8: 12 80 00 08 bne 400195d8 <msdos_get_name_node+0xe8>
400195bc: 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;
400195c0: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400195c4: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
400195c8: 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;
400195cc: 82 10 20 01 mov 1, %g1
400195d0: 10 80 00 06 b 400195e8 <msdos_get_name_node+0xf8>
400195d4: c2 27 40 00 st %g1, [ %i5 ]
}
else
{
rc =
400195d8: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
400195dc: b4 10 00 1d mov %i5, %i2
400195e0: 7f ff ff 15 call 40019234 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
400195e4: 97 e8 00 10 restore %g0, %l0, %o3
}
}
}
}
return rc;
}
400195e8: 81 c7 e0 08 ret
400195ec: 91 e8 00 1c restore %g0, %i4, %o0
4000edc8 <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
)
{
4000edc8: 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));
4000edcc: 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;
4000edd0: 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));
4000edd4: 7f ff db 29 call 40005a78 <calloc>
4000edd8: 92 10 20 a4 mov 0xa4, %o1
if (!fs_info)
4000eddc: ba 92 20 00 orcc %o0, 0, %i5
4000ede0: 32 80 00 03 bne,a 4000edec <msdos_initialize_support+0x24><== ALWAYS TAKEN
4000ede4: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
4000ede8: 30 80 00 45 b,a 4000eefc <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);
4000edec: 40 00 12 b1 call 400138b0 <fat_init_volume_info>
4000edf0: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
4000edf4: b8 92 20 00 orcc %o0, 0, %i4
4000edf8: 12 80 00 12 bne 4000ee40 <msdos_initialize_support+0x78> <== NEVER TAKEN
4000edfc: 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;
4000ee00: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4000ee04: 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;
4000ee08: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
4000ee0c: f4 27 60 98 st %i2, [ %i5 + 0x98 ]
fs_info->directory_handlers = directory_handlers;
4000ee10: 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;
4000ee14: 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;
4000ee18: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
4000ee1c: 90 10 00 1d mov %i5, %o0
4000ee20: 92 07 bf f0 add %fp, -16, %o1
4000ee24: 40 00 0e 2c call 400126d4 <fat_file_open>
4000ee28: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
4000ee2c: b8 92 20 00 orcc %o0, 0, %i4
4000ee30: 02 80 00 08 be 4000ee50 <msdos_initialize_support+0x88> <== ALWAYS TAKEN
4000ee34: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_shutdown_drive(&fs_info->fat);
4000ee38: 40 00 14 c2 call 40014140 <fat_shutdown_drive> <== NOT EXECUTED
4000ee3c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000ee40: 7f ff db 46 call 40005b58 <free> <== NOT EXECUTED
4000ee44: 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;
}
4000ee48: 81 c7 e0 08 ret <== NOT EXECUTED
4000ee4c: 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;
4000ee50: 03 00 08 00 sethi %hi(0x200000), %g1
4000ee54: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000ee58: 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;
4000ee5c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000ee60: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
4000ee64: 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 )
4000ee68: 80 a0 60 00 cmp %g1, 0
4000ee6c: 12 80 00 09 bne 4000ee90 <msdos_initialize_support+0xc8>
4000ee70: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4000ee74: 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 :
4000ee78: 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) ?
4000ee7c: 80 a2 00 01 cmp %o0, %g1
4000ee80: 1a 80 00 13 bcc 4000eecc <msdos_initialize_support+0x104>
4000ee84: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
4000ee88: 10 80 00 11 b 4000eecc <msdos_initialize_support+0x104>
4000ee8c: 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);
4000ee90: 40 00 10 be call 40013188 <fat_file_size>
4000ee94: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
4000ee98: b4 92 20 00 orcc %o0, 0, %i2
4000ee9c: 22 80 00 0c be,a 4000eecc <msdos_initialize_support+0x104><== ALWAYS TAKEN
4000eea0: d0 17 60 06 lduh [ %i5 + 6 ], %o0
{
fat_file_close(&fs_info->fat, fat_fd);
4000eea4: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000eea8: 40 00 0f 21 call 40012b2c <fat_file_close> <== NOT EXECUTED
4000eeac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000eeb0: 40 00 14 a4 call 40014140 <fat_shutdown_drive> <== NOT EXECUTED
4000eeb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000eeb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000eebc: 7f ff db 27 call 40005b58 <free> <== NOT EXECUTED
4000eec0: 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;
}
4000eec4: 81 c7 e0 08 ret <== NOT EXECUTED
4000eec8: 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));
4000eecc: 7f ff da eb call 40005a78 <calloc>
4000eed0: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
4000eed4: 80 a2 20 00 cmp %o0, 0
4000eed8: 12 80 00 0f bne 4000ef14 <msdos_initialize_support+0x14c> <== ALWAYS TAKEN
4000eedc: d0 27 60 a0 st %o0, [ %i5 + 0xa0 ]
{
fat_file_close(&fs_info->fat, fat_fd);
4000eee0: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000eee4: 40 00 0f 12 call 40012b2c <fat_file_close> <== NOT EXECUTED
4000eee8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000eeec: 40 00 14 95 call 40014140 <fat_shutdown_drive> <== NOT EXECUTED
4000eef0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000eef4: 7f ff db 19 call 40005b58 <free> <== NOT EXECUTED
4000eef8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4000eefc: 40 00 32 92 call 4001b944 <__errno> <== NOT EXECUTED
4000ef00: 01 00 00 00 nop <== NOT EXECUTED
4000ef04: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
4000ef08: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000ef0c: 10 80 00 1b b 4000ef78 <msdos_initialize_support+0x1b0> <== NOT EXECUTED
4000ef10: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
4000ef14: 92 10 20 01 mov 1, %o1
4000ef18: 90 10 20 03 mov 3, %o0
4000ef1c: 94 10 20 10 mov 0x10, %o2
4000ef20: 96 10 20 00 clr %o3
4000ef24: 7f ff eb 91 call 40009d68 <rtems_semaphore_create>
4000ef28: 98 07 60 9c add %i5, 0x9c, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
4000ef2c: 80 a2 20 00 cmp %o0, 0
4000ef30: 02 80 00 0e be 4000ef68 <msdos_initialize_support+0x1a0> <== ALWAYS TAKEN
4000ef34: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
4000ef38: 40 00 0e fd call 40012b2c <fat_file_close> <== NOT EXECUTED
4000ef3c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000ef40: 40 00 14 80 call 40014140 <fat_shutdown_drive> <== NOT EXECUTED
4000ef44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
4000ef48: 7f ff db 04 call 40005b58 <free> <== NOT EXECUTED
4000ef4c: d0 07 60 a0 ld [ %i5 + 0xa0 ], %o0 <== NOT EXECUTED
free(fs_info);
4000ef50: 7f ff db 02 call 40005b58 <free> <== NOT EXECUTED
4000ef54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4000ef58: 40 00 32 7b call 4001b944 <__errno> <== NOT EXECUTED
4000ef5c: 01 00 00 00 nop <== NOT EXECUTED
4000ef60: 10 bf ff ea b 4000ef08 <msdos_initialize_support+0x140> <== NOT EXECUTED
4000ef64: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
4000ef68: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000ef6c: d2 20 60 08 st %o1, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
4000ef70: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->ops = op_table;
4000ef74: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
4000ef78: b0 10 00 1c mov %i4, %i0
4000ef7c: 81 c7 e0 08 ret
4000ef80: 81 e8 00 00 restore
4000ed94 <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000ed94: 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,
4000ed98: 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(
4000ed9c: 92 10 20 00 clr %o1
4000eda0: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
4000eda4: 7f ff ec 8e call 40009fdc <rtems_semaphore_obtain>
4000eda8: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
4000edac: 80 a2 20 00 cmp %o0, 0
4000edb0: 02 80 00 04 be 4000edc0 <msdos_lock+0x2c> <== ALWAYS TAKEN
4000edb4: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
4000edb8: 7f ff ee 62 call 4000a740 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000edbc: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
4000edc0: 81 c7 e0 08 ret
4000edc4: 81 e8 00 00 restore
4001809c <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)
{
4001809c: 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);
400180a0: 92 10 20 20 mov 0x20, %o1
400180a4: 90 10 00 1a mov %i2, %o0
400180a8: 40 00 11 09 call 4001c4cc <memset>
400180ac: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
400180b0: c2 4e 00 00 ldsb [ %i0 ], %g1
400180b4: 80 a0 60 2e cmp %g1, 0x2e
400180b8: 12 80 00 23 bne 40018144 <msdos_long_to_short+0xa8>
400180bc: 84 10 20 00 clr %g2
400180c0: 80 a6 60 01 cmp %i1, 1
400180c4: 32 80 00 04 bne,a 400180d4 <msdos_long_to_short+0x38>
400180c8: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
400180cc: 10 80 00 0a b 400180f4 <msdos_long_to_short+0x58>
400180d0: 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))
400180d4: 80 a0 60 2e cmp %g1, 0x2e
400180d8: 12 80 00 1c bne 40018148 <msdos_long_to_short+0xac> <== NEVER TAKEN
400180dc: 80 a0 80 19 cmp %g2, %i1
400180e0: 80 a6 60 02 cmp %i1, 2
400180e4: 12 80 00 19 bne 40018148 <msdos_long_to_short+0xac> <== NEVER TAKEN
400180e8: 80 a0 80 19 cmp %g2, %i1
{
sfn[0] = sfn[1] = '.';
400180ec: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
400180f0: 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;
400180f4: 10 80 00 72 b 400182bc <msdos_long_to_short+0x220>
400180f8: 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] != '.'))
400180fc: 80 a0 60 2e cmp %g1, 0x2e
40018100: 22 80 00 11 be,a 40018144 <msdos_long_to_short+0xa8> <== NEVER TAKEN
40018104: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40018108: 80 a0 60 20 cmp %g1, 0x20
4001810c: 22 80 00 0e be,a 40018144 <msdos_long_to_short+0xa8>
40018110: 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) ||
40018114: 03 10 00 b4 sethi %hi(0x4002d000), %g1
40018118: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 ! 4002d1a8 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
4001811c: 2d 10 00 b1 sethi %hi(0x4002c400), %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
40018120: 2f 10 00 b1 sethi %hi(0x4002c400), %l7
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
40018124: c2 27 bf fc st %g1, [ %fp + -4 ]
40018128: b8 10 20 00 clr %i4
4001812c: a2 10 3f ff mov -1, %l1
40018130: a4 10 20 00 clr %l2
40018134: a6 10 20 00 clr %l3
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
40018138: ac 15 a3 38 or %l6, 0x338, %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
4001813c: 10 80 00 45 b 40018250 <msdos_long_to_short+0x1b4>
40018140: ae 15 e3 40 or %l7, 0x340, %l7
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
40018144: 80 a0 80 19 cmp %g2, %i1
40018148: 26 bf ff ed bl,a 400180fc <msdos_long_to_short+0x60> <== ALWAYS TAKEN
4001814c: c2 4e 00 02 ldsb [ %i0 + %g2 ], %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
40018150: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
40018154: 12 bf ff f0 bne 40018114 <msdos_long_to_short+0x78> <== NOT EXECUTED
40018158: 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;
}
4001815c: 81 c7 e0 08 ret <== NOT EXECUTED
40018160: 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 == '.';
40018164: 80 a0 00 01 cmp %g0, %g1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
40018168: 90 10 00 16 mov %l6, %o0
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
4001816c: 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)
40018170: 92 10 00 1b mov %i3, %o1
40018174: 40 00 14 1a call 4001d1dc <strchr>
40018178: aa 10 00 14 mov %l4, %l5
4001817c: 80 a2 20 00 cmp %o0, 0
40018180: 12 80 00 12 bne 400181c8 <msdos_long_to_short+0x12c>
40018184: ba 10 20 02 mov 2, %i5
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
40018188: 80 8d 20 ff btst 0xff, %l4
4001818c: 12 80 00 0e bne 400181c4 <msdos_long_to_short+0x128>
40018190: c2 07 bf fc ld [ %fp + -4 ], %g1
40018194: 84 0c 20 ff and %l0, 0xff, %g2
40018198: 84 00 40 02 add %g1, %g2, %g2
4001819c: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
400181a0: 80 88 a0 07 btst 7, %g2
400181a4: 12 80 00 09 bne 400181c8 <msdos_long_to_short+0x12c>
400181a8: ba 10 20 01 mov 1, %i5
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400181ac: 90 10 00 17 mov %l7, %o0
400181b0: 40 00 14 0b call 4001d1dc <strchr>
400181b4: 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;
400181b8: 80 a0 00 08 cmp %g0, %o0
400181bc: 10 80 00 03 b 400181c8 <msdos_long_to_short+0x12c>
400181c0: ba 40 20 00 addx %g0, 0, %i5
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
400181c4: 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))
400181c8: 80 8f 60 01 btst 1, %i5
400181cc: 02 80 00 2f be 40018288 <msdos_long_to_short+0x1ec>
400181d0: 80 a4 7f ff cmp %l1, -1
return type;
if (dot_at >= 0)
400181d4: 02 80 00 0a be 400181fc <msdos_long_to_short+0x160>
400181d8: 80 8d 60 ff btst 0xff, %l5
{
if (is_dot || ((count - dot_at) > 3))
400181dc: 32 80 00 2e bne,a 40018294 <msdos_long_to_short+0x1f8>
400181e0: ba 10 20 02 mov 2, %i5
400181e4: 82 27 00 11 sub %i4, %l1, %g1
400181e8: 80 a0 60 03 cmp %g1, 3
400181ec: 24 80 00 0d ble,a 40018220 <msdos_long_to_short+0x184> <== ALWAYS TAKEN
400181f0: 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;
400181f4: 10 80 00 28 b 40018294 <msdos_long_to_short+0x1f8> <== NOT EXECUTED
400181f8: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
400181fc: 80 a5 20 00 cmp %l4, 0
40018200: 12 80 00 05 bne 40018214 <msdos_long_to_short+0x178>
40018204: 80 8d 60 ff btst 0xff, %l5
40018208: 80 a7 20 08 cmp %i4, 8
4001820c: 02 80 00 28 be 400182ac <msdos_long_to_short+0x210>
40018210: 80 8d 60 ff btst 0xff, %l5
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
40018214: 32 80 00 0e bne,a 4001824c <msdos_long_to_short+0x1b0>
40018218: a2 10 00 1c mov %i4, %l1
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
4001821c: 82 04 3f bf add %l0, -65, %g1
40018220: 82 08 60 ff and %g1, 0xff, %g1
40018224: 80 a0 60 19 cmp %g1, 0x19
40018228: 28 80 00 09 bleu,a 4001824c <msdos_long_to_short+0x1b0>
4001822c: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
40018230: a0 04 3f 9f add %l0, -97, %l0
40018234: a0 0c 20 ff and %l0, 0xff, %l0
40018238: 80 a4 20 19 cmp %l0, 0x19
4001823c: 28 80 00 04 bleu,a 4001824c <msdos_long_to_short+0x1b0>
40018240: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
40018244: 10 80 00 03 b 40018250 <msdos_long_to_short+0x1b4>
40018248: b8 07 20 01 inc %i4
4001824c: b8 07 20 01 inc %i4
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
40018250: f6 4e 00 1c ldsb [ %i0 + %i4 ], %i3
40018254: 80 a6 e0 00 cmp %i3, 0
40018258: 02 80 00 05 be 4001826c <msdos_long_to_short+0x1d0>
4001825c: e0 0e 00 1c ldub [ %i0 + %i4 ], %l0
40018260: 80 a7 00 19 cmp %i4, %i1
40018264: 06 bf ff c0 bl 40018164 <msdos_long_to_short+0xc8>
40018268: 82 1e e0 2e xor %i3, 0x2e, %g1
count++;
name++;
}
if (lowercase && uppercase)
4001826c: 80 8c e0 ff btst 0xff, %l3
40018270: 02 80 00 11 be 400182b4 <msdos_long_to_short+0x218>
40018274: 80 8c a0 ff btst 0xff, %l2
40018278: 22 80 00 07 be,a 40018294 <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
4001827c: 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;
40018280: 10 80 00 05 b 40018294 <msdos_long_to_short+0x1f8> <== NOT EXECUTED
40018284: 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)
40018288: 82 97 60 00 orcc %i5, 0, %g1
4001828c: 22 80 00 0d be,a 400182c0 <msdos_long_to_short+0x224> <== NEVER TAKEN
40018290: 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);
40018294: 90 10 00 18 mov %i0, %o0
40018298: 92 10 00 19 mov %i1, %o1
4001829c: 40 00 0a 88 call 4001acbc <msdos_filename_unix2dos>
400182a0: 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;
400182a4: 10 80 00 06 b 400182bc <msdos_long_to_short+0x220>
400182a8: 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;
400182ac: 10 bf ff fa b 40018294 <msdos_long_to_short+0x1f8>
400182b0: ba 10 20 02 mov 2, %i5
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
400182b4: 10 bf ff f8 b 40018294 <msdos_long_to_short+0x1f8>
400182b8: 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;
}
400182bc: b0 10 00 01 mov %g1, %i0
400182c0: 81 c7 e0 08 ret
400182c4: 81 e8 00 00 restore
4000ef84 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000ef84: 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))
4000ef88: 05 00 00 3c sethi %hi(0xf000), %g2
4000ef8c: 03 00 00 10 sethi %hi(0x4000), %g1
4000ef90: 84 0e c0 02 and %i3, %g2, %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000ef94: 88 10 00 19 mov %i1, %g4
4000ef98: 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))
4000ef9c: 80 a0 80 01 cmp %g2, %g1
4000efa0: 02 80 00 07 be 4000efbc <msdos_mknod+0x38>
4000efa4: b8 10 00 1b mov %i3, %i4
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
4000efa8: 3b 00 00 20 sethi %hi(0x8000), %i5
4000efac: 80 a0 80 1d cmp %g2, %i5
4000efb0: 02 80 00 04 be 4000efc0 <msdos_mknod+0x3c> <== ALWAYS TAKEN
4000efb4: b2 10 20 04 mov 4, %i1
4000efb8: 30 80 00 06 b,a 4000efd0 <msdos_mknod+0x4c> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
4000efbc: 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);
4000efc0: b4 10 00 04 mov %g4, %i2
4000efc4: b6 10 00 03 mov %g3, %i3
4000efc8: 40 00 22 d3 call 40017b14 <msdos_creat_node>
4000efcc: 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);
4000efd0: 40 00 32 5d call 4001b944 <__errno> <== NOT EXECUTED
4000efd4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000efd8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000efdc: 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;
}
4000efe0: 81 c7 e0 08 ret <== NOT EXECUTED
4000efe4: 81 e8 00 00 restore <== NOT EXECUTED
4000eff4 <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
)
{
4000eff4: 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;
4000eff8: 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,
4000effc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000f000: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000f004: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000f008: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000f00c: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
4000f010: 40 00 22 c1 call 40017b14 <msdos_creat_node> <== NOT EXECUTED
4000f014: 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)
4000f018: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000f01c: 12 80 00 05 bne 4000f030 <msdos_rename+0x3c> <== NOT EXECUTED
4000f020: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4000f024: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
4000f028: 40 00 25 2e call 400184e0 <msdos_set_first_char4file_name><== NOT EXECUTED
4000f02c: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
4000f030: 81 c7 e0 08 ret <== NOT EXECUTED
4000f034: 81 e8 00 00 restore <== NOT EXECUTED
4000f038 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
4000f038: 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;
4000f03c: 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;
4000f040: 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)
4000f044: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000f048: 80 a0 a0 00 cmp %g2, 0
4000f04c: 12 80 00 19 bne 4000f0b0 <msdos_rmnod+0x78>
4000f050: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
4000f054: 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);
4000f058: 92 10 00 1d mov %i5, %o1
4000f05c: 40 00 25 6e call 40018614 <msdos_dir_is_empty>
4000f060: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
4000f064: b0 92 20 00 orcc %o0, 0, %i0
4000f068: 12 80 00 1a bne 4000f0d0 <msdos_rmnod+0x98> <== NEVER TAKEN
4000f06c: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
4000f070: 80 a0 60 00 cmp %g1, 0
4000f074: 32 80 00 06 bne,a 4000f08c <msdos_rmnod+0x54>
4000f078: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
4000f07c: 40 00 32 32 call 4001b944 <__errno>
4000f080: 01 00 00 00 nop
4000f084: 10 80 00 08 b 4000f0a4 <msdos_rmnod+0x6c>
4000f088: 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)
4000f08c: 80 a0 60 01 cmp %g1, 1
4000f090: 28 80 00 08 bleu,a 4000f0b0 <msdos_rmnod+0x78> <== ALWAYS TAKEN
4000f094: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
4000f098: 40 00 32 2b call 4001b944 <__errno> <== NOT EXECUTED
4000f09c: 01 00 00 00 nop <== NOT EXECUTED
4000f0a0: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
4000f0a4: c2 22 00 00 st %g1, [ %o0 ]
4000f0a8: 81 c7 e0 08 ret
4000f0ac: 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,
4000f0b0: 92 07 60 20 add %i5, 0x20, %o1
4000f0b4: 40 00 25 0b call 400184e0 <msdos_set_first_char4file_name>
4000f0b8: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
4000f0bc: b0 92 20 00 orcc %o0, 0, %i0
4000f0c0: 12 80 00 04 bne 4000f0d0 <msdos_rmnod+0x98> <== NEVER TAKEN
4000f0c4: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
4000f0c8: 40 00 10 1c call 40013138 <fat_file_mark_removed>
4000f0cc: 92 10 00 1d mov %i5, %o1
return rc;
}
4000f0d0: 81 c7 e0 08 ret
4000f0d4: 81 e8 00 00 restore
400182c8 <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
)
{
400182c8: 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);
400182cc: 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;
400182d0: 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);
400182d4: 94 07 bf fc add %fp, -4, %o2
400182d8: 40 00 09 de call 4001aa50 <msdos_date_unix2dos>
400182dc: 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);
400182e0: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
400182e4: 7f ff ff 60 call 40018064 <fat_cluster_num_to_sector_num>
400182e8: 90 10 00 1d mov %i5, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
400182ec: 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);
400182f0: 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);
400182f4: 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);
400182f8: 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);
400182fc: 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);
40018300: b8 0f 00 01 and %i4, %g1, %i4
time_val = CT_LE_W(time_val);
40018304: 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);
40018308: 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);
4001830c: 83 28 60 10 sll %g1, 0x10, %g1
40018310: 85 30 60 08 srl %g1, 8, %g2
40018314: 83 30 60 18 srl %g1, 0x18, %g1
40018318: 82 10 80 01 or %g2, %g1, %g1
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
4001831c: 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);
40018320: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40018324: 94 07 20 16 add %i4, 0x16, %o2
40018328: 96 10 20 02 mov 2, %o3
4001832c: 98 07 bf fc add %fp, -4, %o4
40018330: 7f ff ec a7 call 400135cc <fat_sector_write>
40018334: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
40018338: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
4001833c: 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);
40018340: 83 28 60 10 sll %g1, 0x10, %g1
40018344: 85 30 60 08 srl %g1, 8, %g2
40018348: 83 30 60 18 srl %g1, 0x18, %g1
4001834c: 82 10 80 01 or %g2, %g1, %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40018350: 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);
40018354: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40018358: 96 10 20 02 mov 2, %o3
4001835c: 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,
40018360: 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,
40018364: 7f ff ec 9a call 400135cc <fat_sector_write>
40018368: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
4001836c: 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,
40018370: b2 10 00 08 mov %o0, %i1
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40018374: 94 07 20 12 add %i4, 0x12, %o2
40018378: 90 10 00 1d mov %i5, %o0
4001837c: 96 10 20 02 mov 2, %o3
40018380: 7f ff ec 93 call 400135cc <fat_sector_write>
40018384: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
40018388: 80 a6 60 00 cmp %i1, 0
4001838c: 06 80 00 04 bl 4001839c <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
40018390: 80 a6 a0 00 cmp %i2, 0
40018394: 16 80 00 04 bge 400183a4 <msdos_set_dir_wrt_time_and_date+0xdc><== ALWAYS TAKEN
40018398: 80 a2 20 00 cmp %o0, 0
return -1;
4001839c: 81 c7 e0 08 ret <== NOT EXECUTED
400183a0: 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) )
400183a4: 06 bf ff fe bl 4001839c <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
400183a8: 01 00 00 00 nop
return -1;
return RC_OK;
}
400183ac: 81 c7 e0 08 ret
400183b0: 91 e8 20 00 restore %g0, 0, %o0
400184e0 <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
)
{
400184e0: 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;
400184e4: 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;
400184e8: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
400184ec: c2 27 bf f0 st %g1, [ %fp + -16 ]
400184f0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fat_pos_t end = dir_pos->sname;
400184f4: 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;
400184f8: c2 27 bf f4 st %g1, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
400184fc: 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
)
{
40018500: 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;
40018504: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40018508: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
4001850c: 80 a7 00 01 cmp %i4, %g1
40018510: 12 80 00 08 bne 40018530 <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
40018514: f8 27 bf f8 st %i4, [ %fp + -8 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
40018518: 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) &&
4001851c: 80 88 60 03 btst 3, %g1
40018520: 22 80 00 05 be,a 40018534 <msdos_set_first_char4file_name+0x54><== NEVER TAKEN
40018524: 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;
40018528: 10 80 00 03 b 40018534 <msdos_set_first_char4file_name+0x54>
4001852c: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
else
dir_block_size = fs_info->fat.vol.bpc;
40018530: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
40018534: c2 06 60 08 ld [ %i1 + 8 ], %g1
40018538: 80 a0 7f ff cmp %g1, -1
4001853c: 12 80 00 07 bne 40018558 <msdos_set_first_char4file_name+0x78>
40018540: d2 07 bf f0 ld [ %fp + -16 ], %o1
start = dir_pos->sname;
40018544: c2 06 40 00 ld [ %i1 ], %g1
40018548: c2 27 bf f0 st %g1, [ %fp + -16 ]
4001854c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40018550: 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) +
40018554: d2 07 bf f0 ld [ %fp + -16 ], %o1
40018558: 7f ff fe c3 call 40018064 <fat_cluster_num_to_sector_num>
4001855c: 90 10 00 1d mov %i5, %o0
(start.ofs >> fs_info->fat.vol.sec_log2));
40018560: c2 07 bf f4 ld [ %fp + -12 ], %g1
40018564: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40018568: 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));
4001856c: 93 30 40 09 srl %g1, %o1, %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40018570: 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) +
40018574: 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,
40018578: 94 0a 80 01 and %o2, %g1, %o2
4001857c: 90 10 00 1d mov %i5, %o0
40018580: 96 10 20 01 mov 1, %o3
40018584: 7f ff ec 12 call 400135cc <fat_sector_write>
40018588: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
4001858c: 80 a2 20 00 cmp %o0, 0
40018590: 06 80 00 1e bl 40018608 <msdos_set_first_char4file_name+0x128><== NEVER TAKEN
40018594: d2 07 bf f0 ld [ %fp + -16 ], %o1
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
40018598: 80 a2 40 1c cmp %o1, %i4
4001859c: 12 80 00 08 bne 400185bc <msdos_set_first_char4file_name+0xdc><== NEVER TAKEN
400185a0: c2 07 bf f4 ld [ %fp + -12 ], %g1
400185a4: c4 07 bf fc ld [ %fp + -4 ], %g2
400185a8: 80 a0 40 02 cmp %g1, %g2
400185ac: 12 80 00 05 bne 400185c0 <msdos_set_first_char4file_name+0xe0>
400185b0: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
400185b4: 81 c7 e0 08 ret
400185b8: 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;
400185bc: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
400185c0: 80 a0 40 1b cmp %g1, %i3
400185c4: 0a bf ff e4 bcs 40018554 <msdos_set_first_char4file_name+0x74><== ALWAYS TAKEN
400185c8: c2 27 bf f4 st %g1, [ %fp + -12 ]
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
400185cc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
400185d0: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
400185d4: 12 80 00 06 bne 400185ec <msdos_set_first_char4file_name+0x10c><== NOT EXECUTED
400185d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
400185dc: 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) &&
400185e0: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
400185e4: 12 bf ff f4 bne 400185b4 <msdos_set_first_char4file_name+0xd4><== NOT EXECUTED
400185e8: 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);
400185ec: 40 00 04 e9 call 40019990 <fat_get_fat_cluster> <== NOT EXECUTED
400185f0: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
400185f4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
400185f8: 12 80 00 05 bne 4001860c <msdos_set_first_char4file_name+0x12c><== NOT EXECUTED
400185fc: 01 00 00 00 nop <== NOT EXECUTED
return rc;
start.ofs = 0;
40018600: 10 bf ff d5 b 40018554 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
40018604: 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;
40018608: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
4001860c: 81 c7 e0 08 ret <== NOT EXECUTED
40018610: 81 e8 00 00 restore <== NOT EXECUTED
400183b4 <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
)
{
400183b4: 9d e3 bf 98 save %sp, -104, %sp
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
400183b8: 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);
400183bc: 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;
400183c0: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t le_cl_hi = 0;
400183c4: 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);
400183c8: 7f ff ff 27 call 40018064 <fat_cluster_num_to_sector_num>
400183cc: 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;
400183d0: 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);
400183d4: 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);
400183d8: 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);
400183dc: 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);
400183e0: 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);
400183e4: 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);
400183e8: b6 0e c0 01 and %i3, %g1, %i3
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
400183ec: 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));
400183f0: 83 2f 20 10 sll %i4, 0x10, %g1
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
400183f4: 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));
400183f8: 83 30 60 18 srl %g1, 0x18, %g1
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
400183fc: 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));
40018400: 85 28 a0 08 sll %g2, 8, %g2
40018404: 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);
40018408: 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));
4001840c: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec,
40018410: 92 10 00 1a mov %i2, %o1
40018414: 94 06 e0 1a add %i3, 0x1a, %o2
40018418: 96 10 20 02 mov 2, %o3
4001841c: 98 07 bf fc add %fp, -4, %o4
40018420: 7f ff ec 6b call 400135cc <fat_sector_write>
40018424: 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));
40018428: 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,
4001842c: a0 10 00 08 mov %o0, %l0
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40018430: 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,
40018434: 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));
40018438: b3 2e 60 08 sll %i1, 8, %i1
4001843c: b9 37 20 08 srl %i4, 8, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
40018440: 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));
40018444: b8 16 40 1c or %i1, %i4, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
40018448: 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));
4001844c: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec,
40018450: 96 10 20 02 mov 2, %o3
40018454: 7f ff ec 5e call 400135cc <fat_sector_write>
40018458: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
4001845c: 80 a2 20 00 cmp %o0, 0
40018460: 06 80 00 04 bl 40018470 <msdos_set_first_cluster_num+0xbc><== NEVER TAKEN
40018464: 80 a4 20 00 cmp %l0, 0
40018468: 16 80 00 03 bge 40018474 <msdos_set_first_cluster_num+0xc0><== ALWAYS TAKEN
4001846c: b0 10 20 00 clr %i0
return -1;
40018470: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
40018474: 81 c7 e0 08 ret
40018478: 81 e8 00 00 restore
4000dd20 <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 )
{
4000dd20: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
4000dd24: 80 a6 20 00 cmp %i0, 0
4000dd28: 02 80 00 07 be 4000dd44 <msdos_set_sectors_per_cluster_from_request+0x24>
4000dd2c: ba 10 20 80 mov 0x80, %i5
4000dd30: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000dd34: 80 a0 60 00 cmp %g1, 0
4000dd38: 32 80 00 03 bne,a 4000dd44 <msdos_set_sectors_per_cluster_from_request+0x24>
4000dd3c: 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 )
{
4000dd40: ba 10 20 80 mov 0x80, %i5
4000dd44: 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 ) {
4000dd48: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000dd4c: 80 a0 40 1d cmp %g1, %i5
4000dd50: 2a 80 00 0c bcs,a 4000dd80 <msdos_set_sectors_per_cluster_from_request+0x60>
4000dd54: 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 ) {
4000dd58: 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;
4000dd5c: fa 26 60 0c st %i5, [ %i1 + 0xc ]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
4000dd60: 7f ff d2 76 call 40002738 <.udiv>
4000dd64: 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
4000dd68: 80 a7 40 08 cmp %i5, %o0
4000dd6c: 18 80 00 05 bgu 4000dd80 <msdos_set_sectors_per_cluster_from_request+0x60><== NEVER TAKEN
4000dd70: 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;
4000dd74: ba 10 20 01 mov 1, %i5
ret_val = 0;
4000dd78: 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 ) {
4000dd7c: bb 37 60 01 srl %i5, 1, %i5
4000dd80: 80 a7 60 00 cmp %i5, 0
4000dd84: 32 bf ff f2 bne,a 4000dd4c <msdos_set_sectors_per_cluster_from_request+0x2c>
4000dd88: c2 06 60 0c ld [ %i1 + 0xc ], %g1
ret_val = 0;
}
}
}
if (ret_val != 0) {
4000dd8c: 80 a6 20 00 cmp %i0, 0
4000dd90: 02 80 00 06 be 4000dda8 <msdos_set_sectors_per_cluster_from_request+0x88><== ALWAYS TAKEN
4000dd94: 01 00 00 00 nop
errno = EINVAL;
4000dd98: 40 00 36 eb call 4001b944 <__errno> <== NOT EXECUTED
4000dd9c: 01 00 00 00 nop <== NOT EXECUTED
4000dda0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
4000dda4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return ret_val;
}
4000dda8: 81 c7 e0 08 ret
4000ddac: 81 e8 00 00 restore
40019804 <msdos_sync>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
40019804: 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;
40019808: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001980c: 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;
40019810: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
40019814: 94 10 20 00 clr %o2
40019818: 7f ff c1 f1 call 40009fdc <rtems_semaphore_obtain>
4001981c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40019820: 80 a2 20 00 cmp %o0, 0
40019824: 02 80 00 08 be 40019844 <msdos_sync+0x40> <== ALWAYS TAKEN
40019828: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
4001982c: 40 00 08 46 call 4001b944 <__errno> <== NOT EXECUTED
40019830: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40019834: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40019838: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001983c: 81 c7 e0 08 ret <== NOT EXECUTED
40019840: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_sync(&fs_info->fat);
40019844: 7f ff ea 0b call 40014070 <fat_sync>
40019848: 90 10 00 1d mov %i5, %o0
4001984c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
40019850: 7f ff c2 2c call 4000a100 <rtems_semaphore_release>
40019854: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
40019858: 81 c7 e0 08 ret
4001985c: 81 e8 00 00 restore
4000ed68 <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000ed68: 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);
4000ed6c: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000ed70: 7f ff ec e4 call 4000a100 <rtems_semaphore_release>
4000ed74: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
if (sc != RTEMS_SUCCESSFUL) {
4000ed78: 80 a2 20 00 cmp %o0, 0
4000ed7c: 02 80 00 04 be 4000ed8c <msdos_unlock+0x24> <== ALWAYS TAKEN
4000ed80: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
4000ed84: 7f ff ee 6f call 4000a740 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000ed88: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
4000ed8c: 81 c7 e0 08 ret
4000ed90: 81 e8 00 00 restore
40004b48 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
40004b48: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
40004b4c: 03 10 00 7a sethi %hi(0x4001e800), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
40004b50: 80 a6 00 19 cmp %i0, %i1
40004b54: 02 80 00 03 be 40004b60 <newlib_delete_hook+0x18>
40004b58: fa 00 61 38 ld [ %g1 + 0x138 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
40004b5c: fa 06 61 48 ld [ %i1 + 0x148 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
40004b60: 80 a7 60 00 cmp %i5, 0
40004b64: 02 80 00 0b be 40004b90 <newlib_delete_hook+0x48> <== NEVER TAKEN
40004b68: 03 10 00 77 sethi %hi(0x4001dc00), %g1
40004b6c: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 4001dc78 <_global_impure_ptr>
40004b70: 80 a7 40 01 cmp %i5, %g1
40004b74: 02 80 00 07 be 40004b90 <newlib_delete_hook+0x48>
40004b78: 13 10 00 12 sethi %hi(0x40004800), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
40004b7c: 90 10 00 1d mov %i5, %o0
40004b80: 40 00 2d e6 call 40010318 <_fwalk>
40004b84: 92 12 61 3c or %o1, 0x13c, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
40004b88: 40 00 1b 4c call 4000b8b8 <_Workspace_Free>
40004b8c: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
40004b90: 80 a6 00 19 cmp %i0, %i1
40004b94: 12 80 00 04 bne 40004ba4 <newlib_delete_hook+0x5c>
40004b98: c0 26 61 48 clr [ %i1 + 0x148 ]
_REENT = 0;
40004b9c: 03 10 00 7a sethi %hi(0x4001e800), %g1
40004ba0: c0 20 61 38 clr [ %g1 + 0x138 ] ! 4001e938 <_impure_ptr>
40004ba4: 81 c7 e0 08 ret
40004ba8: 81 e8 00 00 restore
4000493c <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
4000493c: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
40004940: 40 00 2d 7b call 4000ff2c <fileno>
40004944: 90 10 00 18 mov %i0, %o0
40004948: 80 a2 20 02 cmp %o0, 2
4000494c: 18 80 00 0e bgu 40004984 <newlib_free_buffers+0x48> <== NEVER TAKEN
40004950: 01 00 00 00 nop
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
40004954: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
40004958: 80 88 60 80 btst 0x80, %g1
4000495c: 02 80 00 0c be 4000498c <newlib_free_buffers+0x50> <== ALWAYS TAKEN
40004960: 01 00 00 00 nop
free( fp->_bf._base );
40004964: 7f ff fd b0 call 40004024 <free> <== NOT EXECUTED
40004968: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
4000496c: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40004970: 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;
40004974: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40004978: 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;
4000497c: 10 80 00 04 b 4000498c <newlib_free_buffers+0x50> <== NOT EXECUTED
40004980: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
40004984: 40 00 2c aa call 4000fc2c <fclose> <== NOT EXECUTED
40004988: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
4000498c: 81 c7 e0 08 ret
40004990: 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 9c sethi %hi(0x40027000), %o0 <== NOT EXECUTED
40001ff8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40001ffc: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
40002000: 40 00 6a a8 call 4001caa0 <printf> <== NOT EXECUTED
40002004: 31 10 00 9c sethi %hi(0x40027000), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
40002008: 40 00 6a e7 call 4001cba4 <puts> <== NOT EXECUTED
4000200c: 91 ee 23 90 restore %i0, 0x390, %o0 <== NOT EXECUTED
400075d0 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
400075d0: 81 c3 e0 08 retl <== NOT EXECUTED
400075d4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400075e0 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
400075e0: 81 c3 e0 08 retl <== NOT EXECUTED
400075a8 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
400075a8: 81 c3 e0 08 retl <== NOT EXECUTED
400075ac: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400075c8 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
400075c8: 81 c3 e0 08 retl <== NOT EXECUTED
400075cc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400075f8 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
400075f8: 81 c3 e0 08 retl <== NOT EXECUTED
400075fc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40007600 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
40007600: 81 c3 e0 08 retl <== NOT EXECUTED
40007604: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400075a0 <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
400075a0: 81 c3 e0 08 retl <== NOT EXECUTED
400075a4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400066f4 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
400066f4: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
400066f8: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
400066fc: 80 88 60 01 btst 1, %g1
40006700: 02 80 00 56 be 40006858 <oproc+0x164> <== NEVER TAKEN
40006704: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
40006708: 84 0e 20 ff and %i0, 0xff, %g2
4000670c: 80 a0 a0 09 cmp %g2, 9
40006710: 22 80 00 2a be,a 400067b8 <oproc+0xc4>
40006714: c4 06 60 28 ld [ %i1 + 0x28 ], %g2
40006718: 18 80 00 07 bgu 40006734 <oproc+0x40> <== ALWAYS TAKEN
4000671c: 80 a0 a0 0a cmp %g2, 0xa
40006720: 80 a0 a0 08 cmp %g2, 8 <== NOT EXECUTED
40006724: 12 80 00 36 bne 400067fc <oproc+0x108> <== NOT EXECUTED
40006728: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
4000672c: 10 80 00 2f b 400067e8 <oproc+0xf4> <== NOT EXECUTED
40006730: 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) {
40006734: 02 80 00 06 be 4000674c <oproc+0x58>
40006738: 80 a0 a0 0d cmp %g2, 0xd
4000673c: 32 80 00 30 bne,a 400067fc <oproc+0x108> <== ALWAYS TAKEN
40006740: 80 88 60 02 btst 2, %g1
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
40006744: 10 80 00 0f b 40006780 <oproc+0x8c> <== NOT EXECUTED
40006748: 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)
4000674c: 80 88 60 20 btst 0x20, %g1
40006750: 32 80 00 02 bne,a 40006758 <oproc+0x64> <== NEVER TAKEN
40006754: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
40006758: 80 88 60 04 btst 4, %g1
4000675c: 02 80 00 40 be 4000685c <oproc+0x168> <== NEVER TAKEN
40006760: 90 07 a0 44 add %fp, 0x44, %o0
rtems_termios_puts ("\r", 1, tty);
40006764: 11 10 00 74 sethi %hi(0x4001d000), %o0
40006768: 92 10 20 01 mov 1, %o1
4000676c: 90 12 23 08 or %o0, 0x308, %o0
40006770: 7f ff ff 98 call 400065d0 <rtems_termios_puts>
40006774: 94 10 00 19 mov %i1, %o2
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
40006778: 10 80 00 38 b 40006858 <oproc+0x164>
4000677c: c0 26 60 28 clr [ %i1 + 0x28 ]
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
40006780: 02 80 00 06 be 40006798 <oproc+0xa4> <== NOT EXECUTED
40006784: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40006788: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
4000678c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006790: 02 80 00 36 be 40006868 <oproc+0x174> <== NOT EXECUTED
40006794: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
40006798: 22 80 00 30 be,a 40006858 <oproc+0x164> <== NOT EXECUTED
4000679c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
400067a0: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
400067a4: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400067a8: 02 80 00 2c be 40006858 <oproc+0x164> <== NOT EXECUTED
400067ac: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
400067b0: 10 80 00 2a b 40006858 <oproc+0x164> <== NOT EXECUTED
400067b4: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
400067b8: 92 10 20 08 mov 8, %o1
400067bc: 86 08 a0 07 and %g2, 7, %g3
400067c0: 92 22 40 03 sub %o1, %g3, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
400067c4: 07 00 00 06 sethi %hi(0x1800), %g3
400067c8: 82 08 40 03 and %g1, %g3, %g1
400067cc: 80 a0 40 03 cmp %g1, %g3
400067d0: 82 00 80 09 add %g2, %o1, %g1
400067d4: 12 80 00 21 bne 40006858 <oproc+0x164> <== NEVER TAKEN
400067d8: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
400067dc: 11 10 00 74 sethi %hi(0x4001d000), %o0
400067e0: 10 80 00 20 b 40006860 <oproc+0x16c>
400067e4: 90 12 23 10 or %o0, 0x310, %o0 ! 4001d310 <rtems_termios_baud_table+0x108>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
400067e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400067ec: 04 80 00 1b ble 40006858 <oproc+0x164> <== NOT EXECUTED
400067f0: 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++;
400067f4: 10 80 00 19 b 40006858 <oproc+0x164> <== NOT EXECUTED
400067f8: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
400067fc: 02 80 00 0d be 40006830 <oproc+0x13c> <== ALWAYS TAKEN
40006800: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1
c = toupper(c);
40006804: 03 10 00 7a sethi %hi(0x4001e800), %g1 <== NOT EXECUTED
40006808: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 4001e930 <__ctype_ptr__><== NOT EXECUTED
4000680c: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
40006810: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
40006814: c2 08 60 01 ldub [ %g1 + 1 ], %g1 <== NOT EXECUTED
40006818: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
4000681c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40006820: 22 80 00 02 be,a 40006828 <oproc+0x134> <== NOT EXECUTED
40006824: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
40006828: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
4000682c: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1 <== NOT EXECUTED
40006830: 05 10 00 7a sethi %hi(0x4001e800), %g2
40006834: c4 00 a1 30 ld [ %g2 + 0x130 ], %g2 ! 4001e930 <__ctype_ptr__>
40006838: 82 00 80 01 add %g2, %g1, %g1
4000683c: c2 08 60 01 ldub [ %g1 + 1 ], %g1
40006840: 80 88 60 20 btst 0x20, %g1
40006844: 12 80 00 06 bne 4000685c <oproc+0x168> <== NEVER TAKEN
40006848: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
4000684c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
40006850: 82 00 60 01 inc %g1
40006854: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
40006858: 90 07 a0 44 add %fp, 0x44, %o0
4000685c: 92 10 20 01 mov 1, %o1
40006860: 7f ff ff 5c call 400065d0 <rtems_termios_puts>
40006864: 94 10 00 19 mov %i1, %o2
40006868: 81 c7 e0 08 ret
4000686c: 81 e8 00 00 restore
40005258 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
40005258: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
4000525c: 80 a6 20 00 cmp %i0, 0
40005260: 02 80 00 11 be 400052a4 <partition_free+0x4c>
40005264: 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));
40005268: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
4000526c: 82 08 60 7f and %g1, 0x7f, %g1
40005270: 80 a0 60 05 cmp %g1, 5
40005274: 22 80 00 04 be,a 40005284 <partition_free+0x2c> <== NEVER TAKEN
40005278: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
4000527c: 40 00 03 84 call 4000608c <free>
40005280: 81 e8 00 00 restore
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
40005284: 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]);
40005288: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
4000528c: 7f ff ff f3 call 40005258 <partition_free> <== NOT EXECUTED
40005290: 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;
40005294: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
40005298: 12 bf ff fc bne 40005288 <partition_free+0x30> <== NOT EXECUTED
4000529c: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
400052a0: 30 bf ff f7 b,a 4000527c <partition_free+0x24> <== NOT EXECUTED
400052a4: 81 c7 e0 08 ret
400052a8: 81 e8 00 00 restore
40005590 <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)
{
40005590: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
40005594: 92 10 20 00 clr %o1
40005598: 90 10 00 18 mov %i0, %o0
4000559c: 40 00 06 54 call 40006eec <open>
400055a0: ba 10 20 19 mov 0x19, %i5
if (fd < 0)
400055a4: 80 a2 20 00 cmp %o0, 0
400055a8: 06 80 00 6d bl 4000575c <partition_table_get+0x1cc> <== NEVER TAKEN
400055ac: b8 10 00 08 mov %o0, %i4
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
400055b0: 40 00 02 e1 call 40006134 <fstat>
400055b4: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
400055b8: 80 a2 20 00 cmp %o0, 0
400055bc: 12 80 00 66 bne 40005754 <partition_table_get+0x1c4> <== NEVER TAKEN
400055c0: 90 06 60 08 add %i1, 8, %o0
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
400055c4: 92 10 00 18 mov %i0, %o1
400055c8: 40 00 43 bd call 400164bc <strncpy>
400055cc: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
400055d0: c4 1f bf d0 ldd [ %fp + -48 ], %g2
400055d4: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
400055d8: c4 07 bf f8 ld [ %fp + -8 ], %g2
400055dc: 80 a0 a0 00 cmp %g2, 0
400055e0: 02 80 00 03 be 400055ec <partition_table_get+0x5c> <== ALWAYS TAKEN
400055e4: 82 10 22 00 mov 0x200, %g1
400055e8: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
400055ec: 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;
400055f0: 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);
400055f4: 90 10 00 1c mov %i4, %o0
400055f8: 92 10 20 00 clr %o1
400055fc: 94 10 20 00 clr %o2
40005600: 96 10 20 00 clr %o3
40005604: 40 00 03 bf call 40006500 <lseek>
40005608: ba 10 20 1b mov 0x1b, %i5
if (new_off != off) {
4000560c: 80 92 00 09 orcc %o0, %o1, %g0
40005610: 12 80 00 09 bne 40005634 <partition_table_get+0xa4> <== NEVER TAKEN
40005614: d0 07 bf b0 ld [ %fp + -80 ], %o0
40005618: 90 10 00 1c mov %i4, %o0
4000561c: 92 10 20 00 clr %o1
40005620: 7f ff ff 2e call 400052d8 <get_sector.part.0>
40005624: 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)
40005628: ba 92 20 00 orcc %o0, 0, %i5
4000562c: 02 80 00 06 be 40005644 <partition_table_get+0xb4> <== ALWAYS TAKEN
40005630: d0 07 bf b0 ld [ %fp + -80 ], %o0
{
if (sector)
40005634: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005638: 02 80 00 47 be 40005754 <partition_table_get+0x1c4> <== NOT EXECUTED
4000563c: 01 00 00 00 nop <== NOT EXECUTED
40005640: 30 80 00 19 b,a 400056a4 <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) &&
40005644: c4 0a 22 02 ldub [ %o0 + 0x202 ], %g2
40005648: 80 a0 a0 55 cmp %g2, 0x55
4000564c: 12 80 00 06 bne 40005664 <partition_table_get+0xd4> <== NEVER TAKEN
40005650: 82 10 20 00 clr %g1
40005654: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
40005658: 82 18 60 aa xor %g1, 0xaa, %g1
4000565c: 80 a0 00 01 cmp %g0, %g1
40005660: 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))
40005664: 80 a0 60 00 cmp %g1, 0
40005668: 32 80 00 05 bne,a 4000567c <partition_table_get+0xec> <== ALWAYS TAKEN
4000566c: b0 02 21 c2 add %o0, 0x1c2, %i0
{
free(sector);
40005670: 40 00 02 87 call 4000608c <free> <== NOT EXECUTED
40005674: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
40005678: 30 80 00 37 b,a 40005754 <partition_table_get+0x1c4> <== NOT EXECUTED
4000567c: 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;
40005680: 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)
40005684: 91 2e e0 04 sll %i3, 4, %o0
40005688: 92 07 bf b4 add %fp, -76, %o1
4000568c: 7f ff ff 29 call 40005330 <data_to_part_desc.part.1>
40005690: 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)
40005694: ba 92 20 00 orcc %o0, 0, %i5
40005698: 02 80 00 06 be 400056b0 <partition_table_get+0x120> <== ALWAYS TAKEN
4000569c: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
400056a0: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
400056a4: 40 00 02 7a call 4000608c <free> <== NOT EXECUTED
400056a8: 01 00 00 00 nop <== NOT EXECUTED
400056ac: 30 80 00 2a b,a 40005754 <partition_table_get+0x1c4> <== NOT EXECUTED
return rc;
}
if (part_desc != NULL)
400056b0: 80 a0 60 00 cmp %g1, 0
400056b4: 02 80 00 0b be 400056e0 <partition_table_get+0x150> <== NEVER TAKEN
400056b8: 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;
400056bc: c6 00 60 04 ld [ %g1 + 4 ], %g3
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
400056c0: c4 28 60 02 stb %g2, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
400056c4: 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;
400056c8: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
400056cc: 84 00 c0 02 add %g3, %g2, %g2
400056d0: 84 00 bf ff add %g2, -1, %g2
400056d4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
400056d8: 10 80 00 03 b 400056e4 <partition_table_get+0x154>
400056dc: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
}
else
{
disk_desc->partitions[part_num] = NULL;
400056e0: 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++)
400056e4: 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;
400056e8: 80 a6 e0 04 cmp %i3, 4
400056ec: 12 bf ff e6 bne 40005684 <partition_table_get+0xf4>
400056f0: b4 06 a0 04 add %i2, 4, %i2
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
400056f4: 40 00 02 66 call 4000608c <free>
400056f8: d0 07 bf b0 ld [ %fp + -80 ], %o0
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
400056fc: f6 26 60 24 st %i3, [ %i1 + 0x24 ]
40005700: 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)
40005704: 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];
40005708: d4 06 a0 28 ld [ %i2 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
4000570c: 80 a2 a0 00 cmp %o2, 0
40005710: 02 80 00 0d be 40005744 <partition_table_get+0x1b4> <== NEVER TAKEN
40005714: 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));
40005718: 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))
4000571c: 82 08 60 7f and %g1, 0x7f, %g1
40005720: 80 a0 60 05 cmp %g1, 5
40005724: 32 80 00 09 bne,a 40005748 <partition_table_get+0x1b8>
40005728: b6 06 e0 04 add %i3, 4, %i3
{
read_extended_partition(fd, part_desc->start, part_desc);
4000572c: d2 02 a0 04 ld [ %o2 + 4 ], %o1
40005730: 7f ff ff 31 call 400053f4 <read_extended_partition>
40005734: 90 10 00 1c mov %i4, %o0
free(part_desc);
40005738: 40 00 02 55 call 4000608c <free>
4000573c: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
40005740: c0 26 a0 28 clr [ %i2 + 0x28 ]
40005744: 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;
40005748: 80 a6 e0 10 cmp %i3, 0x10
4000574c: 12 bf ff ef bne 40005708 <partition_table_get+0x178>
40005750: 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);
40005754: 40 00 02 2d call 40006008 <close>
40005758: 90 10 00 1c mov %i4, %o0
return rc;
}
4000575c: 81 c7 e0 08 ret
40005760: 91 e8 00 1d restore %g0, %i5, %o0
400053dc <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
400053dc: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
400053e0: 92 10 20 00 clr %o1
400053e4: 7f ff ff 6f call 400051a0 <open>
400053e8: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
400053ec: 80 a2 3f ff cmp %o0, -1
400053f0: 02 80 00 09 be 40005414 <pathconf+0x38> <== ALWAYS TAKEN
400053f4: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
400053f8: 40 00 13 ac call 4000a2a8 <fpathconf> <== NOT EXECUTED
400053fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005400: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
40005404: 40 00 13 7c call 4000a1f4 <close> <== NOT EXECUTED
40005408: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
4000540c: 81 c7 e0 08 ret <== NOT EXECUTED
40005410: 81 e8 00 00 restore <== NOT EXECUTED
}
40005414: 81 c7 e0 08 ret
40005418: 91 e8 3f ff restore %g0, -1, %o0
4000d348 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
4000d348: 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)
4000d34c: 11 10 00 7b sethi %hi(0x4001ec00), %o0
4000d350: 92 10 21 ff mov 0x1ff, %o1
4000d354: 40 00 05 29 call 4000e7f8 <rtems_mkdir>
4000d358: 90 12 23 20 or %o0, 0x320, %o0
4000d35c: 80 a2 20 00 cmp %o0, 0
4000d360: 12 80 00 47 bne 4000d47c <pipe_create+0x134>
4000d364: 03 00 00 19 sethi %hi(0x6400), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4000d368: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <PROM_START+0x666f>
4000d36c: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000d370: 03 10 00 80 sethi %hi(0x40020000), %g1
4000d374: d4 10 61 40 lduh [ %g1 + 0x140 ], %o2 ! 40020140 <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);
4000d378: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
4000d37c: 84 10 a1 70 or %g2, 0x170, %g2 ! 2f746d70 <RAM_SIZE+0x2f346d70>
4000d380: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
4000d384: 86 10 e2 69 or %g3, 0x269, %g3 ! 2f2e6669 <RAM_SIZE+0x2eee6669>
4000d388: c4 3f bf f0 std %g2, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000d38c: 84 02 a0 01 add %o2, 1, %g2
4000d390: 90 07 bf fa add %fp, -6, %o0
4000d394: c4 30 61 40 sth %g2, [ %g1 + 0x140 ]
4000d398: 95 2a a0 10 sll %o2, 0x10, %o2
4000d39c: 13 10 00 7b sethi %hi(0x4001ec00), %o1
4000d3a0: 95 32 a0 10 srl %o2, 0x10, %o2
4000d3a4: 40 00 11 f4 call 40011b74 <sprintf>
4000d3a8: 92 12 63 28 or %o1, 0x328, %o1
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4000d3ac: 90 07 bf f0 add %fp, -16, %o0
4000d3b0: 40 00 04 68 call 4000e550 <mkfifo>
4000d3b4: 92 10 21 80 mov 0x180, %o1
4000d3b8: 80 a2 20 00 cmp %o0, 0
4000d3bc: 02 80 00 05 be 4000d3d0 <pipe_create+0x88> <== ALWAYS TAKEN
4000d3c0: 90 07 bf f0 add %fp, -16, %o0
if (errno != EEXIST){
4000d3c4: 40 00 0f 1a call 4001102c <__errno> <== NOT EXECUTED
4000d3c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000d3cc: 30 80 00 2d b,a 4000d480 <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);
4000d3d0: 7f ff e0 0b call 400053fc <open>
4000d3d4: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
4000d3d8: 80 a2 20 00 cmp %o0, 0
4000d3dc: 16 80 00 06 bge 4000d3f4 <pipe_create+0xac>
4000d3e0: d0 26 00 00 st %o0, [ %i0 ]
err = errno;
4000d3e4: 40 00 0f 12 call 4001102c <__errno>
4000d3e8: 01 00 00 00 nop
4000d3ec: 10 80 00 1c b 4000d45c <pipe_create+0x114>
4000d3f0: 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]);
4000d3f4: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000d3f8: c4 00 60 b4 ld [ %g1 + 0xb4 ], %g2 ! 4001f8b4 <rtems_libio_number_iops>
4000d3fc: 80 a2 00 02 cmp %o0, %g2
4000d400: 1a 80 00 08 bcc 4000d420 <pipe_create+0xd8> <== NEVER TAKEN
4000d404: 82 10 20 00 clr %g1
4000d408: 83 2a 20 03 sll %o0, 3, %g1
4000d40c: 91 2a 20 06 sll %o0, 6, %o0
4000d410: 90 22 00 01 sub %o0, %g1, %o0
4000d414: 03 10 00 81 sethi %hi(0x40020400), %g1
4000d418: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 ! 40020428 <rtems_libio_iops>
4000d41c: 82 00 40 08 add %g1, %o0, %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4000d420: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000d424: 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;
4000d428: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000d42c: 92 10 20 01 mov 1, %o1
4000d430: 7f ff df f3 call 400053fc <open>
4000d434: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4000d438: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
4000d43c: 80 a2 20 00 cmp %o0, 0
4000d440: 16 80 00 07 bge 4000d45c <pipe_create+0x114>
4000d444: ba 10 20 00 clr %i5
err = errno;
4000d448: 40 00 0e f9 call 4001102c <__errno>
4000d44c: 01 00 00 00 nop
4000d450: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
4000d454: 7f ff dc 9e call 400046cc <close>
4000d458: d0 06 00 00 ld [ %i0 ], %o0
}
unlink(fifopath);
4000d45c: 7f ff eb 48 call 4000817c <unlink>
4000d460: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
4000d464: 80 a7 60 00 cmp %i5, 0
4000d468: 02 80 00 06 be 4000d480 <pipe_create+0x138>
4000d46c: b0 10 20 00 clr %i0
rtems_set_errno_and_return_minus_one(err);
4000d470: 40 00 0e ef call 4001102c <__errno>
4000d474: 01 00 00 00 nop
4000d478: 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;
4000d47c: b0 10 3f ff mov -1, %i0
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000d480: 81 c7 e0 08 ret
4000d484: 81 e8 00 00 restore
4000e870 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4000e870: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
4000e874: 03 10 01 19 sethi %hi(0x40046400), %g1
4000e878: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <__end+0x21c0f>
4000e87c: 80 a6 40 01 cmp %i1, %g1
4000e880: 12 80 00 11 bne 4000e8c4 <pipe_ioctl+0x54>
4000e884: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
4000e888: 02 80 00 11 be 4000e8cc <pipe_ioctl+0x5c>
4000e88c: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
4000e890: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000e894: 7f ff eb 39 call 40009578 <rtems_semaphore_obtain>
4000e898: 94 10 20 00 clr %o2
4000e89c: 80 a2 20 00 cmp %o0, 0
4000e8a0: 12 80 00 0d bne 4000e8d4 <pipe_ioctl+0x64> <== NEVER TAKEN
4000e8a4: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000e8a8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
4000e8ac: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000e8b0: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
4000e8b4: 7f ff eb 7a call 4000969c <rtems_semaphore_release>
4000e8b8: b0 10 20 00 clr %i0
return 0;
4000e8bc: 81 c7 e0 08 ret
4000e8c0: 81 e8 00 00 restore
}
return -EINVAL;
4000e8c4: 81 c7 e0 08 ret
4000e8c8: 91 e8 3f ea restore %g0, -22, %o0
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4000e8cc: 81 c7 e0 08 ret
4000e8d0: 91 e8 3f f2 restore %g0, -14, %o0
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
4000e8d4: 81 c7 e0 08 ret <== NOT EXECUTED
4000e8d8: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
4000e504 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000e504: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4000e508: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000e50c: 92 10 20 00 clr %o1
4000e510: 94 10 20 00 clr %o2
4000e514: 7f ff ec 19 call 40009578 <rtems_semaphore_obtain>
4000e518: ba 10 00 18 mov %i0, %i5
4000e51c: 80 a2 20 00 cmp %o0, 0
4000e520: 32 80 00 5d bne,a 4000e694 <pipe_read+0x190> <== NEVER TAKEN
4000e524: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
4000e528: 10 80 00 4d b 4000e65c <pipe_read+0x158>
4000e52c: b0 10 20 00 clr %i0
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4000e530: 80 a0 60 00 cmp %g1, 0
4000e534: 32 80 00 04 bne,a 4000e544 <pipe_read+0x40>
4000e538: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4000e53c: 10 80 00 4c b 4000e66c <pipe_read+0x168>
4000e540: b8 10 20 00 clr %i4
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000e544: 80 88 60 01 btst 1, %g1
4000e548: 32 80 00 49 bne,a 4000e66c <pipe_read+0x168>
4000e54c: 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 ++;
4000e550: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
4000e554: 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 ++;
4000e558: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000e55c: 7f ff ec 50 call 4000969c <rtems_semaphore_release>
4000e560: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
4000e564: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e568: 40 00 05 68 call 4000fb08 <rtems_barrier_wait>
4000e56c: 92 10 20 00 clr %o1
4000e570: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e574: 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))
4000e578: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e57c: 92 10 20 00 clr %o1
4000e580: 94 10 20 00 clr %o2
4000e584: 7f ff eb fd call 40009578 <rtems_semaphore_obtain>
4000e588: b8 0f 3f fc and %i4, -4, %i4
4000e58c: 80 a2 20 00 cmp %o0, 0
4000e590: 12 80 00 3b bne 4000e67c <pipe_read+0x178> <== NEVER TAKEN
4000e594: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4000e598: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000e59c: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000e5a0: 12 80 00 33 bne 4000e66c <pipe_read+0x168> <== NEVER TAKEN
4000e5a4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
4000e5a8: f8 07 60 0c ld [ %i5 + 0xc ], %i4
4000e5ac: 80 a7 20 00 cmp %i4, 0
4000e5b0: 22 bf ff e0 be,a 4000e530 <pipe_read+0x2c>
4000e5b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4000e5b8: 82 26 80 18 sub %i2, %i0, %g1
4000e5bc: 80 a7 00 01 cmp %i4, %g1
4000e5c0: 38 80 00 02 bgu,a 4000e5c8 <pipe_read+0xc4>
4000e5c4: b8 10 00 01 mov %g1, %i4
chunk1 = pipe->Size - pipe->Start;
4000e5c8: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e5cc: e0 07 60 04 ld [ %i5 + 4 ], %l0
4000e5d0: d2 07 40 00 ld [ %i5 ], %o1
4000e5d4: 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);
4000e5d8: 94 10 00 1c mov %i4, %o2
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
4000e5dc: 80 a7 00 10 cmp %i4, %l0
4000e5e0: 90 06 40 18 add %i1, %i0, %o0
4000e5e4: 04 80 00 09 ble 4000e608 <pipe_read+0x104>
4000e5e8: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000e5ec: 40 00 10 54 call 4001273c <memcpy>
4000e5f0: 94 10 00 10 mov %l0, %o2
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000e5f4: 90 06 00 10 add %i0, %l0, %o0
4000e5f8: d2 07 40 00 ld [ %i5 ], %o1
4000e5fc: 90 06 40 08 add %i1, %o0, %o0
4000e600: 10 80 00 02 b 4000e608 <pipe_read+0x104>
4000e604: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000e608: 40 00 10 4d call 4001273c <memcpy>
4000e60c: 01 00 00 00 nop
pipe->Start += chunk;
4000e610: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
4000e614: d2 07 60 04 ld [ %i5 + 4 ], %o1
4000e618: 40 00 3f 72 call 4001e3e0 <.urem>
4000e61c: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
4000e620: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4000e624: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
4000e628: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4000e62c: 80 a0 60 00 cmp %g1, 0
4000e630: 12 80 00 03 bne 4000e63c <pipe_read+0x138>
4000e634: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
4000e638: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
4000e63c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000e640: 80 a0 60 00 cmp %g1, 0
4000e644: 22 80 00 06 be,a 4000e65c <pipe_read+0x158>
4000e648: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPWRITERS(pipe);
4000e64c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000e650: 40 00 05 18 call 4000fab0 <rtems_barrier_release>
4000e654: 92 07 bf fc add %fp, -4, %o1
read += chunk;
4000e658: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4000e65c: 80 a6 00 1a cmp %i0, %i2
4000e660: 2a bf ff d3 bcs,a 4000e5ac <pipe_read+0xa8>
4000e664: f8 07 60 0c ld [ %i5 + 0xc ], %i4
4000e668: b8 10 20 00 clr %i4
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4000e66c: 7f ff ec 0c call 4000969c <rtems_semaphore_release>
4000e670: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
4000e674: 10 80 00 04 b 4000e684 <pipe_read+0x180>
4000e678: 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;
4000e67c: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
4000e680: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000e684: 14 80 00 04 bg 4000e694 <pipe_read+0x190>
4000e688: 01 00 00 00 nop
return read;
return ret;
4000e68c: 81 c7 e0 08 ret
4000e690: 91 e8 00 1c restore %g0, %i4, %o0
}
4000e694: 81 c7 e0 08 ret
4000e698: 81 e8 00 00 restore
4000dff4 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000dff4: 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);
4000dff8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4000dffc: 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)
4000e000: 80 88 60 02 btst 2, %g1
4000e004: 02 80 00 05 be 4000e018 <pipe_release+0x24>
4000e008: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
4000e00c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000e010: 84 00 bf ff add %g2, -1, %g2
4000e014: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000e018: 80 88 60 04 btst 4, %g1
4000e01c: 02 80 00 05 be 4000e030 <pipe_release+0x3c>
4000e020: 01 00 00 00 nop
pipe->Writers --;
4000e024: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000e028: 82 00 7f ff add %g1, -1, %g1
4000e02c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
4000e030: 7f ff ed 9b call 4000969c <rtems_semaphore_release>
4000e034: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000e038: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e03c: 80 a0 60 00 cmp %g1, 0
4000e040: 12 80 00 0d bne 4000e074 <pipe_release+0x80>
4000e044: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000e048: 80 a0 60 00 cmp %g1, 0
4000e04c: 12 80 00 06 bne 4000e064 <pipe_release+0x70>
4000e050: 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);
4000e054: 7f ff ff dd call 4000dfc8 <pipe_free>
4000e058: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
4000e05c: 10 80 00 0e b 4000e094 <pipe_release+0xa0>
4000e060: c0 26 00 00 clr [ %i0 ]
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000e064: 02 80 00 05 be 4000e078 <pipe_release+0x84> <== NEVER TAKEN
4000e068: 80 a0 60 00 cmp %g1, 0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4000e06c: 10 80 00 08 b 4000e08c <pipe_release+0x98>
4000e070: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4000e074: 80 a0 60 00 cmp %g1, 0
4000e078: 12 80 00 07 bne 4000e094 <pipe_release+0xa0> <== NEVER TAKEN
4000e07c: 80 a7 20 02 cmp %i4, 2
4000e080: 02 80 00 06 be 4000e098 <pipe_release+0xa4> <== NEVER TAKEN
4000e084: 03 10 00 8e sethi %hi(0x40023800), %g1
PIPE_WAKEUPREADERS(pipe);
4000e088: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e08c: 40 00 06 89 call 4000fab0 <rtems_barrier_release>
4000e090: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000e094: 03 10 00 8e sethi %hi(0x40023800), %g1
4000e098: 7f ff ed 81 call 4000969c <rtems_semaphore_release>
4000e09c: d0 00 62 d0 ld [ %g1 + 0x2d0 ], %o0 ! 40023ad0 <pipe_semaphore>
4000e0a0: 81 c7 e0 08 ret
4000e0a4: 81 e8 00 00 restore
4000e69c <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000e69c: 9d e3 bf 98 save %sp, -104, %sp
4000e6a0: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000e6a4: 80 a6 a0 00 cmp %i2, 0
4000e6a8: 02 80 00 70 be 4000e868 <pipe_write+0x1cc> <== NEVER TAKEN
4000e6ac: b0 10 20 00 clr %i0
return 0;
if (! PIPE_LOCK(pipe))
4000e6b0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e6b4: 92 10 20 00 clr %o1
4000e6b8: 7f ff eb b0 call 40009578 <rtems_semaphore_obtain>
4000e6bc: 94 10 20 00 clr %o2
4000e6c0: 80 a2 20 00 cmp %o0, 0
4000e6c4: 32 80 00 69 bne,a 4000e868 <pipe_write+0x1cc> <== NEVER TAKEN
4000e6c8: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
4000e6cc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e6d0: 80 a0 60 00 cmp %g1, 0
4000e6d4: 02 80 00 54 be 4000e824 <pipe_write+0x188>
4000e6d8: 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;
4000e6dc: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000e6e0: 80 a6 80 01 cmp %i2, %g1
4000e6e4: 18 80 00 03 bgu 4000e6f0 <pipe_write+0x54> <== NEVER TAKEN
4000e6e8: a2 10 20 01 mov 1, %l1
4000e6ec: 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;
4000e6f0: 10 80 00 49 b 4000e814 <pipe_write+0x178>
4000e6f4: 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)) {
4000e6f8: 80 88 60 01 btst 1, %g1
4000e6fc: 32 80 00 4a bne,a 4000e824 <pipe_write+0x188>
4000e700: 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 ++;
4000e704: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
4000e708: 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 ++;
4000e70c: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000e710: 7f ff eb e3 call 4000969c <rtems_semaphore_release>
4000e714: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
4000e718: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000e71c: 40 00 04 fb call 4000fb08 <rtems_barrier_wait>
4000e720: 92 10 20 00 clr %o1
4000e724: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e728: 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))
4000e72c: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e730: 92 10 20 00 clr %o1
4000e734: 94 10 20 00 clr %o2
4000e738: 7f ff eb 90 call 40009578 <rtems_semaphore_obtain>
4000e73c: b8 0f 3f fc and %i4, -4, %i4
4000e740: 80 a2 20 00 cmp %o0, 0
4000e744: 12 80 00 43 bne 4000e850 <pipe_write+0x1b4> <== NEVER TAKEN
4000e748: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4000e74c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000e750: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000e754: 12 80 00 34 bne 4000e824 <pipe_write+0x188> <== NEVER TAKEN
4000e758: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
4000e75c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e760: 80 a0 60 00 cmp %g1, 0
4000e764: 02 80 00 30 be 4000e824 <pipe_write+0x188> <== NEVER TAKEN
4000e768: 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) {
4000e76c: e0 07 60 04 ld [ %i5 + 4 ], %l0
4000e770: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000e774: b8 24 00 01 sub %l0, %g1, %i4
4000e778: 80 a7 00 11 cmp %i4, %l1
4000e77c: 2a bf ff df bcs,a 4000e6f8 <pipe_write+0x5c>
4000e780: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000e784: 84 26 80 18 sub %i2, %i0, %g2
4000e788: 80 a7 00 02 cmp %i4, %g2
4000e78c: 38 80 00 02 bgu,a 4000e794 <pipe_write+0xf8>
4000e790: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000e794: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000e798: 92 10 00 10 mov %l0, %o1
4000e79c: 40 00 3f 11 call 4001e3e0 <.urem>
4000e7a0: 90 00 40 08 add %g1, %o0, %o0
4000e7a4: c2 07 40 00 ld [ %i5 ], %g1
4000e7a8: 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);
4000e7ac: 94 10 00 1c mov %i4, %o2
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
4000e7b0: 80 a7 00 10 cmp %i4, %l0
4000e7b4: 92 06 40 18 add %i1, %i0, %o1
4000e7b8: 04 80 00 09 ble 4000e7dc <pipe_write+0x140>
4000e7bc: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000e7c0: 40 00 0f df call 4001273c <memcpy>
4000e7c4: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000e7c8: 92 04 00 18 add %l0, %i0, %o1
4000e7cc: d0 07 40 00 ld [ %i5 ], %o0
4000e7d0: 92 06 40 09 add %i1, %o1, %o1
4000e7d4: 10 80 00 02 b 4000e7dc <pipe_write+0x140>
4000e7d8: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000e7dc: 40 00 0f d8 call 4001273c <memcpy>
4000e7e0: 01 00 00 00 nop
pipe->Length += chunk;
4000e7e4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000e7e8: 82 00 40 1c add %g1, %i4, %g1
4000e7ec: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
4000e7f0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000e7f4: 80 a0 60 00 cmp %g1, 0
4000e7f8: 22 80 00 06 be,a 4000e810 <pipe_write+0x174>
4000e7fc: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPREADERS(pipe);
4000e800: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e804: 40 00 04 ab call 4000fab0 <rtems_barrier_release>
4000e808: 92 07 bf fc add %fp, -4, %o1
written += chunk;
4000e80c: b0 06 00 1c add %i0, %i4, %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
4000e810: 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) {
4000e814: 80 a6 00 1a cmp %i0, %i2
4000e818: 2a bf ff d6 bcs,a 4000e770 <pipe_write+0xd4>
4000e81c: e0 07 60 04 ld [ %i5 + 4 ], %l0
4000e820: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4000e824: 7f ff eb 9e call 4000969c <rtems_semaphore_release>
4000e828: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
4000e82c: 80 a7 3f e0 cmp %i4, -32
4000e830: 32 80 00 0a bne,a 4000e858 <pipe_write+0x1bc>
4000e834: 80 a6 20 00 cmp %i0, 0
kill(getpid(), SIGPIPE);
4000e838: 40 00 01 23 call 4000ecc4 <getpid>
4000e83c: 01 00 00 00 nop
4000e840: 40 00 02 95 call 4000f294 <kill>
4000e844: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
4000e848: 10 80 00 04 b 4000e858 <pipe_write+0x1bc>
4000e84c: 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;
4000e850: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000e854: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000e858: 14 80 00 04 bg 4000e868 <pipe_write+0x1cc>
4000e85c: 01 00 00 00 nop
4000e860: 81 c7 e0 08 ret
4000e864: 91 e8 00 1c restore %g0, %i4, %o0
return written;
return ret;
}
4000e868: 81 c7 e0 08 ret
4000e86c: 81 e8 00 00 restore
40009240 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
40009240: 05 10 00 98 sethi %hi(0x40026000), %g2
40009244: 84 10 a2 f8 or %g2, 0x2f8, %g2 ! 400262f8 <rtems_malloc_statistics>
40009248: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000924c: 86 00 e0 01 inc %g3
40009250: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40009254: 84 02 7f ff add %o1, -1, %g2
40009258: 80 88 80 09 btst %g2, %o1
4000925c: 12 80 00 07 bne 40009278 <posix_memalign+0x38> <== NEVER TAKEN
40009260: 80 a2 60 03 cmp %o1, 3
40009264: 08 80 00 05 bleu 40009278 <posix_memalign+0x38>
40009268: 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 );
4000926c: 82 13 c0 00 mov %o7, %g1
40009270: 40 00 00 85 call 40009484 <rtems_memalign>
40009274: 9e 10 40 00 mov %g1, %o7
}
40009278: 81 c3 e0 08 retl
4000927c: 90 10 20 16 mov 0x16, %o0
4000cb0c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4000cb0c: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
4000cb10: 80 a0 60 00 cmp %g1, 0
4000cb14: 02 80 00 0f be 4000cb50 <pthread_attr_setschedpolicy+0x44>
4000cb18: 90 10 20 16 mov 0x16, %o0
4000cb1c: c4 00 40 00 ld [ %g1 ], %g2
4000cb20: 80 a0 a0 00 cmp %g2, 0
4000cb24: 02 80 00 0b be 4000cb50 <pthread_attr_setschedpolicy+0x44>
4000cb28: 80 a2 60 04 cmp %o1, 4
return EINVAL;
switch ( policy ) {
4000cb2c: 38 80 00 09 bgu,a 4000cb50 <pthread_attr_setschedpolicy+0x44>
4000cb30: 90 10 20 86 mov 0x86, %o0
4000cb34: 84 10 20 01 mov 1, %g2
4000cb38: 85 28 80 09 sll %g2, %o1, %g2
4000cb3c: 80 88 a0 17 btst 0x17, %g2
4000cb40: 22 80 00 04 be,a 4000cb50 <pthread_attr_setschedpolicy+0x44><== NEVER TAKEN
4000cb44: 90 10 20 86 mov 0x86, %o0 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4000cb48: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
4000cb4c: 90 10 20 00 clr %o0
return 0;
default:
return ENOTSUP;
}
}
4000cb50: 81 c3 e0 08 retl
40007f64 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
40007f64: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
40007f68: 80 a6 20 00 cmp %i0, 0
40007f6c: 12 80 00 04 bne 40007f7c <pthread_barrier_init+0x18>
40007f70: 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;
40007f74: 81 c7 e0 08 ret
40007f78: 91 e8 20 16 restore %g0, 0x16, %o0
* Error check parameters
*/
if ( !barrier )
return EINVAL;
if ( count == 0 )
40007f7c: 22 80 00 1e be,a 40007ff4 <pthread_barrier_init+0x90>
40007f80: b0 10 20 16 mov 0x16, %i0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
40007f84: 80 a6 60 00 cmp %i1, 0
40007f88: 32 80 00 06 bne,a 40007fa0 <pthread_barrier_init+0x3c>
40007f8c: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
40007f90: 90 07 bf f8 add %fp, -8, %o0
40007f94: 7f ff ff bc call 40007e84 <pthread_barrierattr_init>
40007f98: 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 )
40007f9c: c2 06 40 00 ld [ %i1 ], %g1
40007fa0: 80 a0 60 00 cmp %g1, 0
40007fa4: 22 80 00 14 be,a 40007ff4 <pthread_barrier_init+0x90>
40007fa8: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
40007fac: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007fb0: 80 a0 60 00 cmp %g1, 0
40007fb4: 32 80 00 10 bne,a 40007ff4 <pthread_barrier_init+0x90> <== NEVER TAKEN
40007fb8: 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;
40007fbc: 03 10 00 61 sethi %hi(0x40018400), %g1
40007fc0: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 400186e0 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
40007fc4: c0 27 bf f0 clr [ %fp + -16 ]
the_attributes.maximum_count = count;
40007fc8: f4 27 bf f4 st %i2, [ %fp + -12 ]
++level;
40007fcc: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007fd0: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
* 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 *)
40007fd4: 39 10 00 62 sethi %hi(0x40018800), %i4
40007fd8: 40 00 08 68 call 4000a178 <_Objects_Allocate>
40007fdc: 90 17 22 64 or %i4, 0x264, %o0 ! 40018a64 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
40007fe0: ba 92 20 00 orcc %o0, 0, %i5
40007fe4: 12 80 00 06 bne 40007ffc <pthread_barrier_init+0x98>
40007fe8: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
40007fec: 40 00 0d 2a call 4000b494 <_Thread_Enable_dispatch>
40007ff0: b0 10 20 0b mov 0xb, %i0
40007ff4: 81 c7 e0 08 ret
40007ff8: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
40007ffc: 40 00 05 dc call 4000976c <_CORE_barrier_Initialize>
40008000: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008004: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008008: b8 17 22 64 or %i4, 0x264, %i4
4000800c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008010: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008014: 85 28 a0 02 sll %g2, 2, %g2
40008018: 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;
4000801c: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
40008020: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40008024: 40 00 0d 1c call 4000b494 <_Thread_Enable_dispatch>
40008028: b0 10 20 00 clr %i0
4000802c: 81 c7 e0 08 ret
40008030: 81 e8 00 00 restore
40007854 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
40007854: 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 )
40007858: 80 a6 20 00 cmp %i0, 0
4000785c: 02 80 00 12 be 400078a4 <pthread_cleanup_push+0x50>
40007860: 03 10 00 63 sethi %hi(0x40018c00), %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;
40007864: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 40018c40 <_Thread_Dispatch_disable_level>
++level;
40007868: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4000786c: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
40007870: 40 00 11 99 call 4000bed4 <_Workspace_Allocate>
40007874: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
40007878: 92 92 20 00 orcc %o0, 0, %o1
4000787c: 02 80 00 08 be 4000789c <pthread_cleanup_push+0x48> <== NEVER TAKEN
40007880: 03 10 00 64 sethi %hi(0x40019000), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40007884: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 40019160 <_Per_CPU_Information+0x10>
handler_stack = &thread_support->Cancellation_Handlers;
40007888: d0 00 61 50 ld [ %g1 + 0x150 ], %o0
handler->routine = routine;
4000788c: f0 22 60 08 st %i0, [ %o1 + 8 ]
handler->arg = arg;
40007890: f2 22 60 0c st %i1, [ %o1 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
40007894: 40 00 06 1e call 4000910c <_Chain_Append>
40007898: 90 02 20 e4 add %o0, 0xe4, %o0
}
_Thread_Enable_dispatch();
4000789c: 40 00 0d 62 call 4000ae24 <_Thread_Enable_dispatch>
400078a0: 81 e8 00 00 restore
400078a4: 81 c7 e0 08 ret
400078a8: 81 e8 00 00 restore
40008834 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
40008834: 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;
40008838: 80 a6 60 00 cmp %i1, 0
4000883c: 32 80 00 05 bne,a 40008850 <pthread_cond_init+0x1c>
40008840: c4 06 60 04 ld [ %i1 + 4 ], %g2
else the_attr = &_POSIX_Condition_variables_Default_attributes;
40008844: 33 10 00 60 sethi %hi(0x40018000), %i1
40008848: b2 16 61 3c or %i1, 0x13c, %i1 ! 4001813c <_POSIX_Condition_variables_Default_attributes>
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
4000884c: c4 06 60 04 ld [ %i1 + 4 ], %g2
40008850: 80 a0 a0 01 cmp %g2, 1
40008854: 02 80 00 25 be 400088e8 <pthread_cond_init+0xb4> <== NEVER TAKEN
40008858: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
4000885c: c4 06 40 00 ld [ %i1 ], %g2
40008860: 80 a0 a0 00 cmp %g2, 0
40008864: 02 80 00 21 be 400088e8 <pthread_cond_init+0xb4>
40008868: 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;
4000886c: 03 10 00 66 sethi %hi(0x40019800), %g1
40008870: c4 00 61 80 ld [ %g1 + 0x180 ], %g2 ! 40019980 <_Thread_Dispatch_disable_level>
++level;
40008874: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008878: c4 20 61 80 st %g2, [ %g1 + 0x180 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
4000887c: 39 10 00 67 sethi %hi(0x40019c00), %i4
40008880: 40 00 0a 11 call 4000b0c4 <_Objects_Allocate>
40008884: 90 17 21 9c or %i4, 0x19c, %o0 ! 40019d9c <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
40008888: ba 92 20 00 orcc %o0, 0, %i5
4000888c: 32 80 00 06 bne,a 400088a4 <pthread_cond_init+0x70>
40008890: c2 06 60 04 ld [ %i1 + 4 ], %g1
_Thread_Enable_dispatch();
40008894: 40 00 0e d3 call 4000c3e0 <_Thread_Enable_dispatch>
40008898: 01 00 00 00 nop
return ENOMEM;
4000889c: 10 80 00 13 b 400088e8 <pthread_cond_init+0xb4>
400088a0: 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(
400088a4: 90 07 60 18 add %i5, 0x18, %o0
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
400088a8: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
400088ac: 92 10 20 00 clr %o1
400088b0: 15 04 00 02 sethi %hi(0x10000800), %o2
400088b4: 96 10 20 74 mov 0x74, %o3
400088b8: 40 00 10 c1 call 4000cbbc <_Thread_queue_Initialize>
400088bc: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400088c0: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400088c4: b8 17 21 9c or %i4, 0x19c, %i4
400088c8: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400088cc: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400088d0: 85 28 a0 02 sll %g2, 2, %g2
400088d4: 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;
400088d8: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
400088dc: 40 00 0e c1 call 4000c3e0 <_Thread_Enable_dispatch>
400088e0: c2 26 00 00 st %g1, [ %i0 ]
return 0;
400088e4: 82 10 20 00 clr %g1
}
400088e8: 81 c7 e0 08 ret
400088ec: 91 e8 00 01 restore %g0, %g1, %o0
40008694 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
40008694: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
40008698: 80 a0 60 00 cmp %g1, 0
4000869c: 02 80 00 08 be 400086bc <pthread_condattr_destroy+0x28>
400086a0: 90 10 20 16 mov 0x16, %o0
400086a4: c4 00 40 00 ld [ %g1 ], %g2
400086a8: 80 a0 a0 00 cmp %g2, 0
400086ac: 02 80 00 04 be 400086bc <pthread_condattr_destroy+0x28> <== NEVER TAKEN
400086b0: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
400086b4: c0 20 40 00 clr [ %g1 ]
return 0;
400086b8: 90 10 20 00 clr %o0
}
400086bc: 81 c3 e0 08 retl
40007c2c <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
40007c2c: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
40007c30: 80 a6 a0 00 cmp %i2, 0
40007c34: 02 80 00 8c be 40007e64 <pthread_create+0x238>
40007c38: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40007c3c: 80 a6 60 00 cmp %i1, 0
40007c40: 32 80 00 05 bne,a 40007c54 <pthread_create+0x28>
40007c44: c2 06 40 00 ld [ %i1 ], %g1
40007c48: 33 10 00 79 sethi %hi(0x4001e400), %i1
40007c4c: b2 16 61 0c or %i1, 0x10c, %i1 ! 4001e50c <_POSIX_Threads_Default_attributes>
if ( !the_attr->is_initialized )
40007c50: c2 06 40 00 ld [ %i1 ], %g1
40007c54: 80 a0 60 00 cmp %g1, 0
40007c58: 02 80 00 83 be 40007e64 <pthread_create+0x238>
40007c5c: 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) )
40007c60: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007c64: 80 a0 60 00 cmp %g1, 0
40007c68: 02 80 00 07 be 40007c84 <pthread_create+0x58>
40007c6c: 03 10 00 7c sethi %hi(0x4001f000), %g1
40007c70: c4 06 60 08 ld [ %i1 + 8 ], %g2
40007c74: c2 00 61 30 ld [ %g1 + 0x130 ], %g1
40007c78: 80 a0 80 01 cmp %g2, %g1
40007c7c: 2a 80 00 7b bcs,a 40007e68 <pthread_create+0x23c>
40007c80: 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 ) {
40007c84: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40007c88: 80 a0 60 01 cmp %g1, 1
40007c8c: 02 80 00 06 be 40007ca4 <pthread_create+0x78>
40007c90: 80 a0 60 02 cmp %g1, 2
40007c94: 32 80 00 74 bne,a 40007e64 <pthread_create+0x238>
40007c98: ba 10 20 16 mov 0x16, %i5
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
40007c9c: 10 80 00 09 b 40007cc0 <pthread_create+0x94>
40007ca0: 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 ];
40007ca4: 03 10 00 80 sethi %hi(0x40020000), %g1
40007ca8: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1 ! 400203f0 <_Per_CPU_Information+0x10>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
40007cac: 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 ];
40007cb0: d2 00 61 50 ld [ %g1 + 0x150 ], %o1
schedpolicy = api->schedpolicy;
40007cb4: e2 02 60 84 ld [ %o1 + 0x84 ], %l1
schedparam = api->schedparam;
40007cb8: 10 80 00 04 b 40007cc8 <pthread_create+0x9c>
40007cbc: 92 02 60 88 add %o1, 0x88, %o1
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
40007cc0: 90 07 bf e4 add %fp, -28, %o0
40007cc4: 92 06 60 18 add %i1, 0x18, %o1
40007cc8: 40 00 23 ed call 40010c7c <memcpy>
40007ccc: 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 )
40007cd0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40007cd4: 80 a0 60 00 cmp %g1, 0
40007cd8: 12 80 00 63 bne 40007e64 <pthread_create+0x238>
40007cdc: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
40007ce0: 40 00 18 61 call 4000de64 <_POSIX_Priority_Is_valid>
40007ce4: d0 07 bf e4 ld [ %fp + -28 ], %o0
40007ce8: 80 8a 20 ff btst 0xff, %o0
40007cec: 02 80 00 5e be 40007e64 <pthread_create+0x238> <== NEVER TAKEN
40007cf0: 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);
40007cf4: 03 10 00 7c sethi %hi(0x4001f000), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
40007cf8: e4 07 bf e4 ld [ %fp + -28 ], %l2
40007cfc: e6 08 61 2c ldub [ %g1 + 0x12c ], %l3
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
40007d00: 90 10 00 11 mov %l1, %o0
40007d04: 92 07 bf e4 add %fp, -28, %o1
40007d08: 94 07 bf dc add %fp, -36, %o2
40007d0c: 40 00 18 61 call 4000de90 <_POSIX_Thread_Translate_sched_param>
40007d10: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
40007d14: ba 92 20 00 orcc %o0, 0, %i5
40007d18: 32 80 00 54 bne,a 40007e68 <pthread_create+0x23c>
40007d1c: b0 10 00 1d mov %i5, %i0
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
40007d20: 39 10 00 7f sethi %hi(0x4001fc00), %i4
40007d24: 40 00 06 36 call 400095fc <_API_Mutex_Lock>
40007d28: d0 07 23 50 ld [ %i4 + 0x350 ], %o0 ! 4001ff50 <_RTEMS_Allocator_Mutex>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
40007d2c: 11 10 00 80 sethi %hi(0x40020000), %o0
40007d30: 40 00 08 d2 call 4000a078 <_Objects_Allocate>
40007d34: 90 12 20 d4 or %o0, 0xd4, %o0 ! 400200d4 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
40007d38: a0 92 20 00 orcc %o0, 0, %l0
40007d3c: 32 80 00 04 bne,a 40007d4c <pthread_create+0x120>
40007d40: c2 06 60 08 ld [ %i1 + 8 ], %g1
_RTEMS_Unlock_allocator();
40007d44: 10 80 00 21 b 40007dc8 <pthread_create+0x19c>
40007d48: d0 07 23 50 ld [ %i4 + 0x350 ], %o0
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
40007d4c: 05 10 00 7c sethi %hi(0x4001f000), %g2
40007d50: d6 00 a1 30 ld [ %g2 + 0x130 ], %o3 ! 4001f130 <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(
40007d54: c0 27 bf d4 clr [ %fp + -44 ]
40007d58: 97 2a e0 01 sll %o3, 1, %o3
40007d5c: 80 a2 c0 01 cmp %o3, %g1
40007d60: 1a 80 00 03 bcc 40007d6c <pthread_create+0x140>
40007d64: d4 06 60 04 ld [ %i1 + 4 ], %o2
40007d68: 96 10 00 01 mov %g1, %o3
40007d6c: 82 10 20 01 mov 1, %g1
40007d70: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40007d74: c2 07 bf dc ld [ %fp + -36 ], %g1
40007d78: 9a 0c e0 ff and %l3, 0xff, %o5
40007d7c: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40007d80: c2 07 bf e0 ld [ %fp + -32 ], %g1
40007d84: c0 23 a0 68 clr [ %sp + 0x68 ]
40007d88: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40007d8c: 82 07 bf d4 add %fp, -44, %g1
40007d90: 39 10 00 80 sethi %hi(0x40020000), %i4
40007d94: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
40007d98: 90 17 20 d4 or %i4, 0xd4, %o0
40007d9c: 92 10 00 10 mov %l0, %o1
40007da0: 98 10 20 00 clr %o4
40007da4: 40 00 0d b4 call 4000b474 <_Thread_Initialize>
40007da8: 9a 23 40 12 sub %o5, %l2, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
40007dac: 80 8a 20 ff btst 0xff, %o0
40007db0: 12 80 00 0a bne 40007dd8 <pthread_create+0x1ac>
40007db4: 90 17 20 d4 or %i4, 0xd4, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
40007db8: 40 00 09 8f call 4000a3f4 <_Objects_Free>
40007dbc: 92 10 00 10 mov %l0, %o1
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
40007dc0: 03 10 00 7f sethi %hi(0x4001fc00), %g1
40007dc4: d0 00 63 50 ld [ %g1 + 0x350 ], %o0 ! 4001ff50 <_RTEMS_Allocator_Mutex>
40007dc8: 40 00 06 22 call 40009650 <_API_Mutex_Unlock>
40007dcc: ba 10 20 0b mov 0xb, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
40007dd0: 81 c7 e0 08 ret
40007dd4: 91 e8 00 1d restore %g0, %i5, %o0
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40007dd8: f8 04 21 50 ld [ %l0 + 0x150 ], %i4
api->Attributes = *the_attr;
40007ddc: 92 10 00 19 mov %i1, %o1
40007de0: 94 10 20 40 mov 0x40, %o2
40007de4: 40 00 23 a6 call 40010c7c <memcpy>
40007de8: 90 10 00 1c mov %i4, %o0
api->detachstate = the_attr->detachstate;
40007dec: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
40007df0: 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;
40007df4: c2 27 20 40 st %g1, [ %i4 + 0x40 ]
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
40007df8: 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;
40007dfc: e2 27 20 84 st %l1, [ %i4 + 0x84 ]
api->schedparam = schedparam;
40007e00: 40 00 23 9f call 40010c7c <memcpy>
40007e04: 90 07 20 88 add %i4, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
40007e08: 90 10 00 10 mov %l0, %o0
40007e0c: 92 10 20 01 mov 1, %o1
40007e10: 94 10 00 1a mov %i2, %o2
40007e14: 96 10 00 1b mov %i3, %o3
40007e18: 40 00 0f d0 call 4000bd58 <_Thread_Start>
40007e1c: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
40007e20: 80 a4 60 04 cmp %l1, 4
40007e24: 32 80 00 0a bne,a 40007e4c <pthread_create+0x220>
40007e28: c2 04 20 08 ld [ %l0 + 8 ], %g1
_Watchdog_Insert_ticks(
40007e2c: 40 00 0f f5 call 4000be00 <_Timespec_To_ticks>
40007e30: 90 07 20 90 add %i4, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40007e34: 92 07 20 a8 add %i4, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40007e38: d0 27 20 b4 st %o0, [ %i4 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40007e3c: 11 10 00 7f sethi %hi(0x4001fc00), %o0
40007e40: 40 00 10 a5 call 4000c0d4 <_Watchdog_Insert>
40007e44: 90 12 23 68 or %o0, 0x368, %o0 ! 4001ff68 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
40007e48: c2 04 20 08 ld [ %l0 + 8 ], %g1
40007e4c: c2 26 00 00 st %g1, [ %i0 ]
_RTEMS_Unlock_allocator();
40007e50: 03 10 00 7f sethi %hi(0x4001fc00), %g1
40007e54: 40 00 05 ff call 40009650 <_API_Mutex_Unlock>
40007e58: d0 00 63 50 ld [ %g1 + 0x350 ], %o0 ! 4001ff50 <_RTEMS_Allocator_Mutex>
return 0;
}
40007e5c: 81 c7 e0 08 ret
40007e60: 91 e8 00 1d restore %g0, %i5, %o0
40007e64: b0 10 00 1d mov %i5, %i0
40007e68: 81 c7 e0 08 ret
40007e6c: 81 e8 00 00 restore
4001c210 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
4001c210: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
4001c214: 80 a6 60 00 cmp %i1, 0
4001c218: 32 80 00 03 bne,a 4001c224 <pthread_kill+0x14>
4001c21c: b8 06 7f ff add %i1, -1, %i4
4001c220: 30 80 00 04 b,a 4001c230 <pthread_kill+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001c224: 80 a7 20 1f cmp %i4, 0x1f
4001c228: 28 80 00 06 bleu,a 4001c240 <pthread_kill+0x30>
4001c22c: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4001c230: 7f ff ce 2d call 4000fae4 <__errno>
4001c234: 01 00 00 00 nop
4001c238: 10 80 00 30 b 4001c2f8 <pthread_kill+0xe8>
4001c23c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
the_thread = _Thread_Get( thread, &location );
4001c240: 7f ff b9 a2 call 4000a8c8 <_Thread_Get>
4001c244: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4001c248: c2 07 bf fc ld [ %fp + -4 ], %g1
4001c24c: 80 a0 60 00 cmp %g1, 0
4001c250: 12 80 00 27 bne 4001c2ec <pthread_kill+0xdc> <== NEVER TAKEN
4001c254: ba 10 00 08 mov %o0, %i5
4001c258: 11 10 00 7a sethi %hi(0x4001e800), %o0
4001c25c: 7f ff b1 c6 call 40008974 <_API_extensions_Add_post_switch>
4001c260: 90 12 20 7c or %o0, 0x7c, %o0 ! 4001e87c <_POSIX_signals_Post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
4001c264: 85 2e 60 02 sll %i1, 2, %g2
4001c268: 87 2e 60 04 sll %i1, 4, %g3
4001c26c: 86 20 c0 02 sub %g3, %g2, %g3
4001c270: 05 10 00 7e sethi %hi(0x4001f800), %g2
4001c274: 84 10 a1 f0 or %g2, 0x1f0, %g2 ! 4001f9f0 <_POSIX_signals_Vectors>
4001c278: 84 00 80 03 add %g2, %g3, %g2
4001c27c: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4001c280: 80 a0 a0 01 cmp %g2, 1
4001c284: 12 80 00 06 bne 4001c29c <pthread_kill+0x8c>
4001c288: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
_Thread_Enable_dispatch();
4001c28c: 7f ff b9 83 call 4000a898 <_Thread_Enable_dispatch>
4001c290: b0 10 20 00 clr %i0
4001c294: 81 c7 e0 08 ret
4001c298: 81 e8 00 00 restore
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001c29c: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
4001c2a0: b6 10 20 01 mov 1, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001c2a4: 90 10 00 1d mov %i5, %o0
4001c2a8: b9 2e c0 1c sll %i3, %i4, %i4
4001c2ac: 92 10 00 19 mov %i1, %o1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001c2b0: b8 10 80 1c or %g2, %i4, %i4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001c2b4: 94 10 20 00 clr %o2
4001c2b8: 7f ff ff 84 call 4001c0c8 <_POSIX_signals_Unblock_thread>
4001c2bc: f8 20 60 d4 st %i4, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001c2c0: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001c2c4: 82 10 61 90 or %g1, 0x190, %g1 ! 4001f990 <_Per_CPU_Information>
4001c2c8: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001c2cc: 80 a0 a0 00 cmp %g2, 0
4001c2d0: 02 bf ff ef be 4001c28c <pthread_kill+0x7c>
4001c2d4: 01 00 00 00 nop
4001c2d8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001c2dc: 80 a7 40 02 cmp %i5, %g2
4001c2e0: 22 bf ff eb be,a 4001c28c <pthread_kill+0x7c>
4001c2e4: f6 28 60 0c stb %i3, [ %g1 + 0xc ]
4001c2e8: 30 bf ff e9 b,a 4001c28c <pthread_kill+0x7c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
4001c2ec: 7f ff cd fe call 4000fae4 <__errno> <== NOT EXECUTED
4001c2f0: 01 00 00 00 nop <== NOT EXECUTED
4001c2f4: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3> <== NOT EXECUTED
4001c2f8: c2 22 00 00 st %g1, [ %o0 ]
}
4001c2fc: 81 c7 e0 08 ret
4001c300: 91 e8 3f ff restore %g0, -1, %o0
40009e08 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
40009e08: 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 );
40009e0c: 92 07 bf fc add %fp, -4, %o1
40009e10: 40 00 00 37 call 40009eec <_POSIX_Absolute_timeout_to_ticks>
40009e14: 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 );
40009e18: 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 )
40009e1c: 82 1a 20 03 xor %o0, 3, %g1
40009e20: 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 );
40009e24: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
40009e28: b8 60 3f ff subx %g0, -1, %i4
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
40009e2c: 90 10 00 18 mov %i0, %o0
40009e30: 7f ff ff b7 call 40009d0c <_POSIX_Mutex_Lock_support>
40009e34: 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) ) {
40009e38: 80 a7 20 00 cmp %i4, 0
40009e3c: 12 80 00 0c bne 40009e6c <pthread_mutex_timedlock+0x64>
40009e40: b0 10 00 08 mov %o0, %i0
40009e44: 80 a2 20 10 cmp %o0, 0x10
40009e48: 12 80 00 09 bne 40009e6c <pthread_mutex_timedlock+0x64>
40009e4c: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40009e50: 02 80 00 07 be 40009e6c <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
40009e54: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40009e58: ba 07 7f ff add %i5, -1, %i5
40009e5c: 80 a7 60 01 cmp %i5, 1
40009e60: 18 80 00 03 bgu 40009e6c <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
40009e64: b0 10 20 10 mov 0x10, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
40009e68: b0 10 20 74 mov 0x74, %i0
}
return lock_status;
}
40009e6c: 81 c7 e0 08 ret
40009e70: 81 e8 00 00 restore
40007698 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
40007698: 82 10 00 08 mov %o0, %g1
if ( !attr )
4000769c: 80 a0 60 00 cmp %g1, 0
400076a0: 02 80 00 0b be 400076cc <pthread_mutexattr_gettype+0x34>
400076a4: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
400076a8: c4 00 40 00 ld [ %g1 ], %g2
400076ac: 80 a0 a0 00 cmp %g2, 0
400076b0: 02 80 00 07 be 400076cc <pthread_mutexattr_gettype+0x34>
400076b4: 80 a2 60 00 cmp %o1, 0
return EINVAL;
if ( !type )
400076b8: 02 80 00 05 be 400076cc <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
400076bc: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
400076c0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
400076c4: 90 10 20 00 clr %o0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
400076c8: c2 22 40 00 st %g1, [ %o1 ]
return 0;
}
400076cc: 81 c3 e0 08 retl
400099c0 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
400099c0: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
400099c4: 80 a0 60 00 cmp %g1, 0
400099c8: 02 80 00 0a be 400099f0 <pthread_mutexattr_setpshared+0x30>
400099cc: 90 10 20 16 mov 0x16, %o0
400099d0: c4 00 40 00 ld [ %g1 ], %g2
400099d4: 80 a0 a0 00 cmp %g2, 0
400099d8: 02 80 00 06 be 400099f0 <pthread_mutexattr_setpshared+0x30>
400099dc: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
400099e0: 18 80 00 04 bgu 400099f0 <pthread_mutexattr_setpshared+0x30><== NEVER TAKEN
400099e4: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
400099e8: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
400099ec: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
400099f0: 81 c3 e0 08 retl
40007704 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
40007704: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
40007708: 80 a0 60 00 cmp %g1, 0
4000770c: 02 80 00 0a be 40007734 <pthread_mutexattr_settype+0x30>
40007710: 90 10 20 16 mov 0x16, %o0
40007714: c4 00 40 00 ld [ %g1 ], %g2
40007718: 80 a0 a0 00 cmp %g2, 0
4000771c: 02 80 00 06 be 40007734 <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
40007720: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
40007724: 18 80 00 04 bgu 40007734 <pthread_mutexattr_settype+0x30>
40007728: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
4000772c: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
40007730: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
40007734: 81 c3 e0 08 retl
400082b4 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
400082b4: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
400082b8: 80 a6 60 00 cmp %i1, 0
400082bc: 02 80 00 1c be 4000832c <pthread_once+0x78>
400082c0: ba 10 00 18 mov %i0, %i5
400082c4: 80 a6 20 00 cmp %i0, 0
400082c8: 22 80 00 17 be,a 40008324 <pthread_once+0x70>
400082cc: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !once_control->init_executed ) {
400082d0: c2 06 20 04 ld [ %i0 + 4 ], %g1
400082d4: 80 a0 60 00 cmp %g1, 0
400082d8: 12 80 00 13 bne 40008324 <pthread_once+0x70>
400082dc: b0 10 20 00 clr %i0
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
400082e0: 90 10 21 00 mov 0x100, %o0
400082e4: 92 10 21 00 mov 0x100, %o1
400082e8: 40 00 03 0d call 40008f1c <rtems_task_mode>
400082ec: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
400082f0: c2 07 60 04 ld [ %i5 + 4 ], %g1
400082f4: 80 a0 60 00 cmp %g1, 0
400082f8: 12 80 00 07 bne 40008314 <pthread_once+0x60> <== NEVER TAKEN
400082fc: d0 07 bf fc ld [ %fp + -4 ], %o0
once_control->is_initialized = true;
40008300: 82 10 20 01 mov 1, %g1
40008304: c2 27 40 00 st %g1, [ %i5 ]
once_control->init_executed = true;
(*init_routine)();
40008308: 9f c6 40 00 call %i1
4000830c: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
40008310: d0 07 bf fc ld [ %fp + -4 ], %o0
40008314: 92 10 21 00 mov 0x100, %o1
40008318: 94 07 bf fc add %fp, -4, %o2
4000831c: 40 00 03 00 call 40008f1c <rtems_task_mode>
40008320: b0 10 20 00 clr %i0
40008324: 81 c7 e0 08 ret
40008328: 81 e8 00 00 restore
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
4000832c: b0 10 20 16 mov 0x16, %i0
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
40008330: 81 c7 e0 08 ret
40008334: 81 e8 00 00 restore
400086d4 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
400086d4: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
400086d8: 80 a6 20 00 cmp %i0, 0
400086dc: 12 80 00 04 bne 400086ec <pthread_rwlock_init+0x18>
400086e0: 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;
400086e4: 81 c7 e0 08 ret
400086e8: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
400086ec: 32 80 00 06 bne,a 40008704 <pthread_rwlock_init+0x30>
400086f0: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
400086f4: 90 07 bf f8 add %fp, -8, %o0
400086f8: 40 00 01 b0 call 40008db8 <pthread_rwlockattr_init>
400086fc: 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 )
40008700: c2 06 40 00 ld [ %i1 ], %g1
40008704: 80 a0 60 00 cmp %g1, 0
40008708: 22 80 00 13 be,a 40008754 <pthread_rwlock_init+0x80> <== NEVER TAKEN
4000870c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
40008710: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008714: 80 a0 60 00 cmp %g1, 0
40008718: 32 80 00 0f bne,a 40008754 <pthread_rwlock_init+0x80> <== NEVER TAKEN
4000871c: 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;
40008720: 03 10 00 8f sethi %hi(0x40023c00), %g1
40008724: c4 00 62 80 ld [ %g1 + 0x280 ], %g2 ! 40023e80 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
40008728: c0 27 bf f4 clr [ %fp + -12 ]
++level;
4000872c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008730: c4 20 62 80 st %g2, [ %g1 + 0x280 ]
* 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 *)
40008734: 39 10 00 90 sethi %hi(0x40024000), %i4
40008738: 40 00 0a 7e call 4000b130 <_Objects_Allocate>
4000873c: 90 17 20 84 or %i4, 0x84, %o0 ! 40024084 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
40008740: ba 92 20 00 orcc %o0, 0, %i5
40008744: 12 80 00 06 bne 4000875c <pthread_rwlock_init+0x88>
40008748: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
4000874c: 40 00 0f 79 call 4000c530 <_Thread_Enable_dispatch>
40008750: b0 10 20 0b mov 0xb, %i0
40008754: 81 c7 e0 08 ret
40008758: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
4000875c: 40 00 08 dd call 4000aad0 <_CORE_RWLock_Initialize>
40008760: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008764: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008768: b8 17 20 84 or %i4, 0x84, %i4
4000876c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008770: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008774: 85 28 a0 02 sll %g2, 2, %g2
40008778: 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;
4000877c: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
40008780: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40008784: 40 00 0f 6b call 4000c530 <_Thread_Enable_dispatch>
40008788: b0 10 20 00 clr %i0
4000878c: 81 c7 e0 08 ret
40008790: 81 e8 00 00 restore
40008d88 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40008d88: 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 )
40008d8c: 80 a6 20 00 cmp %i0, 0
40008d90: 12 80 00 04 bne 40008da0 <pthread_rwlock_timedrdlock+0x18>
40008d94: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
40008d98: 81 c7 e0 08 ret
40008d9c: 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 );
40008da0: 40 00 19 24 call 4000f230 <_POSIX_Absolute_timeout_to_ticks>
40008da4: 90 10 00 19 mov %i1, %o0
40008da8: d2 06 00 00 ld [ %i0 ], %o1
40008dac: ba 10 00 08 mov %o0, %i5
40008db0: 94 07 bf f8 add %fp, -8, %o2
40008db4: 11 10 00 6c sethi %hi(0x4001b000), %o0
40008db8: 40 00 0b 1e call 4000ba30 <_Objects_Get>
40008dbc: 90 12 20 c4 or %o0, 0xc4, %o0 ! 4001b0c4 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40008dc0: c2 07 bf f8 ld [ %fp + -8 ], %g1
40008dc4: 80 a0 60 00 cmp %g1, 0
40008dc8: 32 80 00 21 bne,a 40008e4c <pthread_rwlock_timedrdlock+0xc4>
40008dcc: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
40008dd0: d2 06 00 00 ld [ %i0 ], %o1
40008dd4: 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 )
40008dd8: 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(
40008ddc: 90 02 20 10 add %o0, 0x10, %o0
40008de0: 80 a0 00 01 cmp %g0, %g1
40008de4: 98 10 20 00 clr %o4
40008de8: b8 60 3f ff subx %g0, -1, %i4
40008dec: 40 00 07 8c call 4000ac1c <_CORE_RWLock_Obtain_for_reading>
40008df0: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
40008df4: 40 00 0e 90 call 4000c834 <_Thread_Enable_dispatch>
40008df8: 01 00 00 00 nop
if ( !do_wait ) {
40008dfc: 80 a7 20 00 cmp %i4, 0
40008e00: 12 80 00 0e bne 40008e38 <pthread_rwlock_timedrdlock+0xb0>
40008e04: 03 10 00 6d sethi %hi(0x4001b400), %g1
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
40008e08: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 4001b420 <_Per_CPU_Information+0x10>
40008e0c: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40008e10: 80 a0 60 02 cmp %g1, 2
40008e14: 32 80 00 0a bne,a 40008e3c <pthread_rwlock_timedrdlock+0xb4>
40008e18: 03 10 00 6d sethi %hi(0x4001b400), %g1
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40008e1c: 80 a7 60 00 cmp %i5, 0
40008e20: 22 80 00 0b be,a 40008e4c <pthread_rwlock_timedrdlock+0xc4><== NEVER TAKEN
40008e24: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40008e28: ba 07 7f ff add %i5, -1, %i5
40008e2c: 80 a7 60 01 cmp %i5, 1
40008e30: 08 80 00 07 bleu 40008e4c <pthread_rwlock_timedrdlock+0xc4><== ALWAYS TAKEN
40008e34: 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
40008e38: 03 10 00 6d sethi %hi(0x4001b400), %g1
40008e3c: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 4001b420 <_Per_CPU_Information+0x10>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
40008e40: 40 00 00 38 call 40008f20 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40008e44: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
40008e48: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
40008e4c: 81 c7 e0 08 ret
40008e50: 81 e8 00 00 restore
40008e54 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40008e54: 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 )
40008e58: 80 a6 20 00 cmp %i0, 0
40008e5c: 12 80 00 04 bne 40008e6c <pthread_rwlock_timedwrlock+0x18>
40008e60: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
40008e64: 81 c7 e0 08 ret
40008e68: 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 );
40008e6c: 40 00 18 f1 call 4000f230 <_POSIX_Absolute_timeout_to_ticks>
40008e70: 90 10 00 19 mov %i1, %o0
40008e74: d2 06 00 00 ld [ %i0 ], %o1
40008e78: ba 10 00 08 mov %o0, %i5
40008e7c: 94 07 bf f8 add %fp, -8, %o2
40008e80: 11 10 00 6c sethi %hi(0x4001b000), %o0
40008e84: 40 00 0a eb call 4000ba30 <_Objects_Get>
40008e88: 90 12 20 c4 or %o0, 0xc4, %o0 ! 4001b0c4 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40008e8c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40008e90: 80 a0 60 00 cmp %g1, 0
40008e94: 32 80 00 21 bne,a 40008f18 <pthread_rwlock_timedwrlock+0xc4>
40008e98: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
40008e9c: d2 06 00 00 ld [ %i0 ], %o1
40008ea0: 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 )
40008ea4: 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(
40008ea8: 90 02 20 10 add %o0, 0x10, %o0
40008eac: 80 a0 00 01 cmp %g0, %g1
40008eb0: 98 10 20 00 clr %o4
40008eb4: b8 60 3f ff subx %g0, -1, %i4
40008eb8: 40 00 07 8c call 4000ace8 <_CORE_RWLock_Obtain_for_writing>
40008ebc: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
40008ec0: 40 00 0e 5d call 4000c834 <_Thread_Enable_dispatch>
40008ec4: 01 00 00 00 nop
if ( !do_wait &&
40008ec8: 80 a7 20 00 cmp %i4, 0
40008ecc: 12 80 00 0e bne 40008f04 <pthread_rwlock_timedwrlock+0xb0>
40008ed0: 03 10 00 6d sethi %hi(0x4001b400), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
40008ed4: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 4001b420 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
40008ed8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40008edc: 80 a0 60 02 cmp %g1, 2
40008ee0: 32 80 00 0a bne,a 40008f08 <pthread_rwlock_timedwrlock+0xb4>
40008ee4: 03 10 00 6d sethi %hi(0x4001b400), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40008ee8: 80 a7 60 00 cmp %i5, 0
40008eec: 22 80 00 0b be,a 40008f18 <pthread_rwlock_timedwrlock+0xc4><== NEVER TAKEN
40008ef0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40008ef4: ba 07 7f ff add %i5, -1, %i5
40008ef8: 80 a7 60 01 cmp %i5, 1
40008efc: 08 80 00 07 bleu 40008f18 <pthread_rwlock_timedwrlock+0xc4><== ALWAYS TAKEN
40008f00: 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
40008f04: 03 10 00 6d sethi %hi(0x4001b400), %g1
40008f08: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 4001b420 <_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(
40008f0c: 40 00 00 05 call 40008f20 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40008f10: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
40008f14: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
40008f18: 81 c7 e0 08 ret
40008f1c: 81 e8 00 00 restore
400096ac <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
400096ac: 82 10 00 08 mov %o0, %g1
if ( !attr )
400096b0: 80 a0 60 00 cmp %g1, 0
400096b4: 02 80 00 0a be 400096dc <pthread_rwlockattr_setpshared+0x30>
400096b8: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
400096bc: c4 00 40 00 ld [ %g1 ], %g2
400096c0: 80 a0 a0 00 cmp %g2, 0
400096c4: 02 80 00 06 be 400096dc <pthread_rwlockattr_setpshared+0x30>
400096c8: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
400096cc: 18 80 00 04 bgu 400096dc <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
400096d0: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
400096d4: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
400096d8: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
400096dc: 81 c3 e0 08 retl
4000a6d4 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
4000a6d4: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
4000a6d8: 80 a6 a0 00 cmp %i2, 0
4000a6dc: 02 80 00 40 be 4000a7dc <pthread_setschedparam+0x108>
4000a6e0: b6 10 20 16 mov 0x16, %i3
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
4000a6e4: 90 10 00 19 mov %i1, %o0
4000a6e8: 92 10 00 1a mov %i2, %o1
4000a6ec: 94 07 bf f4 add %fp, -12, %o2
4000a6f0: 40 00 16 e6 call 40010288 <_POSIX_Thread_Translate_sched_param>
4000a6f4: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
4000a6f8: b6 92 20 00 orcc %o0, 0, %i3
4000a6fc: 32 80 00 39 bne,a 4000a7e0 <pthread_setschedparam+0x10c>
4000a700: b0 10 00 1b mov %i3, %i0
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
4000a704: 90 10 00 18 mov %i0, %o0
4000a708: 40 00 0b f2 call 4000d6d0 <_Thread_Get>
4000a70c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000a710: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a714: 80 a0 60 00 cmp %g1, 0
4000a718: 12 80 00 30 bne 4000a7d8 <pthread_setschedparam+0x104>
4000a71c: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000a720: fa 02 21 50 ld [ %o0 + 0x150 ], %i5
if ( api->schedpolicy == SCHED_SPORADIC )
4000a724: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
4000a728: 80 a0 60 04 cmp %g1, 4
4000a72c: 32 80 00 05 bne,a 4000a740 <pthread_setschedparam+0x6c>
4000a730: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
4000a734: 40 00 0f c9 call 4000e658 <_Watchdog_Remove>
4000a738: 90 07 60 a8 add %i5, 0xa8, %o0
api->schedpolicy = policy;
4000a73c: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
api->schedparam = *param;
4000a740: 90 07 60 88 add %i5, 0x88, %o0
4000a744: 92 10 00 1a mov %i2, %o1
4000a748: 40 00 22 4b call 40013074 <memcpy>
4000a74c: 94 10 20 1c mov 0x1c, %o2
the_thread->budget_algorithm = budget_algorithm;
4000a750: c2 07 bf f4 ld [ %fp + -12 ], %g1
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
4000a754: 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;
4000a758: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
the_thread->budget_callout = budget_callout;
4000a75c: c2 07 bf f8 ld [ %fp + -8 ], %g1
switch ( api->schedpolicy ) {
4000a760: 06 80 00 1b bl 4000a7cc <pthread_setschedparam+0xf8> <== NEVER TAKEN
4000a764: c2 27 20 7c st %g1, [ %i4 + 0x7c ]
4000a768: 80 a6 60 02 cmp %i1, 2
4000a76c: 04 80 00 07 ble 4000a788 <pthread_setschedparam+0xb4>
4000a770: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000a774: 80 a6 60 04 cmp %i1, 4
4000a778: 12 80 00 15 bne 4000a7cc <pthread_setschedparam+0xf8> <== NEVER TAKEN
4000a77c: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
4000a780: 10 80 00 0d b 4000a7b4 <pthread_setschedparam+0xe0>
4000a784: 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;
4000a788: c2 00 62 30 ld [ %g1 + 0x230 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
4000a78c: 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;
4000a790: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
4000a794: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000a798: d2 08 60 cc ldub [ %g1 + 0xcc ], %o1 ! 4001b8cc <rtems_maximum_priority>
4000a79c: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
4000a7a0: 94 10 20 01 mov 1, %o2
4000a7a4: 92 22 40 01 sub %o1, %g1, %o1
4000a7a8: 40 00 0a a4 call 4000d238 <_Thread_Change_priority>
4000a7ac: d2 27 20 18 st %o1, [ %i4 + 0x18 ]
the_thread,
the_thread->real_priority,
true
);
break;
4000a7b0: 30 80 00 07 b,a 4000a7cc <pthread_setschedparam+0xf8>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
_Watchdog_Remove( &api->Sporadic_timer );
4000a7b4: 90 07 60 a8 add %i5, 0xa8, %o0
4000a7b8: 40 00 0f a8 call 4000e658 <_Watchdog_Remove>
4000a7bc: c2 27 60 a4 st %g1, [ %i5 + 0xa4 ]
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
4000a7c0: 90 10 20 00 clr %o0
4000a7c4: 7f ff ff 7e call 4000a5bc <_POSIX_Threads_Sporadic_budget_TSR>
4000a7c8: 92 10 00 1c mov %i4, %o1
break;
}
_Thread_Enable_dispatch();
4000a7cc: 40 00 0b b5 call 4000d6a0 <_Thread_Enable_dispatch>
4000a7d0: b0 10 00 1b mov %i3, %i0
4000a7d4: 30 80 00 03 b,a 4000a7e0 <pthread_setschedparam+0x10c>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
4000a7d8: b6 10 20 03 mov 3, %i3
}
4000a7dc: b0 10 00 1b mov %i3, %i0
4000a7e0: 81 c7 e0 08 ret
4000a7e4: 81 e8 00 00 restore
40007ff8 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
40007ff8: 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() )
40007ffc: 03 10 00 64 sethi %hi(0x40019000), %g1
40008000: 82 10 61 50 or %g1, 0x150, %g1 ! 40019150 <_Per_CPU_Information>
40008004: c4 00 60 08 ld [ %g1 + 8 ], %g2
40008008: 80 a0 a0 00 cmp %g2, 0
4000800c: 12 80 00 16 bne 40008064 <pthread_testcancel+0x6c> <== NEVER TAKEN
40008010: 05 10 00 63 sethi %hi(0x40018c00), %g2
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40008014: 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;
40008018: c6 00 a0 40 ld [ %g2 + 0x40 ], %g3
4000801c: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
++level;
40008020: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
40008024: c6 20 a0 40 st %g3, [ %g2 + 0x40 ]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
40008028: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
4000802c: 80 a0 a0 00 cmp %g2, 0
40008030: 12 80 00 05 bne 40008044 <pthread_testcancel+0x4c> <== NEVER TAKEN
40008034: ba 10 20 00 clr %i5
40008038: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
4000803c: 80 a0 00 01 cmp %g0, %g1
40008040: ba 40 20 00 addx %g0, 0, %i5
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
40008044: 40 00 0b 78 call 4000ae24 <_Thread_Enable_dispatch>
40008048: 01 00 00 00 nop
if ( cancel )
4000804c: 80 8f 60 ff btst 0xff, %i5
40008050: 02 80 00 05 be 40008064 <pthread_testcancel+0x6c>
40008054: 03 10 00 64 sethi %hi(0x40019000), %g1
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
40008058: f0 00 61 60 ld [ %g1 + 0x160 ], %i0 ! 40019160 <_Per_CPU_Information+0x10>
4000805c: 40 00 16 9b call 4000dac8 <_POSIX_Thread_Exit>
40008060: 93 e8 3f ff restore %g0, -1, %o1
40008064: 81 c7 e0 08 ret
40008068: 81 e8 00 00 restore
4000d23c <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
4000d23c: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
4000d240: 7f ff e1 1b call 400056ac <malloc>
4000d244: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
4000d248: ba 92 20 00 orcc %o0, 0, %i5
4000d24c: 02 80 00 16 be 4000d2a4 <ramdisk_allocate+0x68> <== NEVER TAKEN
4000d250: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
4000d254: 32 80 00 0e bne,a 4000d28c <ramdisk_allocate+0x50>
4000d258: c0 2f 60 0d clrb [ %i5 + 0xd ]
area_begin = calloc(media_block_count, media_block_size);
4000d25c: 90 10 00 1a mov %i2, %o0
4000d260: 7f ff df 9a call 400050c8 <calloc>
4000d264: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
4000d268: b0 92 20 00 orcc %o0, 0, %i0
4000d26c: 12 80 00 07 bne 4000d288 <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
4000d270: 82 10 20 01 mov 1, %g1
free(rd);
4000d274: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000d278: 7f ff df cc call 400051a8 <free> <== NOT EXECUTED
4000d27c: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
4000d280: 81 c7 e0 08 ret <== NOT EXECUTED
4000d284: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
4000d288: 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;
4000d28c: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
4000d290: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = media_block_count;
4000d294: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
4000d298: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
4000d29c: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
4000d2a0: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
4000d2a4: b0 10 00 1d mov %i5, %i0
4000d2a8: 81 c7 e0 08 ret
4000d2ac: 81 e8 00 00 restore
4000d2b0 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
4000d2b0: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
4000d2b4: 80 a6 20 00 cmp %i0, 0
4000d2b8: 02 80 00 0a be 4000d2e0 <ramdisk_free+0x30> <== NEVER TAKEN
4000d2bc: 01 00 00 00 nop
if (rd->malloced) {
4000d2c0: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
4000d2c4: 80 a0 60 00 cmp %g1, 0
4000d2c8: 02 80 00 04 be 4000d2d8 <ramdisk_free+0x28>
4000d2cc: 01 00 00 00 nop
free(rd->area);
4000d2d0: 7f ff df b6 call 400051a8 <free>
4000d2d4: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
4000d2d8: 7f ff df b4 call 400051a8 <free>
4000d2dc: 81 e8 00 00 restore
4000d2e0: 81 c7 e0 08 ret <== NOT EXECUTED
4000d2e4: 81 e8 00 00 restore <== NOT EXECUTED
4000dff8 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
4000dff8: 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();
4000dffc: 7f ff dc 35 call 400050d0 <rtems_disk_io_initialize>
4000e000: a8 10 00 18 mov %i0, %l4
if (rc != RTEMS_SUCCESSFUL)
4000e004: b0 92 20 00 orcc %o0, 0, %i0
4000e008: 12 80 00 46 bne 4000e120 <ramdisk_initialize+0x128> <== NEVER TAKEN
4000e00c: 3b 10 00 98 sethi %hi(0x40026000), %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));
4000e010: d0 07 63 dc ld [ %i5 + 0x3dc ], %o0 ! 400263dc <rtems_ramdisk_configuration_size>
4000e014: 92 10 20 10 mov 0x10, %o1
4000e018: 7f ff df e5 call 40005fac <calloc>
4000e01c: 33 10 00 98 sethi %hi(0x40026000), %i1
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000e020: a6 10 00 1d mov %i5, %l3
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000e024: 39 0b d9 19 sethi %hi(0x2f646400), %i4
4000e028: 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,
4000e02c: 2b 10 00 38 sethi %hi(0x4000e000), %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));
4000e030: b6 10 00 08 mov %o0, %i3
r->trace = false;
4000e034: 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;
4000e038: b2 16 63 e0 or %i1, 0x3e0, %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++)
4000e03c: b4 10 20 00 clr %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000e040: b8 17 21 76 or %i4, 0x176, %i4
4000e044: 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);
4000e048: 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,
4000e04c: aa 15 61 28 or %l5, 0x128, %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++)
4000e050: 10 80 00 2f b 4000e10c <ramdisk_initialize+0x114>
4000e054: 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;
4000e058: f4 2f bf f8 stb %i2, [ %fp + -8 ]
r->block_size = c->block_size;
4000e05c: e4 06 40 00 ld [ %i1 ], %l2
r->block_num = c->block_num;
4000e060: e2 06 60 04 ld [ %i1 + 4 ], %l1
if (c->location == NULL)
4000e064: 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;
4000e068: e4 26 c0 00 st %l2, [ %i3 ]
r->block_num = c->block_num;
if (c->location == NULL)
4000e06c: 80 a0 60 00 cmp %g1, 0
4000e070: 12 80 00 0f bne 4000e0ac <ramdisk_initialize+0xb4> <== NEVER TAKEN
4000e074: e2 26 e0 04 st %l1, [ %i3 + 4 ]
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
4000e078: 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;
4000e07c: e0 2e e0 0d stb %l0, [ %i3 + 0xd ]
r->area = malloc(r->block_size * r->block_num);
4000e080: 40 00 4e 1e call 400218f8 <.umul>
4000e084: 90 10 00 11 mov %l1, %o0
4000e088: 7f ff e1 92 call 400066d0 <malloc>
4000e08c: 01 00 00 00 nop
if (r->area == NULL) /* No enough memory for this disk */
4000e090: 80 a2 20 00 cmp %o0, 0
4000e094: 12 80 00 04 bne 4000e0a4 <ramdisk_initialize+0xac> <== ALWAYS TAKEN
4000e098: d0 26 e0 08 st %o0, [ %i3 + 8 ]
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
4000e09c: 10 80 00 19 b 4000e100 <ramdisk_initialize+0x108> <== NOT EXECUTED
4000e0a0: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->initialized = false;
continue;
}
else
{
r->initialized = true;
4000e0a4: 10 80 00 05 b 4000e0b8 <ramdisk_initialize+0xc0>
4000e0a8: e0 2e e0 0c stb %l0, [ %i3 + 0xc ]
}
}
else
{
r->malloced = false;
4000e0ac: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
4000e0b0: e0 2e e0 0c stb %l0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
4000e0b4: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
4000e0b8: f0 23 a0 5c st %i0, [ %sp + 0x5c ]
4000e0bc: 90 10 00 14 mov %l4, %o0
4000e0c0: 92 10 00 1a mov %i2, %o1
4000e0c4: 94 10 00 12 mov %l2, %o2
4000e0c8: 96 10 00 11 mov %l1, %o3
4000e0cc: 98 10 00 15 mov %l5, %o4
4000e0d0: 7f ff db 6a call 40004e78 <rtems_disk_create_phys>
4000e0d4: 9a 10 00 1b mov %i3, %o5
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
4000e0d8: 80 a2 20 00 cmp %o0, 0
4000e0dc: 22 80 00 0a be,a 4000e104 <ramdisk_initialize+0x10c> <== ALWAYS TAKEN
4000e0e0: b4 06 a0 01 inc %i2
{
if (r->malloced)
4000e0e4: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
4000e0e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000e0ec: 22 80 00 05 be,a 4000e100 <ramdisk_initialize+0x108> <== NOT EXECUTED
4000e0f0: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
{
free(r->area);
4000e0f4: 7f ff df e6 call 4000608c <free> <== NOT EXECUTED
4000e0f8: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
4000e0fc: 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++)
4000e100: b4 06 a0 01 inc %i2 <== NOT EXECUTED
4000e104: b2 06 60 0c add %i1, 0xc, %i1
4000e108: b6 06 e0 10 add %i3, 0x10, %i3
4000e10c: c2 04 e3 dc ld [ %l3 + 0x3dc ], %g1
4000e110: 80 a6 80 01 cmp %i2, %g1
4000e114: 2a bf ff d1 bcs,a 4000e058 <ramdisk_initialize+0x60>
4000e118: f8 3f bf f0 std %i4, [ %fp + -16 ]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
4000e11c: b0 10 20 00 clr %i0
}
4000e120: 81 c7 e0 08 ret
4000e124: 81 e8 00 00 restore
4000d110 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000d110: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000d114: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000d118: ba 10 00 1a mov %i2, %i5
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000d11c: 84 10 a2 07 or %g2, 0x207, %g2
4000d120: 80 a6 40 02 cmp %i1, %g2
4000d124: 02 80 00 37 be 4000d200 <ramdisk_ioctl+0xf0>
4000d128: f8 06 20 3c ld [ %i0 + 0x3c ], %i4
4000d12c: 05 30 06 10 sethi %hi(0xc0184000), %g2
4000d130: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <LEON_REG+0x40184201>
4000d134: 80 a6 40 02 cmp %i1, %g2
4000d138: 12 80 00 39 bne 4000d21c <ramdisk_ioctl+0x10c>
4000d13c: 01 00 00 00 nop
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
4000d140: c2 06 80 00 ld [ %i2 ], %g1
4000d144: 80 a0 60 00 cmp %g1, 0
4000d148: 02 80 00 07 be 4000d164 <ramdisk_ioctl+0x54>
4000d14c: b6 06 a0 18 add %i2, 0x18, %i3
4000d150: 80 a0 60 01 cmp %g1, 1
4000d154: 12 80 00 34 bne 4000d224 <ramdisk_ioctl+0x114> <== NEVER TAKEN
4000d158: 01 00 00 00 nop
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
4000d15c: 10 80 00 14 b 4000d1ac <ramdisk_ioctl+0x9c>
4000d160: 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;
4000d164: 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++)
4000d168: 10 80 00 0b b 4000d194 <ramdisk_ioctl+0x84>
4000d16c: 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);
4000d170: d2 07 00 00 ld [ %i4 ], %o1
4000d174: 40 00 29 96 call 400177cc <.umul>
4000d178: f0 06 e0 08 ld [ %i3 + 8 ], %i0
4000d17c: d4 06 e0 04 ld [ %i3 + 4 ], %o2
4000d180: 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++)
4000d184: 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);
4000d188: 90 10 00 18 mov %i0, %o0
4000d18c: 40 00 1e 1c call 400149fc <memcpy>
4000d190: 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++)
4000d194: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d198: 80 a6 80 01 cmp %i2, %g1
4000d19c: 2a bf ff f5 bcs,a 4000d170 <ramdisk_ioctl+0x60>
4000d1a0: 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);
4000d1a4: 10 80 00 11 b 4000d1e8 <ramdisk_ioctl+0xd8>
4000d1a8: 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++)
4000d1ac: 10 80 00 0a b 4000d1d4 <ramdisk_ioctl+0xc4>
4000d1b0: 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);
4000d1b4: d2 07 00 00 ld [ %i4 ], %o1
4000d1b8: 40 00 29 85 call 400177cc <.umul>
4000d1bc: b4 06 a0 01 inc %i2
4000d1c0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
4000d1c4: d4 06 e0 04 ld [ %i3 + 4 ], %o2
4000d1c8: 90 06 40 08 add %i1, %o0, %o0
4000d1cc: 40 00 1e 0c call 400149fc <memcpy>
4000d1d0: 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++)
4000d1d4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d1d8: 80 a6 80 01 cmp %i2, %g1
4000d1dc: 2a bf ff f6 bcs,a 4000d1b4 <ramdisk_ioctl+0xa4>
4000d1e0: d0 06 c0 00 ld [ %i3 ], %o0
4000d1e4: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000d1e8: 90 10 00 1d mov %i5, %o0
4000d1ec: 92 10 20 00 clr %o1
4000d1f0: 9f c0 40 00 call %g1
4000d1f4: 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);
4000d1f8: 81 c7 e0 08 ret
4000d1fc: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
4000d200: c2 0f 20 0f ldub [ %i4 + 0xf ], %g1
4000d204: 80 a0 60 00 cmp %g1, 0
4000d208: 02 80 00 07 be 4000d224 <ramdisk_ioctl+0x114>
4000d20c: 01 00 00 00 nop
ramdisk_free(rd);
4000d210: 40 00 00 28 call 4000d2b0 <ramdisk_free>
4000d214: 90 10 00 1c mov %i4, %o0
4000d218: 30 80 00 03 b,a 4000d224 <ramdisk_ioctl+0x114>
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
4000d21c: 40 00 0a 01 call 4000fa20 <rtems_blkdev_ioctl>
4000d220: 81 e8 00 00 restore
break;
}
errno = EINVAL;
4000d224: 40 00 1b bf call 40014120 <__errno>
4000d228: b0 10 3f ff mov -1, %i0
4000d22c: 82 10 20 16 mov 0x16, %g1
4000d230: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
4000d234: 81 c7 e0 08 ret
4000d238: 81 e8 00 00 restore
4000d2e8 <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
4000d2e8: 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);
4000d2ec: 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;
4000d2f0: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
4000d2f4: 13 10 00 68 sethi %hi(0x4001a000), %o1
4000d2f8: 94 07 bf fc add %fp, -4, %o2
4000d2fc: 92 12 62 a8 or %o1, 0x2a8, %o1
4000d300: 7f ff f2 47 call 40009c1c <rtems_io_register_driver>
4000d304: a0 10 20 0d mov 0xd, %l0
if (sc != RTEMS_SUCCESSFUL) {
4000d308: 80 a2 20 00 cmp %o0, 0
4000d30c: 32 80 00 20 bne,a 4000d38c <ramdisk_register+0xa4> <== NEVER TAKEN
4000d310: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
4000d314: 96 10 00 1a mov %i2, %o3
4000d318: 92 10 00 18 mov %i0, %o1
4000d31c: 7f ff ff c8 call 4000d23c <ramdisk_allocate>
4000d320: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
4000d324: b4 92 20 00 orcc %o0, 0, %i2
4000d328: 12 80 00 04 bne 4000d338 <ramdisk_register+0x50> <== ALWAYS TAKEN
4000d32c: fa 07 bf fc ld [ %fp + -4 ], %i5
rtems_io_unregister_driver(major);
4000d330: 10 80 00 11 b 4000d374 <ramdisk_register+0x8c> <== NOT EXECUTED
4000d334: 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(
4000d338: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000d33c: 90 10 00 1d mov %i5, %o0
4000d340: 92 10 20 00 clr %o1
4000d344: 94 10 00 18 mov %i0, %o2
4000d348: 96 10 00 19 mov %i1, %o3
4000d34c: 19 10 00 34 sethi %hi(0x4000d000), %o4
4000d350: 9a 10 00 1a mov %i2, %o5
4000d354: 7f ff dc a2 call 400045dc <rtems_disk_create_phys>
4000d358: 98 13 21 10 or %o4, 0x110, %o4
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
4000d35c: 80 a2 20 00 cmp %o0, 0
4000d360: 22 80 00 08 be,a 4000d380 <ramdisk_register+0x98> <== ALWAYS TAKEN
4000d364: fa 27 00 00 st %i5, [ %i4 ]
ramdisk_free(rd);
4000d368: 7f ff ff d2 call 4000d2b0 <ramdisk_free> <== NOT EXECUTED
4000d36c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
4000d370: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
4000d374: 7f ff f2 89 call 40009d98 <rtems_io_unregister_driver> <== NOT EXECUTED
4000d378: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
4000d37c: 30 80 00 04 b,a 4000d38c <ramdisk_register+0xa4> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
4000d380: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
4000d384: a0 10 20 00 clr %l0
}
4000d388: b0 10 00 10 mov %l0, %i0
4000d38c: 81 c7 e0 08 ret
4000d390: 81 e8 00 00 restore
4000d394: 40 00 e2 78 call 40045d74 <__end+0x29904> <== NOT EXECUTED
4000d398: 40 00 e2 18 call 40045bf8 <__end+0x29788> <== NOT EXECUTED
4000d39c: 40 00 e2 2c call 40045c4c <__end+0x297dc> <== NOT EXECUTED
4000d3a0: 40 00 e2 2c call 40045c50 <__end+0x297e0> <== NOT EXECUTED
4000d3a4: 40 00 e2 2c call 40045c54 <__end+0x297e4> <== NOT EXECUTED
4000d3a8: 40 00 e2 2c call 40045c58 <__end+0x297e8> <== NOT EXECUTED
4000d3ac: 40 00 e2 10 call 40045bec <__end+0x2977c> <== NOT EXECUTED
4000d3b0: 40 00 e2 38 call 40045c90 <__end+0x29820> <== NOT EXECUTED
4000d3b4: 40 00 e2 38 call 40045c94 <__end+0x29824> <== NOT EXECUTED
4000d3b8: 40 00 e2 38 call 40045c98 <__end+0x29828> <== NOT EXECUTED
4000d3bc: 40 00 e2 58 call 40045d1c <__end+0x298ac> <== NOT EXECUTED
4000d3c0: 40 00 e1 64 call 40045950 <__end+0x294e0> <== NOT EXECUTED
4000d3c4: 40 00 e1 64 call 40045954 <__end+0x294e4> <== NOT EXECUTED
4000d3c8: 40 00 e1 84 call 400459d8 <__end+0x29568> <== NOT EXECUTED
4000d3cc: 40 00 e1 84 call 400459dc <__end+0x2956c> <== NOT EXECUTED
4000d3d0: 40 00 e1 84 call 400459e0 <__end+0x29570> <== NOT EXECUTED
4000d3d4: 40 00 e1 84 call 400459e4 <__end+0x29574> <== NOT EXECUTED
4000d3d8: 40 00 e1 30 call 40045898 <__end+0x29428> <== NOT EXECUTED
4000d3dc: 40 00 e1 90 call 40045a1c <__end+0x295ac> <== NOT EXECUTED
4000d3e0: 40 00 e1 90 call 40045a20 <__end+0x295b0> <== NOT EXECUTED
4000d3e4: 40 00 e1 90 call 40045a24 <__end+0x295b4> <== NOT EXECUTED
4000d3e8: 40 00 f8 04 call 4004b3f8 <__end+0x2ef88> <== NOT EXECUTED
4000d3ec: 40 00 f8 04 call 4004b3fc <__end+0x2ef8c> <== NOT EXECUTED
4000d3f0: 40 00 f7 c4 call 4004b300 <__end+0x2ee90> <== NOT EXECUTED
4000d3f4: 40 00 f7 f4 call 4004b3c4 <__end+0x2ef54> <== NOT EXECUTED
4000d3f8: 40 00 f7 f4 call 4004b3c8 <__end+0x2ef58> <== NOT EXECUTED
4000d3fc: 40 00 f7 f4 call 4004b3cc <__end+0x2ef5c> <== NOT EXECUTED
4000d400: 40 00 f8 04 call 4004b410 <__end+0x2efa0> <== NOT EXECUTED
4000d404: 40 00 f7 bc call 4004b2f4 <__end+0x2ee84> <== NOT EXECUTED
4000d408: 40 00 f7 b4 call 4004b2d8 <__end+0x2ee68> <== NOT EXECUTED
4000d40c: 40 00 f7 ec call 4004b3bc <__end+0x2ef4c> <== NOT EXECUTED
4000d410: 40 00 f8 04 call 4004b420 <__end+0x2efb0> <== NOT EXECUTED
4001bae4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
4001bae4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001bae8: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001baec: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 4001e774 <rtems_libio_number_iops>
4001baf0: 80 a6 00 01 cmp %i0, %g1
4001baf4: 1a 80 00 16 bcc 4001bb4c <read+0x68>
4001baf8: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
4001bafc: b1 2e 20 06 sll %i0, 6, %i0
4001bb00: b0 26 00 01 sub %i0, %g1, %i0
4001bb04: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001bb08: d0 00 62 f4 ld [ %g1 + 0x2f4 ], %o0 ! 4001f2f4 <rtems_libio_iops>
4001bb0c: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001bb10: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001bb14: 80 88 61 00 btst 0x100, %g1
4001bb18: 02 80 00 0d be 4001bb4c <read+0x68>
4001bb1c: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001bb20: 12 80 00 06 bne 4001bb38 <read+0x54> <== ALWAYS TAKEN
4001bb24: 80 a6 a0 00 cmp %i2, 0
4001bb28: 7f ff cf ef call 4000fae4 <__errno> <== NOT EXECUTED
4001bb2c: 01 00 00 00 nop <== NOT EXECUTED
4001bb30: 10 80 00 0a b 4001bb58 <read+0x74> <== NOT EXECUTED
4001bb34: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
4001bb38: 02 80 00 10 be 4001bb78 <read+0x94>
4001bb3c: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001bb40: 80 88 60 02 btst 2, %g1
4001bb44: 32 80 00 08 bne,a 4001bb64 <read+0x80>
4001bb48: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001bb4c: 7f ff cf e6 call 4000fae4 <__errno>
4001bb50: 01 00 00 00 nop
4001bb54: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4001bb58: c2 22 00 00 st %g1, [ %o0 ]
4001bb5c: 81 c7 e0 08 ret
4001bb60: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
4001bb64: 92 10 00 19 mov %i1, %o1
4001bb68: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001bb6c: 9f c0 40 00 call %g1
4001bb70: 94 10 00 1a mov %i2, %o2
4001bb74: b0 10 00 08 mov %o0, %i0
}
4001bb78: 81 c7 e0 08 ret
4001bb7c: 81 e8 00 00 restore
400053f4 <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)
{
400053f4: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
400053f8: 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))
400053fc: 80 a6 a0 00 cmp %i2, 0
40005400: 02 80 00 61 be 40005584 <read_extended_partition+0x190> <== NEVER TAKEN
40005404: ba 10 20 19 mov 0x19, %i5
40005408: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000540c: 80 a0 60 00 cmp %g1, 0
40005410: 02 80 00 5d be 40005584 <read_extended_partition+0x190> <== NEVER TAKEN
40005414: 90 10 00 18 mov %i0, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
40005418: f6 06 a0 04 ld [ %i2 + 4 ], %i3
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
4000541c: bb 2e e0 09 sll %i3, 9, %i5
new_off = lseek(fd, off, SEEK_SET);
40005420: 92 10 20 00 clr %o1
40005424: 94 10 00 1d mov %i5, %o2
40005428: 40 00 04 36 call 40006500 <lseek>
4000542c: 96 10 20 00 clr %o3
if (new_off != off) {
40005430: 80 a2 20 00 cmp %o0, 0
40005434: 32 80 00 0e bne,a 4000546c <read_extended_partition+0x78><== NEVER TAKEN
40005438: ba 10 20 1b mov 0x1b, %i5 <== NOT EXECUTED
4000543c: 80 a2 40 1d cmp %o1, %i5
40005440: 12 80 00 0b bne 4000546c <read_extended_partition+0x78> <== NEVER TAKEN
40005444: ba 10 20 1b mov 0x1b, %i5
40005448: 90 10 00 18 mov %i0, %o0
4000544c: 92 10 00 1b mov %i3, %o1
40005450: 7f ff ff a2 call 400052d8 <get_sector.part.0>
40005454: 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)
40005458: ba 92 20 00 orcc %o0, 0, %i5
4000545c: 02 80 00 09 be 40005480 <read_extended_partition+0x8c> <== ALWAYS TAKEN
40005460: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
if (sector)
40005464: 10 80 00 04 b 40005474 <read_extended_partition+0x80> <== NOT EXECUTED
40005468: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000546c: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
40005470: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005474: 22 80 00 45 be,a 40005588 <read_extended_partition+0x194><== NOT EXECUTED
40005478: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4000547c: 30 80 00 40 b,a 4000557c <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) &&
40005480: c6 0a 22 02 ldub [ %o0 + 0x202 ], %g3
40005484: 80 a0 e0 55 cmp %g3, 0x55
40005488: 12 80 00 06 bne 400054a0 <read_extended_partition+0xac> <== NEVER TAKEN
4000548c: 84 10 20 00 clr %g2
40005490: c4 0a 22 03 ldub [ %o0 + 0x203 ], %g2
40005494: 84 18 a0 aa xor %g2, 0xaa, %g2
40005498: 80 a0 00 02 cmp %g0, %g2
4000549c: 84 60 3f ff subx %g0, -1, %g2
if (sector)
free(sector);
return rc;
}
if (!msdos_signature_check(sector))
400054a0: 80 a0 a0 00 cmp %g2, 0
400054a4: 12 80 00 06 bne 400054bc <read_extended_partition+0xc8> <== ALWAYS TAKEN
400054a8: a0 02 21 d2 add %o0, 0x1d2, %l0
{
free(sector);
400054ac: 40 00 02 f8 call 4000608c <free> <== NOT EXECUTED
400054b0: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
}
free(sector);
return RTEMS_SUCCESSFUL;
}
400054b4: 81 c7 e0 08 ret <== NOT EXECUTED
400054b8: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
400054bc: 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)
400054c0: a2 06 a0 10 add %i2, 0x10, %l1
400054c4: 90 04 3f f0 add %l0, -16, %o0
400054c8: 7f ff ff 9a call 40005330 <data_to_part_desc.part.1>
400054cc: 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)
400054d0: ba 92 20 00 orcc %o0, 0, %i5
400054d4: 02 80 00 04 be 400054e4 <read_extended_partition+0xf0> <== ALWAYS TAKEN
400054d8: 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);
400054dc: 10 80 00 28 b 4000557c <read_extended_partition+0x188> <== NOT EXECUTED
400054e0: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
400054e4: 80 a2 a0 00 cmp %o2, 0
400054e8: 22 80 00 21 be,a 4000556c <read_extended_partition+0x178>
400054ec: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
400054f0: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
400054f4: 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));
400054f8: 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;
400054fc: 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))
40005500: 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;
40005504: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
if (is_extended(new_part_desc->sys_type))
40005508: 80 a0 a0 05 cmp %g2, 5
4000550c: 12 80 00 0a bne 40005534 <read_extended_partition+0x140>
40005510: c4 02 a0 04 ld [ %o2 + 4 ], %g2
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
40005514: 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;
40005518: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
4000551c: c4 22 a0 04 st %g2, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
40005520: 90 10 00 18 mov %i0, %o0
40005524: 7f ff ff b4 call 400053f4 <read_extended_partition>
40005528: 92 10 00 19 mov %i1, %o1
4000552c: 10 80 00 10 b 4000556c <read_extended_partition+0x178>
40005530: 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;
40005534: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
40005538: 88 00 e0 0a add %g3, 0xa, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
4000553c: 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;
40005540: 89 29 20 02 sll %g4, 2, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
40005544: 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;
40005548: d4 20 40 04 st %o2, [ %g1 + %g4 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
4000554c: 82 06 c0 02 add %i3, %g2, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005550: 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;
40005554: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005558: 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;
4000555c: 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;
40005560: 82 00 80 01 add %g2, %g1, %g1
40005564: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
40005568: 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++)
4000556c: 80 a7 00 11 cmp %i4, %l1
40005570: 12 bf ff d5 bne 400054c4 <read_extended_partition+0xd0>
40005574: 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);
40005578: d0 07 bf f8 ld [ %fp + -8 ], %o0
4000557c: 40 00 02 c4 call 4000608c <free>
40005580: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
40005584: b0 10 00 1d mov %i5, %i0
40005588: 81 c7 e0 08 ret
4000558c: 81 e8 00 00 restore
40005854 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40005854: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
40005858: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000585c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 ! 40017c14 <rtems_libio_number_iops>
40005860: 80 a6 00 01 cmp %i0, %g1
40005864: 2a 80 00 03 bcs,a 40005870 <readv+0x1c>
40005868: 83 2e 20 03 sll %i0, 3, %g1
4000586c: 30 80 00 0c b,a 4000589c <readv+0x48>
iop = rtems_libio_iop( fd );
40005870: b1 2e 20 06 sll %i0, 6, %i0
40005874: b0 26 00 01 sub %i0, %g1, %i0
40005878: 03 10 00 61 sethi %hi(0x40018400), %g1
4000587c: f8 00 63 70 ld [ %g1 + 0x370 ], %i4 ! 40018770 <rtems_libio_iops>
40005880: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
40005884: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40005888: 80 88 61 00 btst 0x100, %g1
4000588c: 02 80 00 04 be 4000589c <readv+0x48>
40005890: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40005894: 12 80 00 06 bne 400058ac <readv+0x58> <== ALWAYS TAKEN
40005898: 80 a6 60 00 cmp %i1, 0
4000589c: 40 00 2a e1 call 40010420 <__errno>
400058a0: 01 00 00 00 nop
400058a4: 10 80 00 1a b 4000590c <readv+0xb8>
400058a8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
400058ac: 02 80 00 15 be 40005900 <readv+0xac>
400058b0: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
400058b4: 04 80 00 13 ble 40005900 <readv+0xac>
400058b8: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
400058bc: 24 80 00 03 ble,a 400058c8 <readv+0x74> <== ALWAYS TAKEN
400058c0: b5 2e a0 03 sll %i2, 3, %i2
400058c4: 30 80 00 0f b,a 40005900 <readv+0xac> <== NOT EXECUTED
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
400058c8: 82 10 20 00 clr %g1
400058cc: 84 10 20 01 mov 1, %g2
400058d0: 10 80 00 03 b 400058dc <readv+0x88>
400058d4: 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;
400058d8: 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 )
400058dc: c8 06 40 01 ld [ %i1 + %g1 ], %g4
400058e0: 80 a1 20 00 cmp %g4, 0
400058e4: 02 80 00 07 be 40005900 <readv+0xac>
400058e8: 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;
400058ec: c8 01 20 04 ld [ %g4 + 4 ], %g4
400058f0: ba 01 00 03 add %g4, %g3, %i5
if ( total < old )
400058f4: 80 a7 40 03 cmp %i5, %g3
400058f8: 16 80 00 07 bge 40005914 <readv+0xc0>
400058fc: 80 a0 00 04 cmp %g0, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
40005900: 40 00 2a c8 call 40010420 <__errno>
40005904: 01 00 00 00 nop
40005908: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4000590c: 10 80 00 20 b 4000598c <readv+0x138>
40005910: c2 22 00 00 st %g1, [ %o0 ]
40005914: 82 00 60 08 add %g1, 8, %g1
if ( iov[v].iov_len )
all_zeros = false;
40005918: 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++ ) {
4000591c: 80 a0 40 1a cmp %g1, %i2
40005920: 12 bf ff ee bne 400058d8 <readv+0x84>
40005924: 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 ) {
40005928: 80 88 a0 ff btst 0xff, %g2
4000592c: 12 80 00 16 bne 40005984 <readv+0x130>
40005930: b0 10 20 00 clr %i0
40005934: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
40005938: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
4000593c: 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)(
40005940: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005944: d2 06 40 1d ld [ %i1 + %i5 ], %o1
40005948: d4 06 e0 04 ld [ %i3 + 4 ], %o2
4000594c: 9f c0 40 00 call %g1
40005950: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
40005954: 80 a2 20 00 cmp %o0, 0
40005958: 26 80 00 0b bl,a 40005984 <readv+0x130> <== NEVER TAKEN
4000595c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
40005960: 32 80 00 02 bne,a 40005968 <readv+0x114> <== ALWAYS TAKEN
40005964: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40005968: c2 06 e0 04 ld [ %i3 + 4 ], %g1
4000596c: 80 a2 00 01 cmp %o0, %g1
40005970: 12 80 00 05 bne 40005984 <readv+0x130> <== NEVER TAKEN
40005974: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40005978: 80 a7 40 1a cmp %i5, %i2
4000597c: 32 bf ff f0 bne,a 4000593c <readv+0xe8>
40005980: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
40005984: 81 c7 e0 08 ret
40005988: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
4000598c: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
40005990: 81 c7 e0 08 ret
40005994: 81 e8 00 00 restore
4001bbdc <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
4001bbdc: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
4001bbe0: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001bbe4: 82 10 63 00 or %g1, 0x300, %g1 ! 4001f300 <rtems_malloc_statistics>
4001bbe8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001bbec: 84 00 a0 01 inc %g2
4001bbf0: 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())) {
4001bbf4: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001bbf8: c2 00 61 88 ld [ %g1 + 0x188 ], %g1 ! 4001f988 <_System_state_Current>
4001bbfc: 80 a0 60 03 cmp %g1, 3
4001bc00: 12 80 00 09 bne 4001bc24 <realloc+0x48>
4001bc04: 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 )
4001bc08: 03 10 00 7d sethi %hi(0x4001f400), %g1
4001bc0c: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 ! 4001f480 <_Thread_Dispatch_disable_level>
4001bc10: 80 a0 60 00 cmp %g1, 0
4001bc14: 02 80 00 38 be 4001bcf4 <realloc+0x118> <== ALWAYS TAKEN
4001bc18: 03 10 00 7e sethi %hi(0x4001f800), %g1
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
4001bc1c: 81 c7 e0 08 ret <== NOT EXECUTED
4001bc20: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
/*
* Continue with realloc().
*/
if ( !ptr )
4001bc24: 12 80 00 04 bne 4001bc34 <realloc+0x58>
4001bc28: 80 a6 60 00 cmp %i1, 0
return malloc( size );
4001bc2c: 7f ff a1 d2 call 40004374 <malloc>
4001bc30: 91 e8 00 19 restore %g0, %i1, %o0
if ( !size ) {
4001bc34: 12 80 00 06 bne 4001bc4c <realloc+0x70> <== ALWAYS TAKEN
4001bc38: 3b 10 00 79 sethi %hi(0x4001e400), %i5
free( ptr );
4001bc3c: 7f ff a0 fa call 40004024 <free> <== NOT EXECUTED
4001bc40: 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;
4001bc44: 81 c7 e0 08 ret <== NOT EXECUTED
4001bc48: 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) ) {
4001bc4c: d0 07 63 30 ld [ %i5 + 0x330 ], %o0
4001bc50: 92 10 00 18 mov %i0, %o1
4001bc54: 40 00 01 b0 call 4001c314 <_Protected_heap_Get_block_size>
4001bc58: 94 07 bf fc add %fp, -4, %o2
4001bc5c: 80 8a 20 ff btst 0xff, %o0
4001bc60: 12 80 00 08 bne 4001bc80 <realloc+0xa4>
4001bc64: d0 07 63 30 ld [ %i5 + 0x330 ], %o0
errno = EINVAL;
4001bc68: 7f ff cf 9f call 4000fae4 <__errno>
4001bc6c: 01 00 00 00 nop
4001bc70: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4001bc74: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
4001bc78: 81 c7 e0 08 ret
4001bc7c: 91 e8 20 00 restore %g0, 0, %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
4001bc80: 92 10 00 18 mov %i0, %o1
4001bc84: 40 00 01 b2 call 4001c34c <_Protected_heap_Resize_block>
4001bc88: 94 10 00 19 mov %i1, %o2
4001bc8c: 80 8a 20 ff btst 0xff, %o0
4001bc90: 12 80 00 1e bne 4001bd08 <realloc+0x12c>
4001bc94: 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 );
4001bc98: 7f ff a1 b7 call 40004374 <malloc>
4001bc9c: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001bca0: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001bca4: 82 10 63 00 or %g1, 0x300, %g1 ! 4001f300 <rtems_malloc_statistics>
4001bca8: 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 );
4001bcac: ba 10 00 08 mov %o0, %i5
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001bcb0: 84 00 bf ff add %g2, -1, %g2
if ( !new_area ) {
4001bcb4: 80 a2 20 00 cmp %o0, 0
4001bcb8: 02 bf ff f0 be 4001bc78 <realloc+0x9c>
4001bcbc: c4 20 60 04 st %g2, [ %g1 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
4001bcc0: c2 07 bf fc ld [ %fp + -4 ], %g1
4001bcc4: 80 a6 40 01 cmp %i1, %g1
4001bcc8: 08 80 00 03 bleu 4001bcd4 <realloc+0xf8> <== NEVER TAKEN
4001bccc: 94 10 00 19 mov %i1, %o2
4001bcd0: 94 10 00 01 mov %g1, %o2
4001bcd4: 92 10 00 18 mov %i0, %o1
4001bcd8: 7f ff d1 d4 call 40010428 <memcpy>
4001bcdc: 90 10 00 1d mov %i5, %o0
free( ptr );
4001bce0: 90 10 00 18 mov %i0, %o0
4001bce4: 7f ff a0 d0 call 40004024 <free>
4001bce8: b0 10 00 1d mov %i5, %i0
4001bcec: 81 c7 e0 08 ret
4001bcf0: 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)
4001bcf4: c2 00 61 98 ld [ %g1 + 0x198 ], %g1
4001bcf8: 80 a0 60 00 cmp %g1, 0
4001bcfc: 02 bf ff ca be 4001bc24 <realloc+0x48> <== ALWAYS TAKEN
4001bd00: 80 a6 20 00 cmp %i0, 0
4001bd04: 30 bf ff dd b,a 4001bc78 <realloc+0x9c> <== NOT EXECUTED
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
4001bd08: 81 c7 e0 08 ret
4001bd0c: 81 e8 00 00 restore
400084fc <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
400084fc: 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);
40008500: 37 10 00 65 sethi %hi(0x40019400), %i3
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
40008504: 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);
40008508: 40 00 02 85 call 40008f1c <pthread_mutex_lock>
4000850c: 90 16 e0 cc or %i3, 0xcc, %o0
if (result != 0) {
40008510: b0 92 20 00 orcc %o0, 0, %i0
40008514: 02 80 00 06 be 4000852c <rtems_aio_enqueue+0x30> <== ALWAYS TAKEN
40008518: 01 00 00 00 nop
free (req);
4000851c: 7f ff ef 87 call 40004338 <free> <== NOT EXECUTED
40008520: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40008524: 81 c7 e0 08 ret <== NOT EXECUTED
40008528: 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);
4000852c: 40 00 04 90 call 4000976c <pthread_self>
40008530: b6 16 e0 cc or %i3, 0xcc, %i3
40008534: 92 07 bf e0 add %fp, -32, %o1
40008538: 40 00 03 9d call 400093ac <pthread_getschedparam>
4000853c: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
40008540: 40 00 04 8b call 4000976c <pthread_self>
40008544: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40008548: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000854c: c6 07 bf e4 ld [ %fp + -28 ], %g3
40008550: 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 ();
40008554: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40008558: 84 20 c0 02 sub %g3, %g2, %g2
4000855c: c4 27 60 0c st %g2, [ %i5 + 0xc ]
req->policy = policy;
40008560: c4 07 bf e0 ld [ %fp + -32 ], %g2
40008564: c4 27 60 08 st %g2, [ %i5 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
40008568: 84 10 20 77 mov 0x77, %g2
4000856c: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
40008570: 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;
40008574: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
40008578: 80 a0 a0 00 cmp %g2, 0
4000857c: 12 80 00 2e bne 40008634 <rtems_aio_enqueue+0x138> <== NEVER TAKEN
40008580: d2 00 40 00 ld [ %g1 ], %o1
40008584: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
40008588: 80 a0 60 04 cmp %g1, 4
4000858c: 14 80 00 2b bg 40008638 <rtems_aio_enqueue+0x13c>
40008590: 11 10 00 65 sethi %hi(0x40019400), %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);
40008594: 90 06 e0 48 add %i3, 0x48, %o0
40008598: 7f ff ff 7d call 4000838c <rtems_aio_search_fd>
4000859c: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
400085a0: 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);
400085a4: b8 10 00 08 mov %o0, %i4
if (r_chain->new_fd == 1) {
400085a8: 80 a0 60 01 cmp %g1, 1
400085ac: 12 80 00 1d bne 40008620 <rtems_aio_enqueue+0x124>
400085b0: 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);
400085b4: 92 10 00 1d mov %i5, %o1
400085b8: 40 00 09 03 call 4000a9c4 <_Chain_Insert>
400085bc: 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);
400085c0: 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;
400085c4: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
400085c8: 40 00 01 fd call 40008dbc <pthread_mutex_init>
400085cc: 90 07 20 1c add %i4, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
400085d0: 92 10 20 00 clr %o1
400085d4: 40 00 00 ff call 400089d0 <pthread_cond_init>
400085d8: 90 07 20 20 add %i4, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
400085dc: 90 07 bf dc add %fp, -36, %o0
400085e0: 92 06 e0 08 add %i3, 8, %o1
400085e4: 15 10 00 1f sethi %hi(0x40007c00), %o2
400085e8: 96 10 00 1c mov %i4, %o3
400085ec: 40 00 02 df call 40009168 <pthread_create>
400085f0: 94 12 a3 d4 or %o2, 0x3d4, %o2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
400085f4: ba 92 20 00 orcc %o0, 0, %i5
400085f8: 22 80 00 07 be,a 40008614 <rtems_aio_enqueue+0x118> <== ALWAYS TAKEN
400085fc: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
40008600: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40008604: 40 00 02 67 call 40008fa0 <pthread_mutex_unlock> <== NOT EXECUTED
40008608: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4000860c: 81 c7 e0 08 ret <== NOT EXECUTED
40008610: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
++aio_request_queue.active_threads;
40008614: 82 00 60 01 inc %g1
40008618: 10 80 00 3a b 40008700 <rtems_aio_enqueue+0x204>
4000861c: c2 26 e0 64 st %g1, [ %i3 + 0x64 ]
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
40008620: b6 02 20 1c add %o0, 0x1c, %i3
40008624: 40 00 02 3e call 40008f1c <pthread_mutex_lock>
40008628: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
4000862c: 10 80 00 0c b 4000865c <rtems_aio_enqueue+0x160>
40008630: 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,
40008634: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
40008638: 94 10 20 00 clr %o2
4000863c: 7f ff ff 54 call 4000838c <rtems_aio_search_fd>
40008640: 90 12 21 14 or %o0, 0x114, %o0
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
40008644: b8 92 20 00 orcc %o0, 0, %i4
40008648: 02 80 00 0d be 4000867c <rtems_aio_enqueue+0x180>
4000864c: b6 07 20 1c add %i4, 0x1c, %i3
{
pthread_mutex_lock (&r_chain->mutex);
40008650: 40 00 02 33 call 40008f1c <pthread_mutex_lock>
40008654: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
40008658: 90 07 20 08 add %i4, 8, %o0
4000865c: 7f ff fe fc call 4000824c <rtems_aio_insert_prio>
40008660: 92 10 00 1d mov %i5, %o1
pthread_cond_signal (&r_chain->cond);
40008664: 40 00 01 0a call 40008a8c <pthread_cond_signal>
40008668: 90 07 20 20 add %i4, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
4000866c: 40 00 02 4d call 40008fa0 <pthread_mutex_unlock>
40008670: 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);
40008674: 10 80 00 24 b 40008704 <rtems_aio_enqueue+0x208>
40008678: 11 10 00 65 sethi %hi(0x40019400), %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);
4000867c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40008680: 11 10 00 65 sethi %hi(0x40019400), %o0
40008684: d2 00 40 00 ld [ %g1 ], %o1
40008688: 90 12 21 20 or %o0, 0x120, %o0
4000868c: 7f ff ff 40 call 4000838c <rtems_aio_search_fd>
40008690: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
40008694: 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);
40008698: b8 10 00 08 mov %o0, %i4
4000869c: 92 10 00 1d mov %i5, %o1
if (r_chain->new_fd == 1) {
400086a0: 80 a0 60 01 cmp %g1, 1
400086a4: 12 80 00 0d bne 400086d8 <rtems_aio_enqueue+0x1dc>
400086a8: 90 02 20 08 add %o0, 8, %o0
400086ac: 40 00 08 c6 call 4000a9c4 <_Chain_Insert>
400086b0: 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);
400086b4: 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;
400086b8: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
400086bc: 40 00 01 c0 call 40008dbc <pthread_mutex_init>
400086c0: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
400086c4: 90 07 20 20 add %i4, 0x20, %o0
400086c8: 40 00 00 c2 call 400089d0 <pthread_cond_init>
400086cc: 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)
400086d0: 10 80 00 05 b 400086e4 <rtems_aio_enqueue+0x1e8>
400086d4: 11 10 00 65 sethi %hi(0x40019400), %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);
400086d8: 7f ff fe dd call 4000824c <rtems_aio_insert_prio>
400086dc: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
400086e0: 11 10 00 65 sethi %hi(0x40019400), %o0
400086e4: 90 12 20 cc or %o0, 0xcc, %o0 ! 400194cc <aio_request_queue>
400086e8: c2 02 20 68 ld [ %o0 + 0x68 ], %g1
400086ec: 80 a0 60 00 cmp %g1, 0
400086f0: 24 80 00 05 ble,a 40008704 <rtems_aio_enqueue+0x208> <== ALWAYS TAKEN
400086f4: 11 10 00 65 sethi %hi(0x40019400), %o0
pthread_cond_signal (&aio_request_queue.new_req);
400086f8: 40 00 00 e5 call 40008a8c <pthread_cond_signal> <== NOT EXECUTED
400086fc: 90 02 20 04 add %o0, 4, %o0 ! 40019404 <bsp_interrupt_handler_table+0x180><== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
40008700: 11 10 00 65 sethi %hi(0x40019400), %o0
40008704: 40 00 02 27 call 40008fa0 <pthread_mutex_unlock>
40008708: 90 12 20 cc or %o0, 0xcc, %o0 ! 400194cc <aio_request_queue>
return 0;
}
4000870c: 81 c7 e0 08 ret
40008710: 81 e8 00 00 restore
40007fd4 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
40007fd4: 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);
40007fd8: 3b 10 00 65 sethi %hi(0x40019400), %i5
40007fdc: ba 17 60 cc or %i5, 0xcc, %i5 ! 400194cc <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)) {
40007fe0: 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 &&
40007fe4: 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,
40007fe8: 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);
40007fec: b6 06 20 1c add %i0, 0x1c, %i3
40007ff0: 40 00 03 cb call 40008f1c <pthread_mutex_lock>
40007ff4: 90 10 00 1b mov %i3, %o0
if (result != 0)
40007ff8: 80 a2 20 00 cmp %o0, 0
40007ffc: 12 80 00 91 bne 40008240 <rtems_aio_handle+0x26c> <== NEVER TAKEN
40008000: 82 06 20 0c add %i0, 0xc, %g1
40008004: 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)) {
40008008: 80 a7 00 01 cmp %i4, %g1
4000800c: 02 80 00 3b be 400080f8 <rtems_aio_handle+0x124>
40008010: 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);
40008014: 40 00 05 d6 call 4000976c <pthread_self>
40008018: 01 00 00 00 nop
4000801c: 92 07 bf d8 add %fp, -40, %o1
40008020: 40 00 04 e3 call 400093ac <pthread_getschedparam>
40008024: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
40008028: c2 07 20 0c ld [ %i4 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
4000802c: 40 00 05 d0 call 4000976c <pthread_self>
40008030: c2 27 bf e4 st %g1, [ %fp + -28 ]
40008034: d2 07 20 08 ld [ %i4 + 8 ], %o1
40008038: 40 00 05 d1 call 4000977c <pthread_setschedparam>
4000803c: 94 07 bf e4 add %fp, -28, %o2
40008040: 40 00 0a 48 call 4000a960 <_Chain_Extract>
40008044: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
40008048: 40 00 03 d6 call 40008fa0 <pthread_mutex_unlock>
4000804c: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
40008050: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40008054: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
40008058: 80 a0 a0 02 cmp %g2, 2
4000805c: 22 80 00 10 be,a 4000809c <rtems_aio_handle+0xc8>
40008060: c4 18 60 08 ldd [ %g1 + 8 ], %g2
40008064: 80 a0 a0 03 cmp %g2, 3
40008068: 02 80 00 15 be 400080bc <rtems_aio_handle+0xe8> <== NEVER TAKEN
4000806c: 80 a0 a0 01 cmp %g2, 1
40008070: 32 80 00 19 bne,a 400080d4 <rtems_aio_handle+0x100> <== NEVER TAKEN
40008074: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
40008078: c4 18 60 08 ldd [ %g1 + 8 ], %g2
4000807c: d0 00 40 00 ld [ %g1 ], %o0
40008080: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
40008084: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
40008088: 96 10 00 02 mov %g2, %o3
4000808c: 40 00 29 7f call 40012688 <pread>
40008090: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
40008094: 10 80 00 0d b 400080c8 <rtems_aio_handle+0xf4>
40008098: 80 a2 3f ff cmp %o0, -1
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
4000809c: d0 00 40 00 ld [ %g1 ], %o0
400080a0: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
400080a4: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
400080a8: 96 10 00 02 mov %g2, %o3
400080ac: 40 00 29 b5 call 40012780 <pwrite>
400080b0: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
400080b4: 10 80 00 05 b 400080c8 <rtems_aio_handle+0xf4>
400080b8: 80 a2 3f ff cmp %o0, -1
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
400080bc: 40 00 19 ef call 4000e878 <fsync> <== NOT EXECUTED
400080c0: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
400080c4: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
400080c8: 32 80 00 09 bne,a 400080ec <rtems_aio_handle+0x118> <== ALWAYS TAKEN
400080cc: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
req->aiocbp->return_value = -1;
400080d0: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
400080d4: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
400080d8: 40 00 26 80 call 40011ad8 <__errno> <== NOT EXECUTED
400080dc: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
400080e0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
400080e4: 10 bf ff c2 b 40007fec <rtems_aio_handle+0x18> <== NOT EXECUTED
400080e8: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
400080ec: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
400080f0: 10 bf ff bf b 40007fec <rtems_aio_handle+0x18>
400080f4: 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);
400080f8: 40 00 03 aa call 40008fa0 <pthread_mutex_unlock>
400080fc: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
40008100: 40 00 03 87 call 40008f1c <pthread_mutex_lock>
40008104: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_empty (chain))
40008108: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000810c: 80 a0 40 1c cmp %g1, %i4
40008110: 12 80 00 48 bne 40008230 <rtems_aio_handle+0x25c> <== NEVER TAKEN
40008114: 92 07 bf dc add %fp, -36, %o1
{
clock_gettime (CLOCK_REALTIME, &timeout);
40008118: 40 00 01 c9 call 4000883c <clock_gettime>
4000811c: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
40008120: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
40008124: 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;
40008128: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
4000812c: 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;
40008130: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
40008134: 90 10 00 1c mov %i4, %o0
40008138: 92 10 00 1d mov %i5, %o1
4000813c: 40 00 02 71 call 40008b00 <pthread_cond_timedwait>
40008140: 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) {
40008144: 80 a2 20 74 cmp %o0, 0x74
40008148: 12 80 00 3a bne 40008230 <rtems_aio_handle+0x25c> <== NEVER TAKEN
4000814c: 01 00 00 00 nop
40008150: 40 00 0a 04 call 4000a960 <_Chain_Extract>
40008154: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
40008158: 40 00 02 c4 call 40008c68 <pthread_mutex_destroy>
4000815c: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
40008160: 40 00 01 e5 call 400088f4 <pthread_cond_destroy>
40008164: 90 10 00 1c mov %i4, %o0
free (r_chain);
40008168: 7f ff f0 74 call 40004338 <free>
4000816c: 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)) {
40008170: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
40008174: 80 a0 40 1a cmp %g1, %i2
40008178: 12 80 00 1b bne 400081e4 <rtems_aio_handle+0x210>
4000817c: 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);
40008180: 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;
40008184: 82 00 60 01 inc %g1
40008188: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
--aio_request_queue.active_threads;
4000818c: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
clock_gettime (CLOCK_REALTIME, &timeout);
40008190: 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;
40008194: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
40008198: 40 00 01 a9 call 4000883c <clock_gettime>
4000819c: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
timeout.tv_sec += 3;
400081a0: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
400081a4: 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;
400081a8: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
400081ac: 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;
400081b0: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
400081b4: 92 10 00 1d mov %i5, %o1
400081b8: 40 00 02 52 call 40008b00 <pthread_cond_timedwait>
400081bc: 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) {
400081c0: 80 a2 20 74 cmp %o0, 0x74
400081c4: 12 80 00 08 bne 400081e4 <rtems_aio_handle+0x210> <== NEVER TAKEN
400081c8: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
400081cc: 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;
400081d0: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
400081d4: 40 00 03 73 call 40008fa0 <pthread_mutex_unlock>
400081d8: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
400081dc: 81 c7 e0 08 ret
400081e0: 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;
400081e4: 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;
400081e8: 82 00 7f ff add %g1, -1, %g1
400081ec: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
++aio_request_queue.active_threads;
400081f0: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
400081f4: 90 10 00 18 mov %i0, %o0
400081f8: 82 00 60 01 inc %g1
400081fc: 40 00 09 d9 call 4000a960 <_Chain_Extract>
40008200: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
40008204: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
40008208: 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 &&
4000820c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
40008210: 80 a0 c0 02 cmp %g3, %g2
40008214: 16 80 00 04 bge 40008224 <rtems_aio_handle+0x250>
40008218: 80 a0 40 19 cmp %g1, %i1
4000821c: 32 bf ff fc bne,a 4000820c <rtems_aio_handle+0x238> <== ALWAYS TAKEN
40008220: 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 );
40008224: d0 00 60 04 ld [ %g1 + 4 ], %o0
40008228: 40 00 09 e7 call 4000a9c4 <_Chain_Insert>
4000822c: 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);
40008230: 40 00 03 5c call 40008fa0 <pthread_mutex_unlock>
40008234: 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);
40008238: 10 bf ff 6e b 40007ff0 <rtems_aio_handle+0x1c>
4000823c: b6 06 20 1c add %i0, 0x1c, %i3
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
40008240: b0 10 20 00 clr %i0 <== NOT EXECUTED
40008244: 81 c7 e0 08 ret <== NOT EXECUTED
40008248: 81 e8 00 00 restore <== NOT EXECUTED
400082ac <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
400082ac: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
400082b0: 3b 10 00 65 sethi %hi(0x40019400), %i5
400082b4: 40 00 03 93 call 40009100 <pthread_attr_init>
400082b8: 90 17 60 d4 or %i5, 0xd4, %o0 ! 400194d4 <aio_request_queue+0x8>
if (result != 0)
400082bc: b0 92 20 00 orcc %o0, 0, %i0
400082c0: 12 80 00 31 bne 40008384 <rtems_aio_init+0xd8> <== NEVER TAKEN
400082c4: 90 17 60 d4 or %i5, 0xd4, %o0
return result;
result =
400082c8: 40 00 03 9a call 40009130 <pthread_attr_setdetachstate>
400082cc: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
400082d0: 80 a2 20 00 cmp %o0, 0
400082d4: 22 80 00 05 be,a 400082e8 <rtems_aio_init+0x3c> <== ALWAYS TAKEN
400082d8: 11 10 00 65 sethi %hi(0x40019400), %o0
pthread_attr_destroy (&aio_request_queue.attr);
400082dc: 40 00 03 7d call 400090d0 <pthread_attr_destroy> <== NOT EXECUTED
400082e0: 90 17 60 d4 or %i5, 0xd4, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
400082e4: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
400082e8: 92 10 20 00 clr %o1
400082ec: 40 00 02 b4 call 40008dbc <pthread_mutex_init>
400082f0: 90 12 20 cc or %o0, 0xcc, %o0
if (result != 0)
400082f4: 80 a2 20 00 cmp %o0, 0
400082f8: 22 80 00 06 be,a 40008310 <rtems_aio_init+0x64> <== ALWAYS TAKEN
400082fc: 11 10 00 65 sethi %hi(0x40019400), %o0
pthread_attr_destroy (&aio_request_queue.attr);
40008300: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
40008304: 40 00 03 73 call 400090d0 <pthread_attr_destroy> <== NOT EXECUTED
40008308: 90 12 20 d4 or %o0, 0xd4, %o0 ! 400194d4 <aio_request_queue+0x8><== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4000830c: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
40008310: 92 10 20 00 clr %o1
40008314: 40 00 01 af call 400089d0 <pthread_cond_init>
40008318: 90 12 20 d0 or %o0, 0xd0, %o0
if (result != 0) {
4000831c: b0 92 20 00 orcc %o0, 0, %i0
40008320: 02 80 00 09 be 40008344 <rtems_aio_init+0x98> <== ALWAYS TAKEN
40008324: 03 10 00 65 sethi %hi(0x40019400), %g1
pthread_mutex_destroy (&aio_request_queue.mutex);
40008328: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
4000832c: 40 00 02 4f call 40008c68 <pthread_mutex_destroy> <== NOT EXECUTED
40008330: 90 12 20 cc or %o0, 0xcc, %o0 ! 400194cc <aio_request_queue><== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
40008334: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
40008338: 40 00 03 66 call 400090d0 <pthread_attr_destroy> <== NOT EXECUTED
4000833c: 90 12 20 d4 or %o0, 0xd4, %o0 ! 400194d4 <aio_request_queue+0x8><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40008340: 03 10 00 65 sethi %hi(0x40019400), %g1 <== NOT EXECUTED
40008344: 82 10 60 cc or %g1, 0xcc, %g1 ! 400194cc <aio_request_queue>
40008348: 84 00 60 4c add %g1, 0x4c, %g2
4000834c: c4 20 60 48 st %g2, [ %g1 + 0x48 ]
head->previous = NULL;
tail->previous = head;
40008350: 84 00 60 48 add %g1, 0x48, %g2
40008354: 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;
40008358: 84 00 60 58 add %g1, 0x58, %g2
4000835c: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
head->previous = NULL;
tail->previous = head;
40008360: 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;
40008364: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
40008368: 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;
4000836c: 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;
40008370: 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;
40008374: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
40008378: 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;
4000837c: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
40008380: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
40008384: 81 c7 e0 08 ret
40008388: 81 e8 00 00 restore
4000824c <rtems_aio_insert_prio>:
4000824c: 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 );
40008250: 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)) {
40008254: 80 a0 40 03 cmp %g1, %g3
40008258: 02 80 00 0e be 40008290 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
4000825c: 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;
40008260: c8 00 60 14 ld [ %g1 + 0x14 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
40008264: 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;
40008268: c8 01 20 18 ld [ %g4 + 0x18 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
4000826c: 10 80 00 04 b 4000827c <rtems_aio_insert_prio+0x30>
40008270: 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;
40008274: c8 00 60 14 ld [ %g1 + 0x14 ], %g4 <== NOT EXECUTED
40008278: 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 &&
4000827c: 80 a3 40 04 cmp %o5, %g4
40008280: 14 80 00 07 bg 4000829c <rtems_aio_insert_prio+0x50> <== NEVER TAKEN
40008284: 80 a0 40 03 cmp %g1, %g3
40008288: d0 00 60 04 ld [ %g1 + 4 ], %o0
4000828c: 92 10 00 02 mov %g2, %o1
40008290: 82 13 c0 00 mov %o7, %g1
40008294: 40 00 09 cc call 4000a9c4 <_Chain_Insert>
40008298: 9e 10 40 00 mov %g1, %o7
4000829c: 32 bf ff f6 bne,a 40008274 <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
400082a0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
400082a4: 10 bf ff fa b 4000828c <rtems_aio_insert_prio+0x40> <== NOT EXECUTED
400082a8: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
4000847c <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)
{
4000847c: 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;
40008480: 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 );
40008484: 82 06 20 04 add %i0, 4, %g1
if (rtems_chain_is_empty (chain))
40008488: 80 a7 40 01 cmp %i5, %g1
4000848c: 12 80 00 09 bne 400084b0 <rtems_aio_remove_req+0x34>
40008490: b0 10 20 02 mov 2, %i0
40008494: 81 c7 e0 08 ret
40008498: 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) {
4000849c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
400084a0: 32 80 00 05 bne,a 400084b4 <rtems_aio_remove_req+0x38> <== NOT EXECUTED
400084a4: 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;
400084a8: 81 c7 e0 08 ret <== NOT EXECUTED
400084ac: 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) {
400084b0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
400084b4: 80 a0 80 19 cmp %g2, %i1
400084b8: 32 bf ff f9 bne,a 4000849c <rtems_aio_remove_req+0x20> <== NEVER TAKEN
400084bc: 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))
400084c0: 80 a7 40 01 cmp %i5, %g1
400084c4: 02 bf ff f4 be 40008494 <rtems_aio_remove_req+0x18> <== NEVER TAKEN
400084c8: b0 10 20 01 mov 1, %i0
400084cc: 40 00 09 25 call 4000a960 <_Chain_Extract>
400084d0: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
400084d4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400084d8: 84 10 20 8c mov 0x8c, %g2
400084dc: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
400084e0: 84 10 3f ff mov -1, %g2
free (current);
400084e4: 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;
400084e8: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
400084ec: 7f ff ef 93 call 40004338 <free>
400084f0: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
400084f4: 81 c7 e0 08 ret
400084f8: 81 e8 00 00 restore
4000db9c <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4000db9c: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
4000dba0: 3b 10 00 6d sethi %hi(0x4001b400), %i5
4000dba4: ba 17 60 2c or %i5, 0x2c, %i5 ! 4001b42c <bdbuf_cache>
4000dba8: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
4000dbac: 80 a0 60 00 cmp %g1, 0
4000dbb0: 22 80 00 12 be,a 4000dbf8 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== ALWAYS TAKEN
4000dbb4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000dbb8: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
4000dbbc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
4000dbc0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000dbc4: 32 80 00 0d bne,a 4000dbf8 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== NOT EXECUTED
4000dbc8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4000dbcc: 7f ff fe 4c call 4000d4fc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000dbd0: 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);
4000dbd4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000dbd8: 7f ff fe 28 call 4000d478 <rtems_bdbuf_lock> <== NOT EXECUTED
4000dbdc: 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,
4000dbe0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000dbe4: 7f ff fe 3c call 4000d4d4 <rtems_bdbuf_unlock> <== NOT EXECUTED
4000dbe8: 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 ();
4000dbec: 7f ff fe 2f call 4000d4a8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000dbf0: 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
4000dbf4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
4000dbf8: 80 a0 60 05 cmp %g1, 5
4000dbfc: 22 80 00 06 be,a 4000dc14 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
4000dc00: 03 10 00 66 sethi %hi(0x40019800), %g1
4000dc04: 80 a0 60 03 cmp %g1, 3
4000dc08: 12 80 00 06 bne 4000dc20 <rtems_bdbuf_add_to_modified_list_after_access+0x84>
4000dc0c: 82 10 20 07 mov 7, %g1
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
4000dc10: 03 10 00 66 sethi %hi(0x40019800), %g1
4000dc14: c2 00 62 78 ld [ %g1 + 0x278 ], %g1 ! 40019a78 <rtems_bdbuf_configuration+0x10>
4000dc18: 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;
4000dc1c: 82 10 20 07 mov 7, %g1
4000dc20: 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;
4000dc24: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000dc28: 82 10 60 2c or %g1, 0x2c, %g1 ! 4001b42c <bdbuf_cache>
4000dc2c: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
the_node->next = tail;
4000dc30: 86 00 60 50 add %g1, 0x50, %g3
tail->previous = the_node;
4000dc34: 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;
4000dc38: c6 26 00 00 st %g3, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
4000dc3c: f0 20 80 00 st %i0, [ %g2 ]
the_node->previous = old_last;
4000dc40: 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)
4000dc44: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
4000dc48: 80 a0 a0 00 cmp %g2, 0
4000dc4c: 22 80 00 04 be,a 4000dc5c <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
4000dc50: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000dc54: 7f ff fe be call 4000d74c <rtems_bdbuf_wake>
4000dc58: 91 e8 60 64 restore %g1, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
4000dc5c: 80 a0 60 00 cmp %g1, 0
4000dc60: 02 80 00 04 be 4000dc70 <rtems_bdbuf_add_to_modified_list_after_access+0xd4>
4000dc64: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
4000dc68: 7f ff fe 2b call 4000d514 <rtems_bdbuf_wake_swapper>
4000dc6c: 81 e8 00 00 restore
4000dc70: 81 c7 e0 08 ret
4000dc74: 81 e8 00 00 restore
4000d5b0 <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)
{
4000d5b0: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4000d5b4: c2 06 00 00 ld [ %i0 ], %g1
4000d5b8: 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 ();
4000d5bc: 7f ff ff e2 call 4000d544 <rtems_bdbuf_disable_preemption>
4000d5c0: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
4000d5c4: 7f ff ff ce call 4000d4fc <rtems_bdbuf_unlock_cache>
4000d5c8: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4000d5cc: d0 06 20 04 ld [ %i0 + 4 ], %o0
4000d5d0: 92 10 20 00 clr %o1
4000d5d4: 7f ff ef a0 call 40009454 <rtems_semaphore_obtain>
4000d5d8: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
4000d5dc: 80 a2 20 06 cmp %o0, 6
4000d5e0: 12 80 00 04 bne 4000d5f0 <rtems_bdbuf_anonymous_wait+0x40><== ALWAYS TAKEN
4000d5e4: 80 a2 20 0d cmp %o0, 0xd
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
4000d5e8: 10 80 00 04 b 4000d5f8 <rtems_bdbuf_anonymous_wait+0x48> <== NOT EXECUTED
4000d5ec: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
4000d5f0: 02 80 00 04 be 4000d600 <rtems_bdbuf_anonymous_wait+0x50> <== ALWAYS TAKEN
4000d5f4: 90 10 20 02 mov 2, %o0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
4000d5f8: 7f ff ff 9b call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d5fc: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4000d600: 7f ff ff aa call 4000d4a8 <rtems_bdbuf_lock_cache>
4000d604: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
4000d608: 7f ff ff dc call 4000d578 <rtems_bdbuf_restore_preemption>
4000d60c: 90 10 00 1d mov %i5, %o0
--waiters->count;
4000d610: c2 06 00 00 ld [ %i0 ], %g1
4000d614: 82 00 7f ff add %g1, -1, %g1
4000d618: c2 26 00 00 st %g1, [ %i0 ]
4000d61c: 81 c7 e0 08 ret
4000d620: 81 e8 00 00 restore
4000d784 <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
4000d784: 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 ?
4000d788: 03 10 00 66 sethi %hi(0x40019800), %g1
4000d78c: d4 00 62 84 ld [ %g1 + 0x284 ], %o2 ! 40019a84 <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
4000d790: 80 a2 a0 00 cmp %o2, 0
4000d794: 12 80 00 03 bne 4000d7a0 <rtems_bdbuf_create_task.constprop.10+0x1c><== ALWAYS TAKEN
4000d798: 92 10 00 19 mov %i1, %o1
4000d79c: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
4000d7a0: 80 a2 60 00 cmp %o1, 0
4000d7a4: 22 80 00 02 be,a 4000d7ac <rtems_bdbuf_create_task.constprop.10+0x28><== NEVER TAKEN
4000d7a8: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
4000d7ac: 90 10 00 18 mov %i0, %o0
4000d7b0: 96 10 24 00 mov 0x400, %o3
4000d7b4: 98 10 20 00 clr %o4
4000d7b8: 7f ff ef b2 call 40009680 <rtems_task_create>
4000d7bc: 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)
4000d7c0: b0 92 20 00 orcc %o0, 0, %i0
4000d7c4: 12 80 00 05 bne 4000d7d8 <rtems_bdbuf_create_task.constprop.10+0x54><== NEVER TAKEN
4000d7c8: b2 10 00 1a mov %i2, %i1
sc = rtems_task_start (*id, entry, arg);
4000d7cc: f0 07 00 00 ld [ %i4 ], %i0
4000d7d0: 7f ff f0 39 call 400098b4 <rtems_task_start>
4000d7d4: 95 e8 00 1b restore %g0, %i3, %o2
return sc;
}
4000d7d8: 81 c7 e0 08 ret <== NOT EXECUTED
4000d7dc: 81 e8 00 00 restore <== NOT EXECUTED
4000d544 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
4000d544: 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);
4000d548: 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;
4000d54c: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000d550: 92 10 21 00 mov 0x100, %o1
4000d554: 40 00 11 43 call 40011a60 <rtems_task_mode>
4000d558: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
4000d55c: 80 a2 20 00 cmp %o0, 0
4000d560: 22 80 00 04 be,a 4000d570 <rtems_bdbuf_disable_preemption+0x2c><== ALWAYS TAKEN
4000d564: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
4000d568: 7f ff ff bf call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d56c: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
return prev_mode;
}
4000d570: 81 c7 e0 08 ret
4000d574: 81 e8 00 00 restore
4000eac4 <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)
{
4000eac4: 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) +
4000eac8: 83 2e a0 04 sll %i2, 4, %g1
4000eacc: 82 00 60 20 add %g1, 0x20, %g1
4000ead0: 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;
4000ead4: 03 10 00 38 sethi %hi(0x4000e000), %g1
4000ead8: 82 10 63 f0 or %g1, 0x3f0, %g1 ! 4000e3f0 <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) +
4000eadc: 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;
4000eae0: 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;
4000eae4: 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;
4000eae8: 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;
4000eaec: c2 27 60 04 st %g1, [ %i5 + 4 ]
req->io_task = rtems_task_self ();
4000eaf0: 40 00 0c 3a call 40011bd8 <rtems_task_self>
4000eaf4: c0 27 40 00 clr [ %i5 ]
req->bufnum = 0;
4000eaf8: 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 ();
4000eafc: 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;
4000eb00: 82 10 20 09 mov 9, %g1
4000eb04: 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;
4000eb08: 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;
4000eb0c: 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;
4000eb10: f6 27 60 18 st %i3, [ %i5 + 0x18 ]
req->bufs [0].length = block_size;
4000eb14: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
4000eb18: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
4000eb1c: 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;
4000eb20: 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)
4000eb24: 10 80 00 16 b 4000eb7c <rtems_bdbuf_execute_read_request+0xb8>
4000eb28: a4 10 20 09 mov 9, %l2
{
media_block += media_blocks_per_block;
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
4000eb2c: 90 10 00 18 mov %i0, %o0
4000eb30: 92 10 00 1b mov %i3, %o1
4000eb34: 7f ff fd 4d call 4000e068 <rtems_bdbuf_get_buffer_for_read_ahead>
4000eb38: b8 07 20 10 add %i4, 0x10, %i4
if (bd == NULL)
4000eb3c: 80 a2 20 00 cmp %o0, 0
4000eb40: 32 80 00 09 bne,a 4000eb64 <rtems_bdbuf_execute_read_request+0xa0><== ALWAYS TAKEN
4000eb44: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4000eb48: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
return rtems_bdbuf_execute_transfer_request (dd, req, true);
4000eb4c: 90 10 00 18 mov %i0, %o0
4000eb50: 92 10 00 1d mov %i5, %o1
4000eb54: 7f ff fe 2d call 4000e408 <rtems_bdbuf_execute_transfer_request>
4000eb58: 94 10 20 01 mov 1, %o2
4000eb5c: 81 c7 e0 08 ret
4000eb60: 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;
4000eb64: d0 27 20 24 st %o0, [ %i4 + 0x24 ]
req->bufs [transfer_index].block = media_block;
4000eb68: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
req->bufs [transfer_index].length = block_size;
4000eb6c: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
req->bufs [transfer_index].buffer = bd->buffer;
4000eb70: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
4000eb74: 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;
4000eb78: 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)
4000eb7c: 80 a6 40 1a cmp %i1, %i2
4000eb80: 2a bf ff eb bcs,a 4000eb2c <rtems_bdbuf_execute_read_request+0x68>
4000eb84: b6 06 c0 11 add %i3, %l1, %i3
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4000eb88: 10 bf ff f1 b 4000eb4c <rtems_bdbuf_execute_read_request+0x88>
4000eb8c: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
4000d464 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
4000d464: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
4000d468: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
4000d46c: 7f ff f1 a7 call 40009b08 <rtems_fatal> <== NOT EXECUTED
4000d470: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000d4c0 <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
4000d4c0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
4000d4c4: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
4000d4c8: 7f ff ff e7 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d4cc: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
4000f1a8 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000f1a8: 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 ();
4000f1ac: 7f ff f8 bf call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f1b0: 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)
4000f1b4: 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;
4000f1b8: 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)
4000f1bc: 80 a6 40 01 cmp %i1, %g1
4000f1c0: 1a 80 00 26 bcc 4000f258 <rtems_bdbuf_get+0xb0> <== NEVER TAKEN
4000f1c4: 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)
4000f1c8: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000f1cc: 80 a2 60 00 cmp %o1, 0
4000f1d0: 26 80 00 04 bl,a 4000f1e0 <rtems_bdbuf_get+0x38> <== NEVER TAKEN
4000f1d4: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000f1d8: 10 80 00 09 b 4000f1fc <rtems_bdbuf_get+0x54>
4000f1dc: 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);
4000f1e0: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000f1e4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000f1e8: 40 00 23 0b call 40017e14 <__muldi3> <== NOT EXECUTED
4000f1ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000f1f0: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
4000f1f4: 40 00 25 19 call 40018658 <__udivdi3> <== NOT EXECUTED
4000f1f8: 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;
4000f1fc: 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);
4000f200: 90 10 00 1d mov %i5, %o0
4000f204: 7f ff fb ac call 4000e0b4 <rtems_bdbuf_get_buffer_for_access>
4000f208: 92 02 40 01 add %o1, %g1, %o1
4000f20c: b8 10 00 08 mov %o0, %i4
switch (bd->state)
4000f210: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000f214: 80 a2 20 02 cmp %o0, 2
4000f218: 02 80 00 08 be 4000f238 <rtems_bdbuf_get+0x90>
4000f21c: 80 a2 20 07 cmp %o0, 7
4000f220: 02 80 00 0a be 4000f248 <rtems_bdbuf_get+0xa0>
4000f224: 80 a2 20 01 cmp %o0, 1
4000f228: 12 80 00 0a bne 4000f250 <rtems_bdbuf_get+0xa8> <== NEVER TAKEN
4000f22c: 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;
4000f230: 10 80 00 04 b 4000f240 <rtems_bdbuf_get+0x98>
4000f234: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
4000f238: 82 10 20 03 mov 3, %g1
4000f23c: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
4000f240: 10 80 00 06 b 4000f258 <rtems_bdbuf_get+0xb0>
4000f244: b0 10 20 00 clr %i0
4000f248: 10 bf ff fd b 4000f23c <rtems_bdbuf_get+0x94>
4000f24c: 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);
4000f250: 7f ff f8 9c call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000f254: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000f258: 7f ff f8 a9 call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f25c: 01 00 00 00 nop
*bd_ptr = bd;
4000f260: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
4000f264: 81 c7 e0 08 ret
4000f268: 81 e8 00 00 restore
4000e0b4 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
4000e0b4: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000e0b8: 39 10 00 6d sethi %hi(0x4001b400), %i4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e0bc: 35 10 00 34 sethi %hi(0x4000d000), %i2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000e0c0: b8 17 20 2c or %i4, 0x2c, %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);
4000e0c4: 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);
4000e0c8: 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;
4000e0cc: 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);
4000e0d0: b6 07 20 74 add %i4, 0x74, %i3
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000e0d4: a6 07 20 50 add %i4, 0x50, %l3
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000e0d8: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
4000e0dc: 92 10 00 18 mov %i0, %o1
4000e0e0: 7f ff fd 82 call 4000d6e8 <rtems_bdbuf_avl_search.isra.0>
4000e0e4: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
4000e0e8: ba 92 20 00 orcc %o0, 0, %i5
4000e0ec: 02 80 00 2f be 4000e1a8 <rtems_bdbuf_get_buffer_for_access+0xf4>
4000e0f0: 90 10 00 18 mov %i0, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
4000e0f4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
4000e0f8: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000e0fc: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
4000e100: 80 a0 80 01 cmp %g2, %g1
4000e104: 02 80 00 35 be 4000e1d8 <rtems_bdbuf_get_buffer_for_access+0x124>
4000e108: a8 10 20 08 mov 8, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e10c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000e110: 80 a2 20 0a cmp %o0, 0xa
4000e114: 18 80 00 4f bgu 4000e250 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
4000e118: 92 10 20 14 mov 0x14, %o1
4000e11c: 82 16 a3 bc or %i2, 0x3bc, %g1
4000e120: 91 2a 20 02 sll %o0, 2, %o0
4000e124: c2 00 40 08 ld [ %g1 + %o0 ], %g1
4000e128: 81 c0 40 00 jmp %g1
4000e12c: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000e130: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000e134: 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;
4000e138: e8 27 60 20 st %l4, [ %i5 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
4000e13c: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000e140: 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;
4000e144: c2 07 20 60 ld [ %i4 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
4000e148: e4 27 40 00 st %l2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
4000e14c: fa 27 20 60 st %i5, [ %i4 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
4000e150: 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 ();
4000e154: 7f ff fc f0 call 4000d514 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
4000e158: 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)
4000e15c: 10 bf ff ed b 4000e110 <rtems_bdbuf_get_buffer_for_access+0x5c><== NOT EXECUTED
4000e160: 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)
4000e164: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000e168: 80 a0 60 00 cmp %g1, 0
4000e16c: 02 80 00 3b be 4000e258 <rtems_bdbuf_get_buffer_for_access+0x1a4><== NEVER TAKEN
4000e170: 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);
4000e174: 7f ff fd 0f call 4000d5b0 <rtems_bdbuf_anonymous_wait>
4000e178: 90 10 00 1b mov %i3, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000e17c: 10 bf ff d8 b 4000e0dc <rtems_bdbuf_get_buffer_for_access+0x28>
4000e180: 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);
4000e184: 90 10 00 1d mov %i5, %o0
4000e188: 10 80 00 04 b 4000e198 <rtems_bdbuf_get_buffer_for_access+0xe4>
4000e18c: 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);
4000e190: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000e194: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000e198: 7f ff fd 23 call 4000d624 <rtems_bdbuf_wait>
4000e19c: 01 00 00 00 nop
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e1a0: 10 bf ff dc b 4000e110 <rtems_bdbuf_get_buffer_for_access+0x5c>
4000e1a4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000e1a8: 7f ff fe c7 call 4000dcc4 <rtems_bdbuf_get_buffer_from_lru_list>
4000e1ac: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
4000e1b0: ba 92 20 00 orcc %o0, 0, %i5
4000e1b4: 32 80 00 0a bne,a 4000e1dc <rtems_bdbuf_get_buffer_for_access+0x128>
4000e1b8: 39 10 00 6d sethi %hi(0x4001b400), %i4
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000e1bc: c2 07 20 4c ld [ %i4 + 0x4c ], %g1 ! 4001b44c <bdbuf_cache+0x20>
4000e1c0: 80 a0 40 13 cmp %g1, %l3
4000e1c4: 02 bf ff ec be 4000e174 <rtems_bdbuf_get_buffer_for_access+0xc0>
4000e1c8: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
4000e1cc: 7f ff fc d2 call 4000d514 <rtems_bdbuf_wake_swapper>
4000e1d0: 01 00 00 00 nop
4000e1d4: 30 bf ff e8 b,a 4000e174 <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);
4000e1d8: 39 10 00 6d sethi %hi(0x4001b400), %i4
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e1dc: 37 10 00 34 sethi %hi(0x4000d000), %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);
4000e1e0: b8 17 20 98 or %i4, 0x98, %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);
4000e1e4: b4 07 3f f8 add %i4, -8, %i2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e1e8: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000e1ec: 82 02 3f ff add %o0, -1, %g1
4000e1f0: 80 a0 60 09 cmp %g1, 9
4000e1f4: 18 80 00 17 bgu 4000e250 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
4000e1f8: 92 10 20 13 mov 0x13, %o1
4000e1fc: 84 16 e3 94 or %i3, 0x394, %g2
4000e200: 83 28 60 02 sll %g1, 2, %g1
4000e204: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000e208: 81 c0 40 00 jmp %g1
4000e20c: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (bd);
4000e210: 7f ff fc 90 call 4000d450 <rtems_bdbuf_group_release>
4000e214: 90 10 00 1d mov %i5, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000e218: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
4000e21c: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
4000e220: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000e224: 10 80 00 15 b 4000e278 <rtems_bdbuf_get_buffer_for_access+0x1c4>
4000e228: 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);
4000e22c: 90 10 00 1d mov %i5, %o0
4000e230: 10 80 00 04 b 4000e240 <rtems_bdbuf_get_buffer_for_access+0x18c>
4000e234: 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);
4000e238: 90 10 00 1d mov %i5, %o0
4000e23c: 92 10 00 1c mov %i4, %o1
4000e240: 7f ff fc f9 call 4000d624 <rtems_bdbuf_wait>
4000e244: 01 00 00 00 nop
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000e248: 10 bf ff e9 b 4000e1ec <rtems_bdbuf_get_buffer_for_access+0x138>
4000e24c: 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);
4000e250: 7f ff fc 9c call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e254: 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);
4000e258: 7f ff fe 88 call 4000dc78 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
4000e25c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000e260: 7f ff fe 46 call 4000db78 <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
4000e264: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000e268: 7f ff fd 39 call 4000d74c <rtems_bdbuf_wake> <== NOT EXECUTED
4000e26c: 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);
4000e270: 10 bf ff 9b b 4000e0dc <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
4000e274: d0 07 20 3c ld [ %i4 + 0x3c ], %o0 <== NOT EXECUTED
}
}
while (bd == NULL);
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
4000e278: 90 10 00 1d mov %i5, %o0
4000e27c: 7f ff fc 70 call 4000d43c <rtems_bdbuf_group_obtain>
4000e280: b0 10 00 1d mov %i5, %i0
return bd;
}
4000e284: 81 c7 e0 08 ret
4000e288: 81 e8 00 00 restore
4000e068 <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)
{
4000e068: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000e06c: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000e070: d0 00 60 68 ld [ %g1 + 0x68 ], %o0 ! 4001b468 <bdbuf_cache+0x3c>
4000e074: 92 10 00 18 mov %i0, %o1
4000e078: 94 10 00 19 mov %i1, %o2
4000e07c: 7f ff fd 9b call 4000d6e8 <rtems_bdbuf_avl_search.isra.0>
4000e080: ba 10 20 00 clr %i5
if (bd == NULL)
4000e084: 80 a2 20 00 cmp %o0, 0
4000e088: 12 80 00 09 bne 4000e0ac <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
4000e08c: 90 10 00 18 mov %i0, %o0
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000e090: 7f ff ff 0d call 4000dcc4 <rtems_bdbuf_get_buffer_from_lru_list>
4000e094: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
4000e098: ba 92 20 00 orcc %o0, 0, %i5
4000e09c: 02 80 00 04 be 4000e0ac <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
4000e0a0: 01 00 00 00 nop
rtems_bdbuf_group_obtain (bd);
4000e0a4: 7f ff fc e6 call 4000d43c <rtems_bdbuf_group_obtain>
4000e0a8: 01 00 00 00 nop
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
4000e0ac: 81 c7 e0 08 ret
4000e0b0: 91 e8 00 1d restore %g0, %i5, %o0
4000dcc4 <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)
{
4000dcc4: 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;
4000dcc8: 25 10 00 6d sethi %hi(0x4001b400), %l2
4000dccc: 90 14 a0 2c or %l2, 0x2c, %o0 ! 4001b42c <bdbuf_cache>
4000dcd0: 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))
4000dcd4: a2 02 20 44 add %o0, 0x44, %l1
4000dcd8: 10 80 00 de b 4000e050 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
4000dcdc: 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)
4000dce0: 80 a0 60 00 cmp %g1, 0
4000dce4: 32 80 00 db bne,a 4000e050 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
4000dce8: f8 07 00 00 ld [ %i4 ], %i4
{
if (bd->group->bds_per_group == dd->bds_per_group)
4000dcec: fa 07 20 28 ld [ %i4 + 0x28 ], %i5
4000dcf0: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
4000dcf4: d2 07 60 08 ld [ %i5 + 8 ], %o1
4000dcf8: 80 a2 40 1b cmp %o1, %i3
4000dcfc: 32 80 00 06 bne,a 4000dd14 <rtems_bdbuf_get_buffer_from_lru_list+0x50>
4000dd00: c2 07 60 0c ld [ %i5 + 0xc ], %g1
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000dd04: 7f ff ff dd call 4000dc78 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000dd08: 90 10 00 1c mov %i4, %o0
4000dd0c: 10 80 00 30 b 4000ddcc <rtems_bdbuf_get_buffer_from_lru_list+0x108>
4000dd10: 84 10 00 1c mov %i4, %g2
empty_bd = bd;
}
else if (bd->group->users == 0)
4000dd14: 80 a0 60 00 cmp %g1, 0
4000dd18: 32 80 00 ce bne,a 4000e050 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
4000dd1c: 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;
4000dd20: d0 04 7f dc ld [ %l1 + -36 ], %o0
4000dd24: 40 00 26 e4 call 400178b4 <.udiv>
4000dd28: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
for (b = 0, bd = group->bdbuf;
4000dd2c: a0 10 20 00 clr %l0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000dd30: 83 2a 20 03 sll %o0, 3, %g1
4000dd34: 91 2a 20 06 sll %o0, 6, %o0
4000dd38: 10 80 00 05 b 4000dd4c <rtems_bdbuf_get_buffer_from_lru_list+0x88>
4000dd3c: a8 22 00 01 sub %o0, %g1, %l4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000dd40: 7f ff ff ce call 4000dc78 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000dd44: 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)
4000dd48: 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;
4000dd4c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000dd50: 80 a4 00 01 cmp %l0, %g1
4000dd54: 0a bf ff fb bcs 4000dd40 <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
4000dd58: 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;
4000dd5c: 82 14 a0 2c or %l2, 0x2c, %g1
4000dd60: 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;
4000dd64: f6 27 60 08 st %i3, [ %i5 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4000dd68: 40 00 26 d3 call 400178b4 <.udiv>
4000dd6c: 92 10 00 1b mov %i3, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4000dd70: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
4000dd74: 83 2a 20 03 sll %o0, 3, %g1
4000dd78: a1 2a 20 06 sll %o0, 6, %l0
4000dd7c: b6 10 20 01 mov 1, %i3
4000dd80: a0 24 00 01 sub %l0, %g1, %l0
4000dd84: 10 80 00 05 b 4000dd98 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
4000dd88: 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);
4000dd8c: 7f ff ff 7b call 4000db78 <rtems_bdbuf_make_free_and_add_to_lru_list>
4000dd90: 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)
4000dd94: 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;
4000dd98: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000dd9c: 80 a6 c0 01 cmp %i3, %g1
4000dda0: 0a bf ff fb bcs 4000dd8c <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
4000dda4: 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)
4000dda8: 80 a6 e0 01 cmp %i3, 1
4000ddac: 28 80 00 05 bleu,a 4000ddc0 <rtems_bdbuf_get_buffer_from_lru_list+0xfc>
4000ddb0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000ddb4: 7f ff fe 66 call 4000d74c <rtems_bdbuf_wake>
4000ddb8: 90 10 00 13 mov %l3, %o0
return group->bdbuf;
4000ddbc: 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)
4000ddc0: 80 a0 a0 00 cmp %g2, 0
4000ddc4: 22 80 00 a3 be,a 4000e050 <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
4000ddc8: 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 ;
4000ddcc: f0 20 a0 14 st %i0, [ %g2 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
4000ddd0: c0 20 a0 08 clr [ %g2 + 8 ]
bd->avl.right = NULL;
4000ddd4: 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;
4000ddd8: 07 10 00 6d sethi %hi(0x4001b400), %g3
4000dddc: 86 10 e0 2c or %g3, 0x2c, %g3 ! 4001b42c <bdbuf_cache>
4000dde0: 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;
4000dde4: f2 20 a0 18 st %i1, [ %g2 + 0x18 ]
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
4000dde8: 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;
4000ddec: ba 07 bf 80 add %fp, -128, %i5
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000ddf0: 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)
4000ddf4: 80 a0 60 00 cmp %g1, 0
4000ddf8: 12 80 00 1d bne 4000de6c <rtems_bdbuf_get_buffer_from_lru_list+0x1a8>
4000ddfc: b6 10 20 01 mov 1, %i3
{
*root = node;
4000de00: c4 20 e0 3c st %g2, [ %g3 + 0x3c ]
node->avl.left = NULL;
4000de04: c0 20 a0 08 clr [ %g2 + 8 ]
node->avl.right = NULL;
4000de08: c0 20 a0 0c clr [ %g2 + 0xc ]
node->avl.bal = 0;
4000de0c: 10 80 00 8e b 4000e044 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
4000de10: 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)))
4000de14: 32 80 00 0f bne,a 4000de50 <rtems_bdbuf_get_buffer_from_lru_list+0x18c><== NEVER TAKEN
4000de18: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
4000de1c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4000de20: 80 a0 c0 19 cmp %g3, %i1
4000de24: 1a 80 00 08 bcc 4000de44 <rtems_bdbuf_get_buffer_from_lru_list+0x180>
4000de28: 01 00 00 00 nop
{
p->avl.cache = 1;
q = p->avl.right;
4000de2c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (q == NULL)
4000de30: 80 a0 e0 00 cmp %g3, 0
4000de34: 12 80 00 0c bne 4000de64 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
4000de38: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.right = q = node;
4000de3c: 10 80 00 12 b 4000de84 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
4000de40: c4 20 60 0c st %g2, [ %g1 + 0xc ]
break;
}
}
else if ((p->dd != dd) || (p->block != block))
4000de44: 02 80 00 7e be 4000e03c <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
4000de48: 01 00 00 00 nop
{
p->avl.cache = -1;
q = p->avl.left;
4000de4c: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (q == NULL)
4000de50: 80 a0 e0 00 cmp %g3, 0
4000de54: 12 80 00 04 bne 4000de64 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
4000de58: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
4000de5c: 10 80 00 0a b 4000de84 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
4000de60: 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)
4000de64: ba 10 00 04 mov %g4, %i5
4000de68: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000de6c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4000de70: c2 27 40 00 st %g1, [ %i5 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000de74: 80 a0 c0 18 cmp %g3, %i0
4000de78: 0a bf ff ed bcs 4000de2c <rtems_bdbuf_get_buffer_from_lru_list+0x168><== NEVER TAKEN
4000de7c: 88 07 60 04 add %i5, 4, %g4
4000de80: 30 bf ff e5 b,a 4000de14 <rtems_bdbuf_get_buffer_from_lru_list+0x150>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4000de84: c0 20 a0 0c clr [ %g2 + 0xc ]
4000de88: c0 20 a0 08 clr [ %g2 + 8 ]
q->avl.bal = 0;
4000de8c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
4000de90: 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;
4000de94: b4 10 3f ff mov -1, %i2
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000de98: 10 80 00 03 b 4000dea4 <rtems_bdbuf_get_buffer_from_lru_list+0x1e0>
4000de9c: 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)
4000dea0: 82 10 00 04 mov %g4, %g1
{
if (p->avl.cache == -1)
4000dea4: c8 48 60 10 ldsb [ %g1 + 0x10 ], %g4
4000dea8: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
4000deac: 80 a1 3f ff cmp %g4, -1
{
switch (p->avl.bal)
4000deb0: 87 28 e0 18 sll %g3, 0x18, %g3
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
4000deb4: 12 80 00 26 bne 4000df4c <rtems_bdbuf_get_buffer_from_lru_list+0x288>
4000deb8: 87 38 e0 18 sra %g3, 0x18, %g3
{
switch (p->avl.bal)
4000debc: 80 a0 e0 00 cmp %g3, 0
4000dec0: 22 80 00 4d be,a 4000dff4 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
4000dec4: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
4000dec8: 80 a0 e0 01 cmp %g3, 1
4000decc: 02 80 00 28 be 4000df6c <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
4000ded0: 80 a0 ff ff cmp %g3, -1
4000ded4: 32 80 00 49 bne,a 4000dff8 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
4000ded8: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
4000dedc: 10 80 00 02 b 4000dee4 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
4000dee0: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (p1->avl.bal == -1) /* simple LL-turn */
4000dee4: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
4000dee8: 80 a1 3f ff cmp %g4, -1
4000deec: 12 80 00 05 bne 4000df00 <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
4000def0: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
4000def4: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
4000def8: 10 80 00 26 b 4000df90 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
4000defc: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000df00: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p1;
4000df04: c6 21 20 08 st %g3, [ %g4 + 8 ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000df08: f0 20 e0 0c st %i0, [ %g3 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000df0c: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p;
4000df10: 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;
4000df14: 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;
4000df18: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
4000df1c: 80 a6 3f ff cmp %i0, -1
4000df20: 12 80 00 04 bne 4000df30 <rtems_bdbuf_get_buffer_from_lru_list+0x26c>
4000df24: b6 10 00 04 mov %g4, %i3
4000df28: 10 80 00 03 b 4000df34 <rtems_bdbuf_get_buffer_from_lru_list+0x270>
4000df2c: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
4000df30: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000df34: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000df38: 80 a0 60 01 cmp %g1, 1
4000df3c: 32 80 00 2a bne,a 4000dfe4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
4000df40: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000df44: 10 80 00 28 b 4000dfe4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
4000df48: f4 28 e0 11 stb %i2, [ %g3 + 0x11 ]
break;
}
}
else
{
switch (p->avl.bal)
4000df4c: 80 a0 e0 00 cmp %g3, 0
4000df50: 22 80 00 29 be,a 4000dff4 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
4000df54: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
4000df58: 80 a0 e0 01 cmp %g3, 1
4000df5c: 02 80 00 06 be 4000df74 <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
4000df60: 80 a0 ff ff cmp %g3, -1
4000df64: 32 80 00 25 bne,a 4000dff8 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
4000df68: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
4000df6c: 10 80 00 20 b 4000dfec <rtems_bdbuf_get_buffer_from_lru_list+0x328>
4000df70: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
4000df74: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (p1->avl.bal == 1) /* simple RR-turn */
4000df78: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
4000df7c: 80 a1 20 01 cmp %g4, 1
4000df80: 12 80 00 07 bne 4000df9c <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
4000df84: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
p->avl.right = p1->avl.left;
4000df88: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
4000df8c: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.bal = 0;
4000df90: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000df94: 10 80 00 14 b 4000dfe4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
4000df98: b6 10 00 03 mov %g3, %i3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000df9c: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p1;
4000dfa0: c6 21 20 0c st %g3, [ %g4 + 0xc ]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000dfa4: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000dfa8: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p;
4000dfac: 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;
4000dfb0: 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;
4000dfb4: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
4000dfb8: 80 a6 20 01 cmp %i0, 1
4000dfbc: 12 80 00 04 bne 4000dfcc <rtems_bdbuf_get_buffer_from_lru_list+0x308><== ALWAYS TAKEN
4000dfc0: b6 10 00 04 mov %g4, %i3
4000dfc4: 10 80 00 03 b 4000dfd0 <rtems_bdbuf_get_buffer_from_lru_list+0x30c><== NOT EXECUTED
4000dfc8: f4 28 60 11 stb %i2, [ %g1 + 0x11 ] <== NOT EXECUTED
4000dfcc: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4000dfd0: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000dfd4: 80 a0 7f ff cmp %g1, -1
4000dfd8: 32 80 00 03 bne,a 4000dfe4 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== ALWAYS TAKEN
4000dfdc: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000dfe0: f8 28 e0 11 stb %i4, [ %g3 + 0x11 ] <== NOT EXECUTED
p = p2;
}
p->avl.bal = 0;
4000dfe4: c0 2e e0 11 clrb [ %i3 + 0x11 ]
4000dfe8: 82 10 00 1b mov %i3, %g1
modified = false;
4000dfec: 10 80 00 03 b 4000dff8 <rtems_bdbuf_get_buffer_from_lru_list+0x334>
4000dff0: 86 10 20 00 clr %g3
break;
}
}
else
{
switch (p->avl.bal)
4000dff4: 86 10 20 01 mov 1, %g3
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000dff8: 80 a7 40 19 cmp %i5, %i1
4000dffc: 28 80 00 09 bleu,a 4000e020 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
4000e000: 07 10 00 6d sethi %hi(0x4001b400), %g3
{
p = *--buf_prev;
4000e004: c8 07 7f fc ld [ %i5 + -4 ], %g4
if (p->avl.cache == -1)
4000e008: f6 49 20 10 ldsb [ %g4 + 0x10 ], %i3
4000e00c: 80 a6 ff ff cmp %i3, -1
4000e010: 32 80 00 06 bne,a 4000e028 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000e014: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p->avl.left = q;
4000e018: 10 80 00 04 b 4000e028 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000e01c: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.right = q;
}
}
else
{
*root = p;
4000e020: 10 80 00 09 b 4000e044 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
4000e024: c2 20 e0 68 st %g1, [ %g3 + 0x68 ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4000e028: 80 88 e0 ff btst 0xff, %g3
4000e02c: 12 bf ff 9d bne 4000dea0 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
4000e030: 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;
4000e034: 10 80 00 05 b 4000e048 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
4000e038: 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);
4000e03c: 7f ff fd 0a call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e040: 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;
4000e044: 82 10 20 01 mov 1, %g1
4000e048: 10 80 00 06 b 4000e060 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
4000e04c: 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))
4000e050: 80 a7 00 11 cmp %i4, %l1
4000e054: 32 bf ff 23 bne,a 4000dce0 <rtems_bdbuf_get_buffer_from_lru_list+0x1c>
4000e058: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
}
node = rtems_chain_next (node);
}
return NULL;
4000e05c: 84 10 20 00 clr %g2
}
4000e060: 81 c7 e0 08 ret
4000e064: 91 e8 00 02 restore %g0, %g2, %o0
4000ed60 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
4000ed60: 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())
4000ed64: 03 10 00 6f sethi %hi(0x4001bc00), %g1
4000ed68: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 4001be58 <_Per_CPU_Information+0x8>
4000ed6c: 80 a0 60 00 cmp %g1, 0
4000ed70: 12 80 00 16 bne 4000edc8 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
4000ed74: 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)
4000ed78: 35 10 00 66 sethi %hi(0x40019800), %i2
4000ed7c: b4 16 a2 68 or %i2, 0x268, %i2 ! 40019a68 <rtems_bdbuf_configuration>
4000ed80: f2 06 a0 28 ld [ %i2 + 0x28 ], %i1
4000ed84: f8 06 a0 24 ld [ %i2 + 0x24 ], %i4
4000ed88: 90 10 00 19 mov %i1, %o0
4000ed8c: 92 10 00 1c mov %i4, %o1
4000ed90: 40 00 23 75 call 40017b64 <.urem>
4000ed94: b0 10 20 0a mov 0xa, %i0
4000ed98: 80 a2 20 00 cmp %o0, 0
4000ed9c: 12 80 01 01 bne 4000f1a0 <rtems_bdbuf_init+0x440> <== NEVER TAKEN
4000eda0: 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 ();
4000eda4: 7f ff f9 e8 call 4000d544 <rtems_bdbuf_disable_preemption>
4000eda8: 3b 10 00 6d sethi %hi(0x4001b400), %i5
if (bdbuf_cache.initialised)
4000edac: ba 17 60 2c or %i5, 0x2c, %i5 ! 4001b42c <bdbuf_cache>
4000edb0: c2 0f 60 95 ldub [ %i5 + 0x95 ], %g1
4000edb4: 80 a0 60 00 cmp %g1, 0
4000edb8: 02 80 00 06 be 4000edd0 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
4000edbc: b6 10 00 08 mov %o0, %i3
{
rtems_bdbuf_restore_preemption (prev_mode);
4000edc0: 7f ff f9 ee call 4000d578 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
4000edc4: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
4000edc8: 81 c7 e0 08 ret <== NOT EXECUTED
4000edcc: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4000edd0: 92 10 20 00 clr %o1
4000edd4: 94 10 20 98 mov 0x98, %o2
4000edd8: 40 00 17 46 call 40014af0 <memset>
4000eddc: 90 10 00 1d mov %i5, %o0
bdbuf_cache.initialised = true;
4000ede0: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
4000ede4: 90 10 00 1b mov %i3, %o0
4000ede8: 7f ff f9 e4 call 4000d578 <rtems_bdbuf_restore_preemption>
4000edec: 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;
4000edf0: 82 07 60 0c add %i5, 0xc, %g1
4000edf4: c2 27 60 08 st %g1, [ %i5 + 8 ]
head->previous = NULL;
tail->previous = head;
4000edf8: 82 07 60 08 add %i5, 8, %g1
4000edfc: 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;
4000ee00: 82 07 60 44 add %i5, 0x44, %g1
4000ee04: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
head->previous = NULL;
tail->previous = head;
4000ee08: 82 07 60 40 add %i5, 0x40, %g1
4000ee0c: 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;
4000ee10: 82 07 60 50 add %i5, 0x50, %g1
4000ee14: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
head->previous = NULL;
tail->previous = head;
4000ee18: 82 07 60 4c add %i5, 0x4c, %g1
4000ee1c: 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;
4000ee20: 82 07 60 5c add %i5, 0x5c, %g1
4000ee24: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
head->previous = NULL;
tail->previous = head;
4000ee28: 82 07 60 58 add %i5, 0x58, %g1
4000ee2c: 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;
4000ee30: 82 07 60 8c add %i5, 0x8c, %g1
4000ee34: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
head->previous = NULL;
tail->previous = head;
4000ee38: 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;
4000ee3c: 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;
4000ee40: c0 27 60 0c clr [ %i5 + 0xc ]
4000ee44: c0 27 60 44 clr [ %i5 + 0x44 ]
4000ee48: c0 27 60 50 clr [ %i5 + 0x50 ]
4000ee4c: c0 27 60 5c clr [ %i5 + 0x5c ]
4000ee50: c0 27 60 8c clr [ %i5 + 0x8c ]
tail->previous = head;
4000ee54: 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'),
4000ee58: 37 10 91 10 sethi %hi(0x42444000), %i3
4000ee5c: 92 10 20 01 mov 1, %o1
4000ee60: 90 16 e3 6c or %i3, 0x36c, %o0
4000ee64: 94 10 20 54 mov 0x54, %o2
4000ee68: 96 10 20 00 clr %o3
4000ee6c: 7f ff e8 dd call 400091e0 <rtems_semaphore_create>
4000ee70: 98 07 60 28 add %i5, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
4000ee74: 80 a2 20 00 cmp %o0, 0
4000ee78: 12 80 00 a3 bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000ee7c: 03 10 00 6d sethi %hi(0x4001b400), %g1
goto error;
rtems_bdbuf_lock_cache ();
4000ee80: 7f ff f9 8a call 4000d4a8 <rtems_bdbuf_lock_cache>
4000ee84: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
4000ee88: 90 16 e3 73 or %i3, 0x373, %o0
4000ee8c: 92 10 20 01 mov 1, %o1
4000ee90: 94 10 20 54 mov 0x54, %o2
4000ee94: 96 10 20 00 clr %o3
4000ee98: 7f ff e8 d2 call 400091e0 <rtems_semaphore_create>
4000ee9c: 98 07 60 2c add %i5, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
4000eea0: 80 a2 20 00 cmp %o0, 0
4000eea4: 12 80 00 98 bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000eea8: 03 10 00 6d sethi %hi(0x4001b400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
4000eeac: 90 16 e3 61 or %i3, 0x361, %o0
4000eeb0: 92 10 20 00 clr %o1
4000eeb4: 94 10 20 24 mov 0x24, %o2
4000eeb8: 96 10 20 00 clr %o3
4000eebc: 7f ff e8 c9 call 400091e0 <rtems_semaphore_create>
4000eec0: 98 07 60 68 add %i5, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000eec4: 80 a2 20 00 cmp %o0, 0
4000eec8: 12 80 00 8f bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000eecc: 03 10 00 6d sethi %hi(0x4001b400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
4000eed0: 90 16 e3 74 or %i3, 0x374, %o0
4000eed4: 92 10 20 00 clr %o1
4000eed8: 94 10 20 24 mov 0x24, %o2
4000eedc: 96 10 20 00 clr %o3
4000eee0: 7f ff e8 c0 call 400091e0 <rtems_semaphore_create>
4000eee4: 98 07 60 70 add %i5, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000eee8: 80 a2 20 00 cmp %o0, 0
4000eeec: 12 80 00 86 bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000eef0: 03 10 00 6d sethi %hi(0x4001b400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
4000eef4: 90 16 e3 62 or %i3, 0x362, %o0
4000eef8: 92 10 20 00 clr %o1
4000eefc: 94 10 20 24 mov 0x24, %o2
4000ef00: 96 10 20 00 clr %o3
4000ef04: 7f ff e8 b7 call 400091e0 <rtems_semaphore_create>
4000ef08: 98 07 60 78 add %i5, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000ef0c: 80 a2 20 00 cmp %o0, 0
4000ef10: 12 80 00 7d bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000ef14: 03 10 00 6d sethi %hi(0x4001b400), %g1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4000ef18: d0 06 a0 20 ld [ %i2 + 0x20 ], %o0
4000ef1c: 40 00 22 66 call 400178b4 <.udiv>
4000ef20: 92 10 00 1c mov %i4, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
4000ef24: 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;
4000ef28: b6 10 00 08 mov %o0, %i3
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
4000ef2c: 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;
4000ef30: 40 00 22 61 call 400178b4 <.udiv>
4000ef34: 90 10 00 19 mov %i1, %o0
4000ef38: 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 =
4000ef3c: 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;
4000ef40: 40 00 22 5d call 400178b4 <.udiv>
4000ef44: 90 10 00 1b mov %i3, %o0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000ef48: 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 =
4000ef4c: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000ef50: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000ef54: 7f ff d8 5d call 400050c8 <calloc>
4000ef58: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4000ef5c: 80 a2 20 00 cmp %o0, 0
4000ef60: 02 80 00 68 be 4000f100 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
4000ef64: 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),
4000ef68: 90 10 20 14 mov 0x14, %o0
4000ef6c: 7f ff d8 57 call 400050c8 <calloc>
4000ef70: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4000ef74: 80 a2 20 00 cmp %o0, 0
4000ef78: 02 80 00 62 be 4000f100 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
4000ef7c: 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)
4000ef80: 92 10 00 1c mov %i4, %o1
4000ef84: 40 00 22 12 call 400177cc <.umul>
4000ef88: 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,
4000ef8c: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000ef90: 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,
4000ef94: 11 10 00 6d sethi %hi(0x4001b400), %o0
4000ef98: 40 00 07 24 call 40010c28 <rtems_memalign>
4000ef9c: 90 12 20 44 or %o0, 0x44, %o0 ! 4001b444 <bdbuf_cache+0x18>
4000efa0: 80 a2 20 00 cmp %o0, 0
4000efa4: 12 80 00 58 bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000efa8: 03 10 00 6d sethi %hi(0x4001b400), %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,
4000efac: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000efb0: 82 10 60 2c or %g1, 0x2c, %g1 ! 4001b42c <bdbuf_cache>
4000efb4: f6 00 60 80 ld [ %g1 + 0x80 ], %i3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000efb8: 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) ==
4000efbc: 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;
4000efc0: e0 00 60 18 ld [ %g1 + 0x18 ], %l0
b < bdbuf_cache.buffer_min_count;
4000efc4: 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))
4000efc8: 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;
4000efcc: 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,
4000efd0: b0 10 00 1b mov %i3, %i0
4000efd4: 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;
4000efd8: a2 10 00 01 mov %g1, %l1
4000efdc: 10 80 00 12 b 4000f024 <rtems_bdbuf_init+0x2c4>
4000efe0: 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;
4000efe4: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
bd->buffer = buffer;
4000efe8: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
4000efec: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
the_node->next = tail;
4000eff0: ea 27 40 00 st %l5, [ %i5 ]
tail->previous = the_node;
4000eff4: fa 24 60 48 st %i5, [ %l1 + 0x48 ]
old_last->next = the_node;
4000eff8: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
4000effc: 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) ==
4000f000: 90 10 00 19 mov %i1, %o0
4000f004: 40 00 22 d8 call 40017b64 <.urem>
4000f008: 92 10 00 12 mov %l2, %o1
4000f00c: 80 a2 00 14 cmp %o0, %l4
4000f010: 22 80 00 02 be,a 4000f018 <rtems_bdbuf_init+0x2b8>
4000f014: 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)
4000f018: b2 06 60 01 inc %i1
4000f01c: ba 07 60 38 add %i5, 0x38, %i5
4000f020: 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,
4000f024: 80 a6 40 13 cmp %i1, %l3
4000f028: 32 bf ff ef bne,a 4000efe4 <rtems_bdbuf_init+0x284>
4000f02c: c0 27 60 14 clr [ %i5 + 0x14 ]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
4000f030: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000f034: 82 10 60 2c or %g1, 0x2c, %g1 ! 4001b42c <bdbuf_cache>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4000f038: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
4000f03c: c6 00 60 7c ld [ %g1 + 0x7c ], %g3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
4000f040: 83 28 a0 03 sll %g2, 3, %g1
4000f044: 89 28 a0 06 sll %g2, 6, %g4
4000f048: 88 21 00 01 sub %g4, %g1, %g4
4000f04c: 10 80 00 06 b 4000f064 <rtems_bdbuf_init+0x304>
4000f050: 82 10 20 00 clr %g1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4000f054: 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++,
4000f058: 82 00 60 01 inc %g1
group++,
4000f05c: b6 06 e0 14 add %i3, 0x14, %i3
bd += bdbuf_cache.max_bds_per_group)
4000f060: 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,
4000f064: 80 a0 40 03 cmp %g1, %g3
4000f068: 32 bf ff fb bne,a 4000f054 <rtems_bdbuf_init+0x2f4>
4000f06c: 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'),
4000f070: 35 10 00 66 sethi %hi(0x40019800), %i2
4000f074: b8 16 a2 68 or %i2, 0x268, %i4 ! 40019a68 <rtems_bdbuf_configuration>
4000f078: 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;
4000f07c: 3b 10 00 6d sethi %hi(0x4001b400), %i5
4000f080: b6 10 20 01 mov 1, %i3
4000f084: ba 17 60 2c or %i5, 0x2c, %i5
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000f088: 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;
4000f08c: f6 2f 60 04 stb %i3, [ %i5 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000f090: 90 12 23 50 or %o0, 0x350, %o0
4000f094: 15 10 00 39 sethi %hi(0x4000e400), %o2
4000f098: 96 10 20 00 clr %o3
4000f09c: 94 12 a3 18 or %o2, 0x318, %o2
4000f0a0: 7f ff f9 b9 call 4000d784 <rtems_bdbuf_create_task.constprop.10>
4000f0a4: 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)
4000f0a8: 80 a2 20 00 cmp %o0, 0
4000f0ac: 12 80 00 16 bne 4000f104 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
4000f0b0: 03 10 00 6d sethi %hi(0x4001b400), %g1
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
4000f0b4: c2 06 a2 68 ld [ %i2 + 0x268 ], %g1
4000f0b8: 80 a0 60 00 cmp %g1, 0
4000f0bc: 32 80 00 06 bne,a 4000f0d4 <rtems_bdbuf_init+0x374>
4000f0c0: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
goto error;
}
rtems_bdbuf_unlock_cache ();
4000f0c4: 7f ff f9 0e call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f0c8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000f0cc: 81 c7 e0 08 ret
4000f0d0: 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;
4000f0d4: f6 2f 60 94 stb %i3, [ %i5 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000f0d8: 11 10 94 91 sethi %hi(0x42524400), %o0
4000f0dc: 15 10 00 3a sethi %hi(0x4000e800), %o2
4000f0e0: 90 12 20 41 or %o0, 0x41, %o0
4000f0e4: 94 12 a3 90 or %o2, 0x390, %o2
4000f0e8: 96 10 20 00 clr %o3
4000f0ec: 7f ff f9 a6 call 4000d784 <rtems_bdbuf_create_task.constprop.10>
4000f0f0: 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)
4000f0f4: 80 a2 20 00 cmp %o0, 0
4000f0f8: 02 bf ff f3 be 4000f0c4 <rtems_bdbuf_init+0x364> <== ALWAYS TAKEN
4000f0fc: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
4000f100: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED
4000f104: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001b4b0 <bdbuf_cache+0x84><== NOT EXECUTED
4000f108: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f10c: 02 80 00 05 be 4000f120 <rtems_bdbuf_init+0x3c0> <== NOT EXECUTED
4000f110: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
4000f114: 7f ff e9 a5 call 400097a8 <rtems_task_delete> <== NOT EXECUTED
4000f118: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
4000f11c: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED
4000f120: d0 00 60 2c ld [ %g1 + 0x2c ], %o0 ! 4001b42c <bdbuf_cache><== NOT EXECUTED
4000f124: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f128: 02 80 00 04 be 4000f138 <rtems_bdbuf_init+0x3d8> <== NOT EXECUTED
4000f12c: 3b 10 00 6d sethi %hi(0x4001b400), %i5 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
4000f130: 7f ff e9 9e call 400097a8 <rtems_task_delete> <== NOT EXECUTED
4000f134: 01 00 00 00 nop <== NOT EXECUTED
free (bdbuf_cache.buffers);
4000f138: ba 17 60 2c or %i5, 0x2c, %i5 <== NOT EXECUTED
4000f13c: 7f ff d8 1b call 400051a8 <free> <== NOT EXECUTED
4000f140: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
4000f144: 7f ff d8 19 call 400051a8 <free> <== NOT EXECUTED
4000f148: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
4000f14c: 7f ff d8 17 call 400051a8 <free> <== NOT EXECUTED
4000f150: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
4000f154: 7f ff e8 91 call 40009398 <rtems_semaphore_delete> <== NOT EXECUTED
4000f158: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
4000f15c: 7f ff e8 8f call 40009398 <rtems_semaphore_delete> <== NOT EXECUTED
4000f160: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
4000f164: 7f ff e8 8d call 40009398 <rtems_semaphore_delete> <== NOT EXECUTED
4000f168: d0 07 60 70 ld [ %i5 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
4000f16c: 7f ff e8 8b call 40009398 <rtems_semaphore_delete> <== NOT EXECUTED
4000f170: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
4000f174: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
4000f178: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f17c: 02 80 00 07 be 4000f198 <rtems_bdbuf_init+0x438> <== NOT EXECUTED
4000f180: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4000f184: 7f ff f8 de call 4000d4fc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000f188: 01 00 00 00 nop <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
4000f18c: 7f ff e8 83 call 40009398 <rtems_semaphore_delete> <== NOT EXECUTED
4000f190: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
4000f194: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
4000f198: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
4000f19c: c0 28 60 c1 clrb [ %g1 + 0xc1 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
4000f1a0: 81 c7 e0 08 ret <== NOT EXECUTED
4000f1a4: 81 e8 00 00 restore <== NOT EXECUTED
4000d478 <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)
{
4000d478: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
4000d47c: 92 10 20 00 clr %o1
4000d480: 90 10 00 18 mov %i0, %o0
4000d484: 7f ff ef f4 call 40009454 <rtems_semaphore_obtain>
4000d488: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4000d48c: 80 a2 20 00 cmp %o0, 0
4000d490: 02 80 00 04 be 4000d4a0 <rtems_bdbuf_lock+0x28> <== ALWAYS TAKEN
4000d494: 01 00 00 00 nop
rtems_bdbuf_fatal (fatal_error_code);
4000d498: 7f ff ff f3 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d49c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000d4a0: 81 c7 e0 08 ret
4000d4a4: 81 e8 00 00 restore
4000f734 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
4000f734: 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;
4000f738: 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;
4000f73c: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
tail->previous = head;
4000f740: 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;
4000f744: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
4000f748: 7f ff f7 58 call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f74c: c0 27 bf 78 clr [ %fp + -136 ]
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
4000f750: 7f ff fd 5c call 4000ecc0 <rtems_bdbuf_read_ahead_cancel>
4000f754: 90 10 00 18 mov %i0, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000f758: 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;
4000f75c: 11 10 00 6d sethi %hi(0x4001b400), %o0
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4000f760: 35 10 00 34 sethi %hi(0x4000d000), %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;
4000f764: 90 12 20 2c or %o0, 0x2c, %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;
4000f768: 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;
4000f76c: fa 02 20 3c ld [ %o0 + 0x3c ], %i5
*prev = NULL;
4000f770: 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;
4000f774: b8 07 bf 80 add %fp, -128, %i4
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4000f778: b4 16 a3 e8 or %i2, 0x3e8, %i2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f77c: b2 10 20 06 mov 6, %i1
4000f780: 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);
4000f784: 10 80 00 3a b 4000f86c <rtems_bdbuf_purge_dev+0x138>
4000f788: a2 02 20 6c add %o0, 0x6c, %l1
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
4000f78c: 80 a0 40 18 cmp %g1, %i0
4000f790: 32 80 00 1e bne,a 4000f808 <rtems_bdbuf_purge_dev+0xd4>
4000f794: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
switch (cur->state)
4000f798: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000f79c: 80 a0 60 0a cmp %g1, 0xa
4000f7a0: 18 80 00 17 bgu 4000f7fc <rtems_bdbuf_purge_dev+0xc8> <== NEVER TAKEN
4000f7a4: 83 28 60 02 sll %g1, 2, %g1
4000f7a8: c2 06 80 01 ld [ %i2 + %g1 ], %g1
4000f7ac: 81 c0 40 00 jmp %g1
4000f7b0: 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);
4000f7b4: 7f ff f7 e6 call 4000d74c <rtems_bdbuf_wake>
4000f7b8: 90 10 00 11 mov %l1, %o0
/* Fall through */
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (cur);
4000f7bc: 7f ff f7 25 call 4000d450 <rtems_bdbuf_group_release>
4000f7c0: 90 10 00 1d mov %i5, %o0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000f7c4: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000f7c8: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
next->previous = previous;
4000f7cc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000f7d0: 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;
4000f7d4: c2 07 bf 7c ld [ %fp + -132 ], %g1
the_node->next = tail;
4000f7d8: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
4000f7dc: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
4000f7e0: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
4000f7e4: 10 80 00 08 b 4000f804 <rtems_bdbuf_purge_dev+0xd0>
4000f7e8: 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;
4000f7ec: 10 80 00 06 b 4000f804 <rtems_bdbuf_purge_dev+0xd0>
4000f7f0: e0 27 60 20 st %l0, [ %i5 + 0x20 ]
4000f7f4: 10 80 00 04 b 4000f804 <rtems_bdbuf_purge_dev+0xd0>
4000f7f8: 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);
4000f7fc: 7f ff f7 1a call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000f800: 90 10 20 17 mov 0x17, %o0 <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
4000f804: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000f808: 80 a0 60 00 cmp %g1, 0
4000f80c: 22 80 00 04 be,a 4000f81c <rtems_bdbuf_purge_dev+0xe8>
4000f810: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
4000f814: 10 80 00 06 b 4000f82c <rtems_bdbuf_purge_dev+0xf8>
4000f818: fa 27 20 04 st %i5, [ %i4 + 4 ]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
4000f81c: 80 a0 60 00 cmp %g1, 0
4000f820: 22 80 00 08 be,a 4000f840 <rtems_bdbuf_purge_dev+0x10c>
4000f824: c2 07 00 00 ld [ %i4 ], %g1
{
/* Right */
++prev;
*prev = cur;
4000f828: fa 27 20 04 st %i5, [ %i4 + 4 ]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
4000f82c: 10 80 00 0f b 4000f868 <rtems_bdbuf_purge_dev+0x134>
4000f830: b8 07 20 04 add %i4, 4, %i4
while (*prev != NULL
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
{
/* Up */
cur = *prev;
--prev;
4000f834: b8 07 3f fc add %i4, -4, %i4
4000f838: ba 10 00 01 mov %g1, %i5
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
4000f83c: c2 07 00 00 ld [ %i4 ], %g1
4000f840: 80 a0 60 00 cmp %g1, 0
4000f844: 22 80 00 0a be,a 4000f86c <rtems_bdbuf_purge_dev+0x138>
4000f848: ba 10 00 01 mov %g1, %i5
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
4000f84c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000f850: 80 a7 40 02 cmp %i5, %g2
4000f854: 02 bf ff f8 be 4000f834 <rtems_bdbuf_purge_dev+0x100>
4000f858: 80 a0 a0 00 cmp %g2, 0
4000f85c: 22 bf ff f7 be,a 4000f838 <rtems_bdbuf_purge_dev+0x104>
4000f860: b8 07 3f fc add %i4, -4, %i4
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
4000f864: 82 10 00 02 mov %g2, %g1
4000f868: ba 10 00 01 mov %g1, %i5
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
4000f86c: 80 a7 60 00 cmp %i5, 0
4000f870: 32 bf ff c7 bne,a 4000f78c <rtems_bdbuf_purge_dev+0x58>
4000f874: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
4000f878: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f87c: 10 80 00 0c b 4000f8ac <rtems_bdbuf_purge_dev+0x178>
4000f880: 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)
4000f884: 80 a0 60 00 cmp %g1, 0
4000f888: 22 80 00 02 be,a 4000f890 <rtems_bdbuf_purge_dev+0x15c>
4000f88c: 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)
4000f890: 80 a0 60 00 cmp %g1, 0
4000f894: 12 80 00 06 bne 4000f8ac <rtems_bdbuf_purge_dev+0x178>
4000f898: f6 27 60 20 st %i3, [ %i5 + 0x20 ]
{
rtems_bdbuf_remove_from_tree (bd);
4000f89c: 7f ff f7 d1 call 4000d7e0 <rtems_bdbuf_remove_from_tree>
4000f8a0: 90 10 00 1d mov %i5, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000f8a4: 7f ff f8 b5 call 4000db78 <rtems_bdbuf_make_free_and_add_to_lru_list>
4000f8a8: 90 10 00 1d mov %i5, %o0
4000f8ac: 7f ff f6 da call 4000d414 <_Chain_Get_unprotected>
4000f8b0: 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)
4000f8b4: ba 92 20 00 orcc %o0, 0, %i5
4000f8b8: 32 bf ff f3 bne,a 4000f884 <rtems_bdbuf_purge_dev+0x150>
4000f8bc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
4000f8c0: 80 8f 20 ff btst 0xff, %i4
4000f8c4: 02 80 00 04 be 4000f8d4 <rtems_bdbuf_purge_dev+0x1a0>
4000f8c8: 11 10 00 6d sethi %hi(0x4001b400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000f8cc: 7f ff f7 a0 call 4000d74c <rtems_bdbuf_wake>
4000f8d0: 90 12 20 a0 or %o0, 0xa0, %o0 ! 4001b4a0 <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 ();
4000f8d4: 7f ff f7 0a call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f8d8: 01 00 00 00 nop
4000f8dc: 81 c7 e0 08 ret
4000f8e0: 81 e8 00 00 restore
4000f26c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000f26c: 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 ();
4000f270: 7f ff f8 8e call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f274: 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)
4000f278: 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;
4000f27c: 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)
4000f280: 80 a6 40 01 cmp %i1, %g1
4000f284: 1a 80 00 71 bcc 4000f448 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
4000f288: 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)
4000f28c: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000f290: 80 a2 60 00 cmp %o1, 0
4000f294: 26 80 00 04 bl,a 4000f2a4 <rtems_bdbuf_read+0x38> <== NEVER TAKEN
4000f298: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000f29c: 10 80 00 09 b 4000f2c0 <rtems_bdbuf_read+0x54>
4000f2a0: 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);
4000f2a4: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000f2a8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000f2ac: 40 00 22 da call 40017e14 <__muldi3> <== NOT EXECUTED
4000f2b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000f2b4: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
4000f2b8: 40 00 24 e8 call 40018658 <__udivdi3> <== NOT EXECUTED
4000f2bc: 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;
4000f2c0: 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);
4000f2c4: 90 10 00 1d mov %i5, %o0
4000f2c8: 7f ff fb 7b call 4000e0b4 <rtems_bdbuf_get_buffer_for_access>
4000f2cc: 92 02 40 01 add %o1, %g1, %o1
4000f2d0: b8 10 00 08 mov %o0, %i4
switch (bd->state)
4000f2d4: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000f2d8: 80 a2 20 02 cmp %o0, 2
4000f2dc: 02 80 00 08 be 4000f2fc <rtems_bdbuf_read+0x90>
4000f2e0: 80 a2 20 07 cmp %o0, 7
4000f2e4: 02 80 00 0b be 4000f310 <rtems_bdbuf_read+0xa4>
4000f2e8: 80 a2 20 01 cmp %o0, 1
4000f2ec: 12 80 00 2d bne 4000f3a0 <rtems_bdbuf_read+0x134> <== NEVER TAKEN
4000f2f0: 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;
4000f2f4: 10 80 00 0e b 4000f32c <rtems_bdbuf_read+0xc0>
4000f2f8: 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;
4000f2fc: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4000f300: 82 00 60 01 inc %g1
4000f304: 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;
4000f308: 10 80 00 06 b 4000f320 <rtems_bdbuf_read+0xb4>
4000f30c: 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;
4000f310: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4000f314: 82 00 60 01 inc %g1
4000f318: 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;
4000f31c: 82 10 20 04 mov 4, %g1
4000f320: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
4000f324: 10 80 00 21 b 4000f3a8 <rtems_bdbuf_read+0x13c>
4000f328: 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;
4000f32c: 82 00 60 01 inc %g1
4000f330: 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)
4000f334: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
4000f338: 80 a0 40 19 cmp %g1, %i1
4000f33c: 02 80 00 09 be 4000f360 <rtems_bdbuf_read+0xf4>
4000f340: 90 10 00 1d mov %i5, %o0
{
rtems_bdbuf_read_ahead_cancel (dd);
4000f344: 7f ff fe 5f call 4000ecc0 <rtems_bdbuf_read_ahead_cancel>
4000f348: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = block + 1;
4000f34c: 82 06 60 01 add %i1, 1, %g1
4000f350: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
4000f354: 82 06 60 02 add %i1, 2, %g1
4000f358: 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);
4000f35c: 90 10 00 1d mov %i5, %o0
4000f360: 92 10 00 1c mov %i4, %o1
4000f364: 7f ff fd d8 call 4000eac4 <rtems_bdbuf_execute_read_request>
4000f368: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
4000f36c: b0 92 20 00 orcc %o0, 0, %i0
4000f370: 32 80 00 0e bne,a 4000f3a8 <rtems_bdbuf_read+0x13c>
4000f374: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f378: 82 10 20 03 mov 3, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000f37c: c4 07 00 00 ld [ %i4 ], %g2
4000f380: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
previous = the_node->previous;
4000f384: 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);
4000f388: 90 10 00 1c mov %i4, %o0
next->previous = previous;
4000f38c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000f390: 7f ff f8 2b call 4000d43c <rtems_bdbuf_group_obtain>
4000f394: 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
4000f398: 10 80 00 05 b 4000f3ac <rtems_bdbuf_read+0x140>
4000f39c: 03 10 00 6d sethi %hi(0x4001b400), %g1
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4000f3a0: 7f ff f8 48 call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000f3a4: 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
4000f3a8: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000f3ac: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 4001b4b0 <bdbuf_cache+0x84>
4000f3b0: 80 a2 20 00 cmp %o0, 0
4000f3b4: 02 80 00 25 be 4000f448 <rtems_bdbuf_read+0x1dc>
4000f3b8: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
4000f3bc: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
4000f3c0: 80 a0 40 19 cmp %g1, %i1
4000f3c4: 12 80 00 21 bne 4000f448 <rtems_bdbuf_read+0x1dc>
4000f3c8: 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);
4000f3cc: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
4000f3d0: 80 a0 a0 00 cmp %g2, 0
4000f3d4: 12 80 00 05 bne 4000f3e8 <rtems_bdbuf_read+0x17c> <== NEVER TAKEN
4000f3d8: 82 10 20 00 clr %g1
4000f3dc: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
4000f3e0: 80 a0 00 01 cmp %g0, %g1
4000f3e4: 82 60 3f ff subx %g0, -1, %g1
&& !rtems_bdbuf_is_read_ahead_active (dd))
4000f3e8: 80 a0 60 00 cmp %g1, 0
4000f3ec: 02 80 00 17 be 4000f448 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
4000f3f0: 03 10 00 6d sethi %hi(0x4001b400), %g1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000f3f4: 82 10 60 2c or %g1, 0x2c, %g1 ! 4001b42c <bdbuf_cache>
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
4000f3f8: c4 00 60 88 ld [ %g1 + 0x88 ], %g2
4000f3fc: 82 00 60 8c add %g1, 0x8c, %g1
4000f400: 80 a0 80 01 cmp %g2, %g1
4000f404: 12 80 00 09 bne 4000f428 <rtems_bdbuf_read+0x1bc> <== NEVER TAKEN
4000f408: 03 10 00 6d sethi %hi(0x4001b400), %g1
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
4000f40c: 7f ff e6 e5 call 40008fa0 <rtems_event_send>
4000f410: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
4000f414: 80 a2 20 00 cmp %o0, 0
4000f418: 02 80 00 04 be 4000f428 <rtems_bdbuf_read+0x1bc> <== ALWAYS TAKEN
4000f41c: 03 10 00 6d sethi %hi(0x4001b400), %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
4000f420: 7f ff f8 11 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000f424: 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;
4000f428: 82 10 60 2c or %g1, 0x2c, %g1
4000f42c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
4000f430: 86 07 60 64 add %i5, 0x64, %g3
the_node->next = tail;
4000f434: 88 00 60 8c add %g1, 0x8c, %g4
tail->previous = the_node;
4000f438: 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;
4000f43c: c8 27 60 64 st %g4, [ %i5 + 0x64 ]
tail->previous = the_node;
old_last->next = the_node;
4000f440: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
4000f444: c4 27 60 68 st %g2, [ %i5 + 0x68 ]
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
4000f448: 7f ff f8 2d call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f44c: 01 00 00 00 nop
*bd_ptr = bd;
4000f450: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
4000f454: 81 c7 e0 08 ret
4000f458: 81 e8 00 00 restore
4000ecc0 <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);
4000ecc0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1
4000ecc4: 80 a0 60 00 cmp %g1, 0
4000ecc8: 12 80 00 05 bne 4000ecdc <rtems_bdbuf_read_ahead_cancel+0x1c><== NEVER TAKEN
4000eccc: 84 10 20 00 clr %g2
4000ecd0: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
4000ecd4: 80 a0 00 02 cmp %g0, %g2
4000ecd8: 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))
4000ecdc: 80 a0 a0 00 cmp %g2, 0
4000ece0: 12 80 00 07 bne 4000ecfc <rtems_bdbuf_read_ahead_cancel+0x3c><== ALWAYS TAKEN
4000ece4: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000ece8: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
next->previous = previous;
4000ecec: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
4000ecf0: 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;
4000ecf4: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED
4000ecf8: c0 22 20 64 clr [ %o0 + 0x64 ] <== NOT EXECUTED
4000ecfc: 81 c3 e0 08 retl
4000eb90 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
4000eb90: 9d e3 bf a0 save %sp, -96, %sp
4000eb94: 33 10 00 6d sethi %hi(0x4001b400), %i1
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
4000eb98: 35 10 00 6d sethi %hi(0x4001b400), %i2
4000eb9c: b2 16 60 b4 or %i1, 0xb4, %i1
4000eba0: 10 80 00 41 b 4000eca4 <rtems_bdbuf_read_ahead_task+0x114>
4000eba4: 31 10 00 66 sethi %hi(0x40019800), %i0
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
4000eba8: 7f ff fa ac call 4000d658 <rtems_bdbuf_wait_for_event>
4000ebac: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
4000ebb0: 7f ff fa 3e call 4000d4a8 <rtems_bdbuf_lock_cache>
4000ebb4: 01 00 00 00 nop
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
4000ebb8: 30 80 00 34 b,a 4000ec88 <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)
4000ebbc: 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;
4000ebc0: 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)
4000ebc4: 80 a7 00 02 cmp %i4, %g2
4000ebc8: 1a 80 00 11 bcc 4000ec0c <rtems_bdbuf_read_ahead_task+0x7c>
4000ebcc: 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)
4000ebd0: d2 07 7f cc ld [ %i5 + -52 ], %o1
4000ebd4: 80 a2 60 00 cmp %o1, 0
4000ebd8: 16 80 00 0a bge 4000ec00 <rtems_bdbuf_read_ahead_task+0x70><== ALWAYS TAKEN
4000ebdc: 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);
4000ebe0: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
4000ebe4: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000ebe8: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000ebec: 40 00 24 8a call 40017e14 <__muldi3> <== NOT EXECUTED
4000ebf0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000ebf4: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
4000ebf8: 40 00 26 98 call 40018658 <__udivdi3> <== NOT EXECUTED
4000ebfc: 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;
4000ec00: c2 07 7f b4 ld [ %i5 + -76 ], %g1
4000ec04: 92 02 40 01 add %o1, %g1, %o1
4000ec08: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4000ec0c: 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)
4000ec10: 80 a0 60 00 cmp %g1, 0
4000ec14: 12 80 00 1b bne 4000ec80 <rtems_bdbuf_read_ahead_task+0xf0>
4000ec18: 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 *)
4000ec1c: 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 =
4000ec20: 7f ff fd 12 call 4000e068 <rtems_bdbuf_get_buffer_for_read_ahead>
4000ec24: 90 10 00 1b mov %i3, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
4000ec28: 92 92 20 00 orcc %o0, 0, %o1
4000ec2c: 02 80 00 17 be 4000ec88 <rtems_bdbuf_read_ahead_task+0xf8><== NEVER TAKEN
4000ec30: c2 06 22 68 ld [ %i0 + 0x268 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
4000ec34: d4 07 7f c4 ld [ %i5 + -60 ], %o2
4000ec38: 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)
4000ec3c: 80 a2 80 01 cmp %o2, %g1
4000ec40: 2a 80 00 09 bcs,a 4000ec64 <rtems_bdbuf_read_ahead_task+0xd4>
4000ec44: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
4000ec48: 85 30 60 01 srl %g1, 1, %g2
dd->read_ahead.next = block + transfer_count;
4000ec4c: 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;
4000ec50: 84 00 80 1c add %g2, %i4, %g2
dd->read_ahead.next = block + transfer_count;
4000ec54: 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;
4000ec58: c4 27 60 08 st %g2, [ %i5 + 8 ]
dd->read_ahead.next = block + transfer_count;
4000ec5c: 10 80 00 03 b 4000ec68 <rtems_bdbuf_read_ahead_task+0xd8>
4000ec60: f8 27 60 0c st %i4, [ %i5 + 0xc ]
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000ec64: c2 27 60 08 st %g1, [ %i5 + 8 ]
}
++dd->stats.read_ahead_transfers;
4000ec68: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000ec6c: 90 10 00 1b mov %i3, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
4000ec70: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000ec74: 7f ff ff 94 call 4000eac4 <rtems_bdbuf_execute_read_request>
4000ec78: c2 27 7f e8 st %g1, [ %i5 + -24 ]
4000ec7c: 30 80 00 03 b,a 4000ec88 <rtems_bdbuf_read_ahead_task+0xf8>
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000ec80: 82 10 3f ff mov -1, %g1
4000ec84: c2 27 60 08 st %g1, [ %i5 + 8 ]
4000ec88: 7f ff f9 e3 call 4000d414 <_Chain_Get_unprotected>
4000ec8c: 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)
4000ec90: ba 92 20 00 orcc %o0, 0, %i5
4000ec94: 32 bf ff ca bne,a 4000ebbc <rtems_bdbuf_read_ahead_task+0x2c>
4000ec98: f8 07 60 0c ld [ %i5 + 0xc ], %i4
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
4000ec9c: 7f ff fa 18 call 4000d4fc <rtems_bdbuf_unlock_cache>
4000eca0: 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)
4000eca4: 82 16 a0 2c or %i2, 0x2c, %g1
4000eca8: c2 08 60 94 ldub [ %g1 + 0x94 ], %g1
4000ecac: 80 a0 60 00 cmp %g1, 0
4000ecb0: 12 bf ff be bne 4000eba8 <rtems_bdbuf_read_ahead_task+0x18><== ALWAYS TAKEN
4000ecb4: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
4000ecb8: 7f ff ea bc call 400097a8 <rtems_task_delete> <== NOT EXECUTED
4000ecbc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000f45c <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
4000f45c: 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)
4000f460: 80 a6 20 00 cmp %i0, 0
4000f464: 02 80 00 31 be 4000f528 <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
4000f468: 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();
4000f46c: 7f ff f8 0f call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f470: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4000f474: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000f478: 80 a2 20 04 cmp %o0, 4
4000f47c: 02 80 00 22 be 4000f504 <rtems_bdbuf_release+0xa8>
4000f480: 01 00 00 00 nop
4000f484: 18 80 00 06 bgu 4000f49c <rtems_bdbuf_release+0x40>
4000f488: 80 a2 20 06 cmp %o0, 6
4000f48c: 80 a2 20 03 cmp %o0, 3
4000f490: 12 80 00 20 bne 4000f510 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
4000f494: 01 00 00 00 nop
4000f498: 30 80 00 04 b,a 4000f4a8 <rtems_bdbuf_release+0x4c>
4000f49c: 18 80 00 1d bgu 4000f510 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
4000f4a0: 01 00 00 00 nop
4000f4a4: 30 80 00 15 b,a 4000f4f8 <rtems_bdbuf_release+0x9c>
}
static void
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
4000f4a8: 7f ff f7 ea call 4000d450 <rtems_bdbuf_group_release>
4000f4ac: 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;
4000f4b0: 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;
4000f4b4: 11 10 00 6d sethi %hi(0x4001b400), %o0
4000f4b8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
4000f4bc: 90 12 20 2c or %o0, 0x2c, %o0
4000f4c0: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
4000f4c4: 84 02 20 44 add %o0, 0x44, %g2
tail->previous = the_node;
4000f4c8: 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;
4000f4cc: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
4000f4d0: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
4000f4d4: 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)
4000f4d8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000f4dc: 80 a0 60 00 cmp %g1, 0
4000f4e0: 22 80 00 03 be,a 4000f4ec <rtems_bdbuf_release+0x90>
4000f4e4: 90 02 20 74 add %o0, 0x74, %o0
4000f4e8: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000f4ec: 7f ff f8 98 call 4000d74c <rtems_bdbuf_wake>
4000f4f0: 01 00 00 00 nop
4000f4f4: 30 80 00 09 b,a 4000f518 <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);
4000f4f8: 7f ff fe 03 call 4000ed04 <rtems_bdbuf_discard_buffer_after_access>
4000f4fc: 90 10 00 18 mov %i0, %o0
break;
4000f500: 30 80 00 06 b,a 4000f518 <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4000f504: 7f ff f9 a6 call 4000db9c <rtems_bdbuf_add_to_modified_list_after_access>
4000f508: 90 10 00 18 mov %i0, %o0
break;
4000f50c: 30 80 00 03 b,a 4000f518 <rtems_bdbuf_release+0xbc>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
4000f510: 7f ff f7 ec call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000f514: 92 10 20 0e mov 0xe, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000f518: 7f ff f7 f9 call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f51c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000f520: 81 c7 e0 08 ret
4000f524: 81 e8 00 00 restore
}
4000f528: 81 c7 e0 08 ret <== NOT EXECUTED
4000f52c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
4000f530 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
4000f530: 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)
4000f534: 80 a6 20 00 cmp %i0, 0
4000f538: 02 80 00 19 be 4000f59c <rtems_bdbuf_release_modified+0x6c><== NEVER TAKEN
4000f53c: 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();
4000f540: 7f ff f7 da call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f544: 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)
4000f548: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000f54c: 80 a2 20 03 cmp %o0, 3
4000f550: 0a 80 00 0d bcs 4000f584 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4000f554: 80 a2 20 05 cmp %o0, 5
4000f558: 08 80 00 05 bleu 4000f56c <rtems_bdbuf_release_modified+0x3c>
4000f55c: 80 a2 20 06 cmp %o0, 6
4000f560: 12 80 00 09 bne 4000f584 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4000f564: 01 00 00 00 nop
4000f568: 30 80 00 04 b,a 4000f578 <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);
4000f56c: 7f ff f9 8c call 4000db9c <rtems_bdbuf_add_to_modified_list_after_access>
4000f570: 90 10 00 18 mov %i0, %o0
break;
4000f574: 30 80 00 06 b,a 4000f58c <rtems_bdbuf_release_modified+0x5c>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4000f578: 7f ff fd e3 call 4000ed04 <rtems_bdbuf_discard_buffer_after_access>
4000f57c: 90 10 00 18 mov %i0, %o0
break;
4000f580: 30 80 00 03 b,a 4000f58c <rtems_bdbuf_release_modified+0x5c>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
4000f584: 7f ff f7 cf call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000f588: 92 10 20 12 mov 0x12, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000f58c: 7f ff f7 dc call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f590: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000f594: 81 c7 e0 08 ret
4000f598: 81 e8 00 00 restore
}
4000f59c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f5a0: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
4000d7e0 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
4000d7e0: 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;
4000d7e4: 03 10 00 6d sethi %hi(0x4001b400), %g1
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
4000d7e8: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
4000d7ec: f6 06 20 18 ld [ %i0 + 0x18 ], %i3
rtems_bdbuf_buffer* p = *root;
4000d7f0: fa 00 60 68 ld [ %g1 + 0x68 ], %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));
4000d7f4: 90 07 bf 80 add %fp, -128, %o0
4000d7f8: 92 10 20 00 clr %o1
4000d7fc: 40 00 1c bd call 40014af0 <memset>
4000d800: 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;
4000d804: 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;
4000d808: 84 10 20 01 mov 1, %g2
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000d80c: 10 80 00 15 b 4000d860 <rtems_bdbuf_remove_from_tree+0x80>
4000d810: b4 10 3f ff mov -1, %i2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000d814: fa 20 c0 00 st %i5, [ %g3 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000d818: 80 a0 40 1c cmp %g1, %i4
4000d81c: 0a 80 00 09 bcs 4000d840 <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
4000d820: 88 00 e0 04 add %g3, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
4000d824: 80 a0 40 1c cmp %g1, %i4
4000d828: 32 80 00 0c bne,a 4000d858 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
4000d82c: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ] <== NOT EXECUTED
4000d830: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000d834: 80 a0 40 1b cmp %g1, %i3
4000d838: 1a 80 00 05 bcc 4000d84c <rtems_bdbuf_remove_from_tree+0x6c>
4000d83c: 01 00 00 00 nop
{
p->avl.cache = 1;
4000d840: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ]
p = p->avl.right;
4000d844: 10 80 00 06 b 4000d85c <rtems_bdbuf_remove_from_tree+0x7c>
4000d848: fa 07 60 0c ld [ %i5 + 0xc ], %i5
}
else if ((p->dd != dd) || (p->block != block))
4000d84c: 02 80 00 b9 be 4000db30 <rtems_bdbuf_remove_from_tree+0x350>
4000d850: 82 07 bf 80 add %fp, -128, %g1
{
p->avl.cache = -1;
4000d854: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ]
p = p->avl.left;
4000d858: fa 07 60 08 ld [ %i5 + 8 ], %i5
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000d85c: 86 10 00 04 mov %g4, %g3
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
4000d860: 80 a7 60 00 cmp %i5, 0
4000d864: 32 bf ff ec bne,a 4000d814 <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
4000d868: 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);
4000d86c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
4000d870: 7f ff ff 14 call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000d874: 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)
4000d878: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000d87c: 80 a0 60 00 cmp %g1, 0
4000d880: 32 80 00 08 bne,a 4000d8a0 <rtems_bdbuf_remove_from_tree+0xc0>
4000d884: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
r = q->avl.left;
4000d888: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (r != NULL)
4000d88c: 80 a0 60 00 cmp %g1, 0
4000d890: 32 80 00 27 bne,a 4000d92c <rtems_bdbuf_remove_from_tree+0x14c>
4000d894: c0 28 60 11 clrb [ %g1 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
4000d898: 10 80 00 26 b 4000d930 <rtems_bdbuf_remove_from_tree+0x150>
4000d89c: 80 a7 20 00 cmp %i4, 0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
4000d8a0: 80 a0 a0 00 cmp %g2, 0
4000d8a4: 02 80 00 06 be 4000d8bc <rtems_bdbuf_remove_from_tree+0xdc>
4000d8a8: 84 10 00 01 mov %g1, %g2
4000d8ac: b6 10 00 01 mov %g1, %i3
4000d8b0: 86 10 00 04 mov %g4, %g3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
4000d8b4: 10 80 00 0f b 4000d8f0 <rtems_bdbuf_remove_from_tree+0x110>
4000d8b8: b2 10 3f ff mov -1, %i1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4000d8bc: c4 07 60 08 ld [ %i5 + 8 ], %g2
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
4000d8c0: c2 21 3f fc st %g1, [ %g4 + -4 ]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4000d8c4: c4 20 60 08 st %g2, [ %g1 + 8 ]
r->avl.bal = q->avl.bal;
4000d8c8: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r->avl.cache = 1;
*buf_prev++ = q = r;
4000d8cc: 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;
4000d8d0: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
r->avl.cache = 1;
4000d8d4: 84 10 20 01 mov 1, %g2
4000d8d8: 10 80 00 15 b 4000d92c <rtems_bdbuf_remove_from_tree+0x14c>
4000d8dc: 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;
4000d8e0: f2 28 a0 10 stb %i1, [ %g2 + 0x10 ]
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
4000d8e4: b6 10 00 02 mov %g2, %i3
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
4000d8e8: 86 00 e0 04 add %g3, 4, %g3
s = r->avl.left;
4000d8ec: 84 10 00 1a mov %i2, %g2
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4000d8f0: f4 00 a0 08 ld [ %g2 + 8 ], %i2
4000d8f4: 80 a6 a0 00 cmp %i2, 0
4000d8f8: 32 bf ff fa bne,a 4000d8e0 <rtems_bdbuf_remove_from_tree+0x100>
4000d8fc: 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;
4000d900: 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;
4000d904: 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;
4000d908: f4 20 a0 08 st %i2, [ %g2 + 8 ]
r->avl.left = s->avl.right;
4000d90c: f4 00 a0 0c ld [ %g2 + 0xc ], %i2
s->avl.right = q->avl.right;
4000d910: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
s->avl.bal = q->avl.bal;
4000d914: 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;
4000d918: f4 26 e0 08 st %i2, [ %i3 + 8 ]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4000d91c: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
s->avl.cache = 1;
4000d920: 82 10 20 01 mov 1, %g1
4000d924: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*t = q = s;
4000d928: 82 10 00 02 mov %g2, %g1
}
}
if (p != NULL)
4000d92c: 80 a7 20 00 cmp %i4, 0
4000d930: 02 80 00 0d be 4000d964 <rtems_bdbuf_remove_from_tree+0x184>
4000d934: 05 10 00 6d sethi %hi(0x4001b400), %g2
{
if (p->avl.cache == -1)
4000d938: c4 4f 20 10 ldsb [ %i4 + 0x10 ], %g2
4000d93c: 80 a0 bf ff cmp %g2, -1
4000d940: 32 80 00 03 bne,a 4000d94c <rtems_bdbuf_remove_from_tree+0x16c>
4000d944: c2 27 20 0c st %g1, [ %i4 + 0xc ]
{
p->avl.left = q;
4000d948: c2 27 20 08 st %g1, [ %i4 + 8 ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
4000d94c: 82 07 bf 80 add %fp, -128, %g1
4000d950: 80 a0 c0 01 cmp %g3, %g1
4000d954: 18 80 00 06 bgu 4000d96c <rtems_bdbuf_remove_from_tree+0x18c>
4000d958: ba 10 20 01 mov 1, %i5
4000d95c: 81 c7 e0 08 ret
4000d960: 81 e8 00 00 restore
p->avl.right = q;
}
}
else
{
*root = q;
4000d964: 10 bf ff fa b 4000d94c <rtems_bdbuf_remove_from_tree+0x16c>
4000d968: c2 20 a0 68 st %g1, [ %g2 + 0x68 ]
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
4000d96c: b6 10 3f ff mov -1, %i3
default:
break;
}
}
if (buf_prev > buf_stack)
4000d970: b2 10 00 01 mov %g1, %i1
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
4000d974: c2 00 ff fc ld [ %g3 + -4 ], %g1
else
{
break;
}
if (p->avl.cache == -1)
4000d978: f8 48 60 10 ldsb [ %g1 + 0x10 ], %i4
4000d97c: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
4000d980: 80 a7 3f ff cmp %i4, -1
{
/* rebalance left branch */
switch (p->avl.bal)
4000d984: 85 28 a0 18 sll %g2, 0x18, %g2
else
{
break;
}
if (p->avl.cache == -1)
4000d988: 12 80 00 2a bne 4000da30 <rtems_bdbuf_remove_from_tree+0x250>
4000d98c: 85 38 a0 18 sra %g2, 0x18, %g2
{
/* rebalance left branch */
switch (p->avl.bal)
4000d990: 80 a0 a0 00 cmp %g2, 0
4000d994: 22 80 00 14 be,a 4000d9e4 <rtems_bdbuf_remove_from_tree+0x204>
4000d998: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
4000d99c: 80 a0 a0 01 cmp %g2, 1
4000d9a0: 02 80 00 06 be 4000d9b8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000d9a4: 80 a0 bf ff cmp %g2, -1
4000d9a8: 12 80 00 4f bne 4000dae4 <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
4000d9ac: 84 10 20 01 mov 1, %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
4000d9b0: 10 80 00 4d b 4000dae4 <rtems_bdbuf_remove_from_tree+0x304>
4000d9b4: c0 28 60 11 clrb [ %g1 + 0x11 ]
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
4000d9b8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (p1->avl.bal >= 0) /* simple RR-turn */
4000d9bc: f4 48 a0 11 ldsb [ %g2 + 0x11 ], %i2
4000d9c0: 80 a6 a0 00 cmp %i2, 0
4000d9c4: 06 80 00 0a bl 4000d9ec <rtems_bdbuf_remove_from_tree+0x20c>
4000d9c8: c8 00 a0 08 ld [ %g2 + 8 ], %g4
{
p->avl.right = p1->avl.left;
4000d9cc: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
if (p1->avl.bal == 0)
4000d9d0: 80 a6 a0 00 cmp %i2, 0
4000d9d4: 12 80 00 2d bne 4000da88 <rtems_bdbuf_remove_from_tree+0x2a8>
4000d9d8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
{
p1->avl.bal = -1;
4000d9dc: f8 28 a0 11 stb %i4, [ %g2 + 0x11 ]
4000d9e0: 82 10 00 02 mov %g2, %g1
modified = false;
4000d9e4: 10 80 00 40 b 4000dae4 <rtems_bdbuf_remove_from_tree+0x304>
4000d9e8: 84 10 20 00 clr %g2
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000d9ec: f4 01 20 0c ld [ %g4 + 0xc ], %i2
p2->avl.right = p1;
4000d9f0: c4 21 20 0c st %g2, [ %g4 + 0xc ]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000d9f4: f4 20 a0 08 st %i2, [ %g2 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000d9f8: f4 01 20 08 ld [ %g4 + 8 ], %i2
p2->avl.left = p;
4000d9fc: 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;
4000da00: 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;
4000da04: f4 49 20 11 ldsb [ %g4 + 0x11 ], %i2
4000da08: 80 a6 a0 01 cmp %i2, 1
4000da0c: 32 80 00 03 bne,a 4000da18 <rtems_bdbuf_remove_from_tree+0x238>
4000da10: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000da14: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000da18: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000da1c: 80 a0 7f ff cmp %g1, -1
4000da20: 32 80 00 2e bne,a 4000dad8 <rtems_bdbuf_remove_from_tree+0x2f8><== ALWAYS TAKEN
4000da24: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000da28: 10 80 00 2c b 4000dad8 <rtems_bdbuf_remove_from_tree+0x2f8><== NOT EXECUTED
4000da2c: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ] <== NOT EXECUTED
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4000da30: 80 a0 a0 00 cmp %g2, 0
4000da34: 22 bf ff ec be,a 4000d9e4 <rtems_bdbuf_remove_from_tree+0x204>
4000da38: f6 28 60 11 stb %i3, [ %g1 + 0x11 ]
4000da3c: 80 a0 a0 01 cmp %g2, 1
4000da40: 02 80 00 06 be 4000da58 <rtems_bdbuf_remove_from_tree+0x278>
4000da44: 80 a0 bf ff cmp %g2, -1
4000da48: 32 80 00 27 bne,a 4000dae4 <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
4000da4c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
4000da50: 10 80 00 04 b 4000da60 <rtems_bdbuf_remove_from_tree+0x280>
4000da54: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
4000da58: 10 80 00 22 b 4000dae0 <rtems_bdbuf_remove_from_tree+0x300>
4000da5c: c0 28 60 11 clrb [ %g1 + 0x11 ]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
4000da60: f8 48 a0 11 ldsb [ %g2 + 0x11 ], %i4
4000da64: 80 a7 20 00 cmp %i4, 0
4000da68: 14 80 00 0c bg 4000da98 <rtems_bdbuf_remove_from_tree+0x2b8>
4000da6c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
4000da70: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
if (p1->avl.bal == 0)
4000da74: 80 a7 20 00 cmp %i4, 0
4000da78: 12 80 00 04 bne 4000da88 <rtems_bdbuf_remove_from_tree+0x2a8>
4000da7c: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
p1->avl.bal = 1;
4000da80: 10 bf ff d8 b 4000d9e0 <rtems_bdbuf_remove_from_tree+0x200>
4000da84: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
modified = false;
}
else
{
p->avl.bal = 0;
4000da88: c0 28 60 11 clrb [ %g1 + 0x11 ]
p1->avl.bal = 0;
4000da8c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000da90: 10 80 00 14 b 4000dae0 <rtems_bdbuf_remove_from_tree+0x300>
4000da94: 82 10 00 02 mov %g2, %g1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000da98: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p1;
4000da9c: c4 21 20 08 st %g2, [ %g4 + 8 ]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000daa0: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000daa4: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p;
4000daa8: 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;
4000daac: 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;
4000dab0: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
4000dab4: 80 a7 3f ff cmp %i4, -1
4000dab8: 32 80 00 03 bne,a 4000dac4 <rtems_bdbuf_remove_from_tree+0x2e4>
4000dabc: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000dac0: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000dac4: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
4000dac8: 80 a0 60 01 cmp %g1, 1
4000dacc: 32 80 00 03 bne,a 4000dad8 <rtems_bdbuf_remove_from_tree+0x2f8>
4000dad0: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000dad4: f6 28 a0 11 stb %i3, [ %g2 + 0x11 ]
p = p2;
p2->avl.bal = 0;
4000dad8: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000dadc: 82 10 00 04 mov %g4, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4000dae0: 84 10 20 01 mov 1, %g2
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
4000dae4: 88 00 ff fc add %g3, -4, %g4
default:
break;
}
}
if (buf_prev > buf_stack)
4000dae8: 80 a1 00 19 cmp %g4, %i1
4000daec: 28 80 00 09 bleu,a 4000db10 <rtems_bdbuf_remove_from_tree+0x330>
4000daf0: 05 10 00 6d sethi %hi(0x4001b400), %g2
{
q = *(buf_prev - 1);
4000daf4: c8 00 ff f8 ld [ %g3 + -8 ], %g4
if (q->avl.cache == -1)
4000daf8: f8 49 20 10 ldsb [ %g4 + 0x10 ], %i4
4000dafc: 80 a7 3f ff cmp %i4, -1
4000db00: 32 80 00 07 bne,a 4000db1c <rtems_bdbuf_remove_from_tree+0x33c>
4000db04: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
q->avl.left = p;
4000db08: 10 80 00 05 b 4000db1c <rtems_bdbuf_remove_from_tree+0x33c>
4000db0c: c2 21 20 08 st %g1, [ %g4 + 8 ]
q->avl.right = p;
}
}
else
{
*root = p;
4000db10: c2 20 a0 68 st %g1, [ %g2 + 0x68 ]
4000db14: 81 c7 e0 08 ret
4000db18: 81 e8 00 00 restore
*root = q;
}
modified = true;
while (modified)
4000db1c: 80 88 a0 ff btst 0xff, %g2
4000db20: 12 bf ff 95 bne 4000d974 <rtems_bdbuf_remove_from_tree+0x194>
4000db24: 86 00 ff fc add %g3, -4, %g3
4000db28: 81 c7 e0 08 ret
4000db2c: 81 e8 00 00 restore
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
4000db30: 80 a0 c0 01 cmp %g3, %g1
4000db34: 08 bf ff 51 bleu 4000d878 <rtems_bdbuf_remove_from_tree+0x98>
4000db38: b8 10 20 00 clr %i4
{
p = *(buf_prev - 1);
4000db3c: 10 bf ff 4f b 4000d878 <rtems_bdbuf_remove_from_tree+0x98>
4000db40: f8 01 3f f8 ld [ %g4 + -8 ], %i4
4000dc78 <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)
{
4000dc78: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
4000dc7c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000dc80: 80 a2 20 00 cmp %o0, 0
4000dc84: 22 80 00 0b be,a 4000dcb0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
4000dc88: c4 06 00 00 ld [ %i0 ], %g2
4000dc8c: 80 a2 20 02 cmp %o0, 2
4000dc90: 12 80 00 06 bne 4000dca8 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30><== NEVER TAKEN
4000dc94: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
4000dc98: 7f ff fe d2 call 4000d7e0 <rtems_bdbuf_remove_from_tree>
4000dc9c: 90 10 00 18 mov %i0, %o0
break;
4000dca0: 10 80 00 04 b 4000dcb0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
4000dca4: c4 06 00 00 ld [ %i0 ], %g2
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
4000dca8: 7f ff fe 06 call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000dcac: 92 10 20 16 mov 0x16, %o1 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000dcb0: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
4000dcb4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000dcb8: c4 20 40 00 st %g2, [ %g1 ]
4000dcbc: 81 c7 e0 08 ret
4000dcc0: 81 e8 00 00 restore
4000d578 <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000d578: 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);
4000d57c: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000d580: 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);
4000d584: 90 10 00 18 mov %i0, %o0
4000d588: 92 12 63 ff or %o1, 0x3ff, %o1
4000d58c: 40 00 11 35 call 40011a60 <rtems_task_mode>
4000d590: 94 07 a0 44 add %fp, 0x44, %o2
if (sc != RTEMS_SUCCESSFUL)
4000d594: 80 a2 20 00 cmp %o0, 0
4000d598: 02 80 00 04 be 4000d5a8 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
4000d59c: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
4000d5a0: 7f ff ff b1 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d5a4: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6> <== NOT EXECUTED
4000d5a8: 81 c7 e0 08 ret
4000d5ac: 81 e8 00 00 restore
4000f8e4 <rtems_bdbuf_set_block_size>:
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
4000f8e4: 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)
4000f8e8: 80 a6 a0 00 cmp %i2, 0
4000f8ec: 02 80 00 04 be 4000f8fc <rtems_bdbuf_set_block_size+0x18>
4000f8f0: ba 10 00 18 mov %i0, %i5
rtems_bdbuf_syncdev (dd);
4000f8f4: 7f ff ff 79 call 4000f6d8 <rtems_bdbuf_syncdev>
4000f8f8: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_lock_cache ();
4000f8fc: 7f ff f6 eb call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f900: b0 10 20 0a mov 0xa, %i0
if (block_size > 0)
4000f904: 80 a6 60 00 cmp %i1, 0
4000f908: 02 80 00 30 be 4000f9c8 <rtems_bdbuf_set_block_size+0xe4>
4000f90c: 03 10 00 66 sethi %hi(0x40019800), %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)
4000f910: 82 10 62 68 or %g1, 0x268, %g1 ! 40019a68 <rtems_bdbuf_configuration>
4000f914: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
4000f918: 80 a6 40 02 cmp %i1, %g2
4000f91c: 18 80 00 2b bgu 4000f9c8 <rtems_bdbuf_set_block_size+0xe4><== NEVER TAKEN
4000f920: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
4000f924: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
4000f928: 40 00 1f e3 call 400178b4 <.udiv>
4000f92c: 90 06 7f ff add %i1, -1, %o0
for (bds_per_size = 1;
4000f930: 92 10 20 01 mov 1, %o1
4000f934: 90 02 20 01 inc %o0
4000f938: 80 a2 40 08 cmp %o1, %o0
4000f93c: 2a bf ff ff bcs,a 4000f938 <rtems_bdbuf_set_block_size+0x54>
4000f940: 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;
4000f944: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000f948: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 ! 4001b44c <bdbuf_cache+0x20>
4000f94c: 40 00 1f da call 400178b4 <.udiv>
4000f950: 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)
4000f954: 80 a2 20 00 cmp %o0, 0
4000f958: 02 80 00 1c be 4000f9c8 <rtems_bdbuf_set_block_size+0xe4> <== NEVER TAKEN
4000f95c: 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;
4000f960: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
4000f964: 90 10 00 19 mov %i1, %o0
4000f968: 40 00 1f d3 call 400178b4 <.udiv>
4000f96c: 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;
4000f970: b8 10 20 00 clr %i4
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
4000f974: b6 10 00 08 mov %o0, %i3
4000f978: 84 10 20 01 mov 1, %g2
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
4000f97c: 83 28 80 1c sll %g2, %i4, %g1
4000f980: 80 a0 40 1b cmp %g1, %i3
4000f984: 2a bf ff fe bcs,a 4000f97c <rtems_bdbuf_set_block_size+0x98>
4000f988: b8 07 20 01 inc %i4
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
4000f98c: b1 2e 00 1c sll %i0, %i4, %i0
4000f990: 80 a6 00 19 cmp %i0, %i1
4000f994: 32 80 00 02 bne,a 4000f99c <rtems_bdbuf_set_block_size+0xb8><== NEVER TAKEN
4000f998: 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;
4000f99c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
4000f9a0: 92 10 00 1b mov %i3, %o1
4000f9a4: 40 00 1f c4 call 400178b4 <.udiv>
4000f9a8: 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;
4000f9ac: 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;
4000f9b0: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
dd->media_blocks_per_block = media_blocks_per_block;
4000f9b4: f6 27 60 2c st %i3, [ %i5 + 0x2c ]
dd->block_to_media_block_shift = block_to_media_block_shift;
4000f9b8: f8 27 60 30 st %i4, [ %i5 + 0x30 ]
dd->bds_per_group = bds_per_group;
4000f9bc: f4 27 60 34 st %i2, [ %i5 + 0x34 ]
rtems_bdbuf_purge_dev (dd);
4000f9c0: 7f ff ff 5d call 4000f734 <rtems_bdbuf_purge_dev>
4000f9c4: 90 10 00 1d mov %i5, %o0
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
4000f9c8: 7f ff f6 cd call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f9cc: 01 00 00 00 nop
return sc;
}
4000f9d0: 81 c7 e0 08 ret
4000f9d4: 81 e8 00 00 restore
4000e28c <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
4000e28c: 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;
4000e290: 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 );
4000e294: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
4000e298: 80 a0 40 19 cmp %g1, %i1
4000e29c: 02 80 00 4e be 4000e3d4 <rtems_bdbuf_swapout_modified_processing+0x148>
4000e2a0: 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))
4000e2a4: 02 80 00 05 be 4000e2b8 <rtems_bdbuf_swapout_modified_processing+0x2c>
4000e2a8: 84 10 20 00 clr %g2
4000e2ac: c4 06 00 00 ld [ %i0 ], %g2
4000e2b0: 80 a0 00 02 cmp %g0, %g2
4000e2b4: 84 60 3f ff subx %g0, -1, %g2
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
4000e2b8: 07 10 00 6d sethi %hi(0x4001b400), %g3
4000e2bc: de 00 e0 a0 ld [ %g3 + 0xa0 ], %o7 ! 4001b4a0 <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))
4000e2c0: 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;
4000e2c4: 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))
4000e2c8: 80 a3 60 00 cmp %o5, 0
4000e2cc: 32 80 00 0d bne,a 4000e300 <rtems_bdbuf_swapout_modified_processing+0x74>
4000e2d0: c0 20 60 2c clr [ %g1 + 0x2c ]
4000e2d4: 80 a6 e0 00 cmp %i3, 0
4000e2d8: 02 80 00 07 be 4000e2f4 <rtems_bdbuf_swapout_modified_processing+0x68>
4000e2dc: 80 a3 e0 00 cmp %o7, 0
4000e2e0: c6 06 00 00 ld [ %i0 ], %g3
4000e2e4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000e2e8: 80 a0 c0 02 cmp %g3, %g2
4000e2ec: 02 80 00 04 be 4000e2fc <rtems_bdbuf_swapout_modified_processing+0x70>
4000e2f0: 80 a3 e0 00 cmp %o7, 0
|| rtems_bdbuf_has_buffer_waiters ())
4000e2f4: 22 80 00 04 be,a 4000e304 <rtems_bdbuf_swapout_modified_processing+0x78>
4000e2f8: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
bd->hold_timer = 0;
4000e2fc: c0 20 60 2c clr [ %g1 + 0x2c ]
if (bd->hold_timer)
4000e300: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000e304: 80 a0 a0 00 cmp %g2, 0
4000e308: 22 80 00 10 be,a 4000e348 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000e30c: c4 06 00 00 ld [ %i0 ], %g2
{
if (update_timers)
4000e310: 80 a7 20 00 cmp %i4, 0
4000e314: 22 80 00 08 be,a 4000e334 <rtems_bdbuf_swapout_modified_processing+0xa8>
4000e318: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
{
if (bd->hold_timer > timer_delta)
4000e31c: 80 a0 80 1d cmp %g2, %i5
4000e320: 28 80 00 04 bleu,a 4000e330 <rtems_bdbuf_swapout_modified_processing+0xa4>
4000e324: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
4000e328: 84 20 80 1d sub %g2, %i5, %g2
4000e32c: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
4000e330: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000e334: 80 a0 a0 00 cmp %g2, 0
4000e338: 22 80 00 04 be,a 4000e348 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000e33c: c4 06 00 00 ld [ %i0 ], %g2
{
node = node->next;
continue;
4000e340: 10 80 00 22 b 4000e3c8 <rtems_bdbuf_swapout_modified_processing+0x13c>
4000e344: 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)
4000e348: 80 a0 a0 00 cmp %g2, 0
4000e34c: 32 80 00 05 bne,a 4000e360 <rtems_bdbuf_swapout_modified_processing+0xd4>
4000e350: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
*dd_ptr = bd->dd;
4000e354: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000e358: c4 26 00 00 st %g2, [ %i0 ]
if (bd->dd == *dd_ptr)
4000e35c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
4000e360: c4 06 00 00 ld [ %i0 ], %g2
4000e364: 80 a0 c0 02 cmp %g3, %g2
4000e368: 12 80 00 17 bne 4000e3c4 <rtems_bdbuf_swapout_modified_processing+0x138><== NEVER TAKEN
4000e36c: c6 00 40 00 ld [ %g1 ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000e370: 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;
4000e374: d8 20 60 20 st %o4, [ %g1 + 0x20 ]
next->previous = previous;
4000e378: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000e37c: c6 20 80 00 st %g3, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
4000e380: 10 80 00 0c b 4000e3b0 <rtems_bdbuf_swapout_modified_processing+0x124>
4000e384: 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)
4000e388: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4000e38c: 80 a2 c0 04 cmp %o3, %g4
4000e390: 28 80 00 08 bleu,a 4000e3b0 <rtems_bdbuf_swapout_modified_processing+0x124>
4000e394: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000e398: c8 00 80 00 ld [ %g2 ], %g4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000e39c: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000e3a0: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
4000e3a4: c8 20 40 00 st %g4, [ %g1 ]
before_node->previous = the_node;
4000e3a8: 10 80 00 07 b 4000e3c4 <rtems_bdbuf_swapout_modified_processing+0x138>
4000e3ac: c2 21 20 04 st %g1, [ %g4 + 4 ]
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
4000e3b0: 80 a0 80 1a cmp %g2, %i2
4000e3b4: 32 bf ff f5 bne,a 4000e388 <rtems_bdbuf_swapout_modified_processing+0xfc>
4000e3b8: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000e3bc: 10 80 00 08 b 4000e3dc <rtems_bdbuf_swapout_modified_processing+0x150>
4000e3c0: c4 06 80 00 ld [ %i2 ], %g2
node = next_node;
}
else
{
node = node->next;
4000e3c4: 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))
4000e3c8: 80 a0 40 19 cmp %g1, %i1
4000e3cc: 12 bf ff c0 bne 4000e2cc <rtems_bdbuf_swapout_modified_processing+0x40>
4000e3d0: 80 a3 60 00 cmp %o5, 0
4000e3d4: 81 c7 e0 08 ret
4000e3d8: 81 e8 00 00 restore
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000e3dc: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000e3e0: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
4000e3e4: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
4000e3e8: 10 bf ff f7 b 4000e3c4 <rtems_bdbuf_swapout_modified_processing+0x138>
4000e3ec: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000e718 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
4000e718: 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;
4000e71c: 33 10 00 66 sethi %hi(0x40019800), %i1
4000e720: b2 16 62 68 or %i1, 0x268, %i1 ! 40019a68 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000e724: 7f ff fb de call 4000d69c <rtems_bdbuf_swapout_writereq_alloc>
4000e728: 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;
4000e72c: 82 07 bf ec add %fp, -20, %g1
4000e730: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
4000e734: 82 07 bf e8 add %fp, -24, %g1
4000e738: 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);
4000e73c: 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 ();
4000e740: 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);
4000e744: 91 2e e0 07 sll %i3, 7, %o0
4000e748: 90 22 00 01 sub %o0, %g1, %o0
4000e74c: 03 10 00 66 sethi %hi(0x40019800), %g1
4000e750: d2 00 62 2c ld [ %g1 + 0x22c ], %o1 ! 40019a2c <Configuration+0xc>
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4000e754: 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;
4000e758: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
4000e75c: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000e760: 90 02 00 1b add %o0, %i3, %o0
4000e764: 40 00 24 54 call 400178b4 <.udiv>
4000e768: 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;
4000e76c: 35 10 00 6d sethi %hi(0x4001b400), %i2
4000e770: a0 10 00 08 mov %o0, %l0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
4000e774: 7f ff fb 4d call 4000d4a8 <rtems_bdbuf_lock_cache>
4000e778: b4 16 a0 2c or %i2, 0x2c, %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),
4000e77c: 27 10 91 1b sethi %hi(0x42446c00), %l3
4000e780: 29 10 00 3a sethi %hi(0x4000e800), %l4
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000e784: b8 10 20 00 clr %i4
4000e788: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
the_node->next = tail;
4000e78c: 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;
4000e790: 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),
4000e794: a6 14 e3 00 or %l3, 0x300, %l3
4000e798: 10 80 00 23 b 4000e824 <rtems_bdbuf_swapout_task+0x10c>
4000e79c: a8 15 22 3c or %l4, 0x23c, %l4
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4000e7a0: 7f ff db c3 call 400056ac <malloc> <== NOT EXECUTED
4000e7a4: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
4000e7a8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4000e7ac: 32 80 00 04 bne,a 4000e7bc <rtems_bdbuf_swapout_task+0xa4><== NOT EXECUTED
4000e7b0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
4000e7b4: 10 80 00 1a b 4000e81c <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
4000e7b8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
4000e7bc: e2 27 40 00 st %l1, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
4000e7c0: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000e7c4: 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;
4000e7c8: 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 ();
4000e7cc: 7f ff fb b4 call 4000d69c <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
4000e7d0: 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),
4000e7d4: 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 );
4000e7d8: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
4000e7dc: 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 ();
4000e7e0: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
head->next = tail;
4000e7e4: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
4000e7e8: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
4000e7ec: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000e7f0: 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)
4000e7f4: 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),
4000e7f8: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
4000e7fc: 90 12 00 13 or %o0, %l3, %o0 <== NOT EXECUTED
4000e800: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4000e804: 7f ff fb e0 call 4000d784 <rtems_bdbuf_create_task.constprop.10><== NOT EXECUTED
4000e808: 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)
4000e80c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e810: 22 80 00 05 be,a 4000e824 <rtems_bdbuf_swapout_task+0x10c><== NOT EXECUTED
4000e814: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
4000e818: 90 10 20 0d mov 0xd, %o0 <== NOT EXECUTED
4000e81c: 7f ff fb 12 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e820: 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++)
4000e824: 80 a7 00 18 cmp %i4, %i0
4000e828: 0a bf ff de bcs 4000e7a0 <rtems_bdbuf_swapout_task+0x88> <== NEVER TAKEN
4000e82c: 01 00 00 00 nop
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
4000e830: 7f ff fb 33 call 4000d4fc <rtems_bdbuf_unlock_cache>
4000e834: 39 10 00 6d sethi %hi(0x4001b400), %i4
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000e838: b8 17 20 2c or %i4, 0x2c, %i4 ! 4001b42c <bdbuf_cache>
4000e83c: 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,
4000e840: a4 07 20 58 add %i4, 0x58, %l2
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000e844: 10 80 00 5a b 4000e9ac <rtems_bdbuf_swapout_task+0x294>
4000e848: 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 ();
4000e84c: 7f ff fb 17 call 4000d4a8 <rtems_bdbuf_lock_cache>
4000e850: 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)
4000e854: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
4000e858: 80 a0 60 00 cmp %g1, 0
4000e85c: 02 80 00 04 be 4000e86c <rtems_bdbuf_swapout_task+0x154>
4000e860: 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,
4000e864: 10 80 00 08 b 4000e884 <rtems_bdbuf_swapout_task+0x16c>
4000e868: ba 07 bf e8 add %fp, -24, %i5
4000e86c: 7f ff fa ea call 4000d414 <_Chain_Get_unprotected>
4000e870: 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)
4000e874: b4 92 20 00 orcc %o0, 0, %i2
4000e878: 22 bf ff fb be,a 4000e864 <rtems_bdbuf_swapout_task+0x14c><== ALWAYS TAKEN
4000e87c: b4 10 20 00 clr %i2
transfer = &worker->transfer;
4000e880: 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 );
4000e884: 82 07 60 04 add %i5, 4, %g1
head->next = tail;
4000e888: c2 27 40 00 st %g1, [ %i5 ]
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
4000e88c: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
head->previous = NULL;
4000e890: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
4000e894: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
4000e898: 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)
4000e89c: 80 88 60 ff btst 0xff, %g1
4000e8a0: 02 80 00 04 be 4000e8b0 <rtems_bdbuf_swapout_task+0x198>
4000e8a4: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
transfer->dd = bdbuf_cache.sync_device;
4000e8a8: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
4000e8ac: 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,
4000e8b0: b0 07 60 0c add %i5, 0xc, %i0
4000e8b4: 92 10 00 12 mov %l2, %o1
4000e8b8: 90 10 00 18 mov %i0, %o0
4000e8bc: 94 10 00 1d mov %i5, %o2
4000e8c0: 96 10 20 01 mov 1, %o3
4000e8c4: 98 10 20 00 clr %o4
4000e8c8: 7f ff fe 71 call 4000e28c <rtems_bdbuf_swapout_modified_processing>
4000e8cc: 9a 10 00 1b mov %i3, %o5
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000e8d0: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
4000e8d4: 90 10 00 18 mov %i0, %o0
4000e8d8: 92 10 00 13 mov %l3, %o1
4000e8dc: 94 10 00 1d mov %i5, %o2
4000e8e0: 98 0e 60 01 and %i1, 1, %o4
4000e8e4: 7f ff fe 6a call 4000e28c <rtems_bdbuf_swapout_modified_processing>
4000e8e8: 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 ();
4000e8ec: 7f ff fb 04 call 4000d4fc <rtems_bdbuf_unlock_cache>
4000e8f0: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000e8f4: 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 );
4000e8f8: 82 07 60 04 add %i5, 4, %g1
4000e8fc: 80 a0 80 01 cmp %g2, %g1
4000e900: 02 80 00 10 be 4000e940 <rtems_bdbuf_swapout_task+0x228>
4000e904: 80 a6 a0 00 cmp %i2, 0
{
if (worker)
4000e908: 02 80 00 0a be 4000e930 <rtems_bdbuf_swapout_task+0x218> <== ALWAYS TAKEN
4000e90c: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
4000e910: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
4000e914: 7f ff e9 a3 call 40008fa0 <rtems_event_send> <== NOT EXECUTED
4000e918: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000e91c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e920: 02 80 00 09 be 4000e944 <rtems_bdbuf_swapout_task+0x22c> <== NOT EXECUTED
4000e924: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
4000e928: 10 bf ff bd b 4000e81c <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
4000e92c: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
4000e930: 7f ff ff 22 call 4000e5b8 <rtems_bdbuf_swapout_write>
4000e934: 90 10 00 1d mov %i5, %o0
}
transfered_buffers = true;
4000e938: 10 80 00 03 b 4000e944 <rtems_bdbuf_swapout_task+0x22c>
4000e93c: 82 10 20 01 mov 1, %g1
4000e940: 82 10 20 00 clr %g1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
4000e944: c4 0f 20 30 ldub [ %i4 + 0x30 ], %g2
4000e948: b2 10 20 00 clr %i1
4000e94c: 80 a0 a0 00 cmp %g2, 0
4000e950: 02 80 00 13 be 4000e99c <rtems_bdbuf_swapout_task+0x284>
4000e954: 82 08 60 ff and %g1, 0xff, %g1
4000e958: 80 a0 60 00 cmp %g1, 0
4000e95c: 12 bf ff bc bne 4000e84c <rtems_bdbuf_swapout_task+0x134>
4000e960: 01 00 00 00 nop
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
4000e964: 7f ff fa d1 call 4000d4a8 <rtems_bdbuf_lock_cache>
4000e968: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
4000e96c: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
4000e970: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
4000e974: 7f ff fa e2 call 4000d4fc <rtems_bdbuf_unlock_cache>
4000e978: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
4000e97c: 80 a7 60 00 cmp %i5, 0
4000e980: 22 80 00 23 be,a 4000ea0c <rtems_bdbuf_swapout_task+0x2f4><== NEVER TAKEN
4000e984: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
4000e988: 90 10 00 1d mov %i5, %o0
4000e98c: 7f ff eb 28 call 4000962c <rtems_event_system_send>
4000e990: 13 20 00 00 sethi %hi(0x80000000), %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4000e994: 10 80 00 1e b 4000ea0c <rtems_bdbuf_swapout_task+0x2f4>
4000e998: 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,
4000e99c: 80 a0 60 00 cmp %g1, 0
4000e9a0: 02 80 00 1b be 4000ea0c <rtems_bdbuf_swapout_task+0x2f4>
4000e9a4: 90 10 20 04 mov 4, %o0
4000e9a8: 30 bf ff a9 b,a 4000e84c <rtems_bdbuf_swapout_task+0x134>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000e9ac: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000e9b0: 80 a0 60 00 cmp %g1, 0
4000e9b4: 12 bf ff a6 bne 4000e84c <rtems_bdbuf_swapout_task+0x134> <== ALWAYS TAKEN
4000e9b8: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
4000e9bc: 7f ff fa bb call 4000d4a8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000e9c0: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000e9c4: 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))
4000e9c8: 10 80 00 06 b 4000e9e0 <rtems_bdbuf_swapout_task+0x2c8> <== NOT EXECUTED
4000e9cc: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
4000e9d0: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4000e9d4: 7f ff e9 73 call 40008fa0 <rtems_event_send> <== NOT EXECUTED
4000e9d8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000e9dc: 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))
4000e9e0: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000e9e4: 32 bf ff fb bne,a 4000e9d0 <rtems_bdbuf_swapout_task+0x2b8><== NOT EXECUTED
4000e9e8: 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 ();
4000e9ec: 7f ff fa c4 call 4000d4fc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000e9f0: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
4000e9f4: 7f ff d9 ed call 400051a8 <free> <== NOT EXECUTED
4000e9f8: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000e9fc: 7f ff eb 6b call 400097a8 <rtems_task_delete> <== NOT EXECUTED
4000ea00: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000ea04: 81 c7 e0 08 ret <== NOT EXECUTED
4000ea08: 81 e8 00 00 restore <== NOT EXECUTED
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4000ea0c: 92 10 20 00 clr %o1
4000ea10: 94 10 00 10 mov %l0, %o2
4000ea14: 7f ff e9 01 call 40008e18 <rtems_event_receive>
4000ea18: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4000ea1c: 80 a2 20 06 cmp %o0, 6
4000ea20: 22 bf ff e4 be,a 4000e9b0 <rtems_bdbuf_swapout_task+0x298>
4000ea24: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000ea28: 80 a2 20 00 cmp %o0, 0
4000ea2c: 22 bf ff e1 be,a 4000e9b0 <rtems_bdbuf_swapout_task+0x298><== ALWAYS TAKEN
4000ea30: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000ea34: 10 bf ff 7a b 4000e81c <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
4000ea38: 90 10 20 18 mov 0x18, %o0 <== NOT EXECUTED
4000ea3c <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)
{
4000ea3c: 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;
4000ea40: 3b 10 00 6d sethi %hi(0x4001b400), %i5 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
4000ea44: b8 06 20 10 add %i0, 0x10, %i4 <== NOT EXECUTED
4000ea48: ba 17 60 2c or %i5, 0x2c, %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 );
4000ea4c: 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)
4000ea50: 10 80 00 12 b 4000ea98 <rtems_bdbuf_swapout_worker_task+0x5c><== NOT EXECUTED
4000ea54: b4 07 60 0c add %i5, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4000ea58: 7f ff fb 00 call 4000d658 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
4000ea5c: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4000ea60: 7f ff fe d6 call 4000e5b8 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
4000ea64: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4000ea68: 7f ff fa 90 call 4000d4a8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000ea6c: 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;
4000ea70: 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;
4000ea74: f6 26 20 10 st %i3, [ %i0 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000ea78: 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;
4000ea7c: f4 26 00 00 st %i2, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
4000ea80: 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;
4000ea84: c0 26 20 14 clr [ %i0 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
4000ea88: 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;
4000ea8c: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4000ea90: 7f ff fa 9b call 4000d4fc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000ea94: 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)
4000ea98: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
4000ea9c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000eaa0: 12 bf ff ee bne 4000ea58 <rtems_bdbuf_swapout_worker_task+0x1c><== NOT EXECUTED
4000eaa4: 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);
4000eaa8: 7f ff d9 c0 call 400051a8 <free> <== NOT EXECUTED
4000eaac: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
free (worker);
4000eab0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000eab4: 7f ff d9 bd call 400051a8 <free> <== NOT EXECUTED
4000eab8: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000eabc: 7f ff eb 3b call 400097a8 <rtems_task_delete> <== NOT EXECUTED
4000eac0: 81 e8 00 00 restore <== NOT EXECUTED
4000e5b8 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
4000e5b8: 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))
4000e5bc: 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 );
4000e5c0: b6 06 20 04 add %i0, 4, %i3
4000e5c4: 80 a0 40 1b cmp %g1, %i3
4000e5c8: 02 80 00 52 be 4000e710 <rtems_bdbuf_swapout_write+0x158> <== NEVER TAKEN
4000e5cc: 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;
4000e5d0: 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;
4000e5d4: 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;
4000e5d8: f4 07 60 2c ld [ %i5 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000e5dc: 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;
4000e5e0: 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;
4000e5e4: 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;
4000e5e8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
4000e5ec: 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;
4000e5f0: 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;
4000e5f4: 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)
4000e5f8: 10 80 00 35 b 4000e6cc <rtems_bdbuf_swapout_write+0x114>
4000e5fc: 23 10 00 66 sethi %hi(0x40019800), %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 &&
4000e600: 02 80 00 12 be 4000e648 <rtems_bdbuf_swapout_write+0x90>
4000e604: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000e608: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000e60c: 80 a0 a0 00 cmp %g2, 0
4000e610: 22 80 00 0f be,a 4000e64c <rtems_bdbuf_swapout_write+0x94>
4000e614: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
4000e618: c6 02 20 18 ld [ %o0 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
4000e61c: 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 &&
4000e620: 80 a0 c0 02 cmp %g3, %g2
4000e624: 22 80 00 0a be,a 4000e64c <rtems_bdbuf_swapout_write+0x94>
4000e628: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000e62c: c2 06 00 00 ld [ %i0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000e630: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000e634: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
4000e638: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
4000e63c: 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;
4000e640: 10 80 00 10 b 4000e680 <rtems_bdbuf_swapout_write+0xc8>
4000e644: 82 10 20 01 mov 1, %g1
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000e648: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000e64c: 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];
4000e650: 87 29 20 04 sll %g4, 4, %g3
transfer->write_req->bufnum++;
4000e654: 88 01 20 01 inc %g4
4000e658: 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];
4000e65c: 86 00 e0 18 add %g3, 0x18, %g3
4000e660: 84 00 40 03 add %g1, %g3, %g2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000e664: f8 20 40 03 st %i4, [ %g1 + %g3 ]
buf->length = dd->block_size;
4000e668: 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;
4000e66c: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
4000e670: c2 20 a0 04 st %g1, [ %g2 + 4 ]
buf->buffer = bd->buffer;
4000e674: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000e678: 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;
4000e67c: 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) ||
4000e680: c4 06 00 00 ld [ %i0 ], %g2
4000e684: 80 a0 80 1b cmp %g2, %i3
4000e688: 02 80 00 0b be 4000e6b4 <rtems_bdbuf_swapout_write+0xfc>
4000e68c: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
4000e690: 84 14 62 68 or %l1, 0x268, %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) ||
4000e694: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
4000e698: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000e69c: 80 a0 c0 02 cmp %g3, %g2
4000e6a0: 1a 80 00 06 bcc 4000e6b8 <rtems_bdbuf_swapout_write+0x100>
4000e6a4: 90 10 00 1d mov %i5, %o0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
4000e6a8: 80 88 60 ff btst 0xff, %g1
4000e6ac: 02 80 00 08 be 4000e6cc <rtems_bdbuf_swapout_write+0x114>
4000e6b0: 01 00 00 00 nop
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4000e6b4: 90 10 00 1d mov %i5, %o0
4000e6b8: 7f ff ff 54 call 4000e408 <rtems_bdbuf_execute_transfer_request>
4000e6bc: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000e6c0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000e6c4: e0 20 60 0c st %l0, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
4000e6c8: 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 );
4000e6cc: 7f ff fb 52 call 4000d414 <_Chain_Get_unprotected>
4000e6d0: 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)
4000e6d4: 80 a2 20 00 cmp %o0, 0
4000e6d8: 12 bf ff ca bne 4000e600 <rtems_bdbuf_swapout_write+0x48>
4000e6dc: 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 &&
4000e6e0: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
4000e6e4: 80 a0 60 00 cmp %g1, 0
4000e6e8: 02 80 00 0a be 4000e710 <rtems_bdbuf_swapout_write+0x158>
4000e6ec: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
4000e6f0: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000e6f4: 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 &&
4000e6f8: 80 88 60 02 btst 2, %g1
4000e6fc: 02 80 00 05 be 4000e710 <rtems_bdbuf_swapout_write+0x158> <== ALWAYS TAKEN
4000e700: 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);
4000e704: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
4000e708: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000e70c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000e710: 81 c7 e0 08 ret
4000e714: 81 e8 00 00 restore
4000d69c <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4000d69c: 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)));
4000d6a0: 03 10 00 66 sethi %hi(0x40019800), %g1
4000d6a4: d0 00 62 6c ld [ %g1 + 0x26c ], %o0 ! 40019a6c <rtems_bdbuf_configuration+0x4>
4000d6a8: 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 =
4000d6ac: 7f ff e0 00 call 400056ac <malloc>
4000d6b0: 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)
4000d6b4: b0 92 20 00 orcc %o0, 0, %i0
4000d6b8: 12 80 00 04 bne 4000d6c8 <rtems_bdbuf_swapout_writereq_alloc+0x2c><== ALWAYS TAKEN
4000d6bc: 82 10 20 01 mov 1, %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
4000d6c0: 7f ff ff 69 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d6c4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
4000d6c8: c2 26 00 00 st %g1, [ %i0 ]
write_req->done = rtems_bdbuf_transfer_done;
4000d6cc: 03 10 00 38 sethi %hi(0x4000e000), %g1
4000d6d0: 82 10 63 f0 or %g1, 0x3f0, %g1 ! 4000e3f0 <rtems_bdbuf_transfer_done>
write_req->io_task = rtems_task_self ();
4000d6d4: 40 00 11 41 call 40011bd8 <rtems_task_self>
4000d6d8: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000d6dc: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return write_req;
}
4000d6e0: 81 c7 e0 08 ret
4000d6e4: 81 e8 00 00 restore
4000f5a4 <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
4000f5a4: 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)
4000f5a8: 80 a6 20 00 cmp %i0, 0
4000f5ac: 02 80 00 49 be 4000f6d0 <rtems_bdbuf_sync+0x12c> <== NEVER TAKEN
4000f5b0: 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();
4000f5b4: 7f ff f7 bd call 4000d4a8 <rtems_bdbuf_lock_cache>
4000f5b8: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4000f5bc: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000f5c0: 80 a2 20 03 cmp %o0, 3
4000f5c4: 0a 80 00 3d bcs 4000f6b8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000f5c8: 92 10 20 11 mov 0x11, %o1
4000f5cc: 80 a2 20 05 cmp %o0, 5
4000f5d0: 08 80 00 06 bleu 4000f5e8 <rtems_bdbuf_sync+0x44>
4000f5d4: 82 10 20 08 mov 8, %g1
4000f5d8: 80 a2 20 06 cmp %o0, 6
4000f5dc: 12 80 00 37 bne 4000f6b8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000f5e0: 01 00 00 00 nop
4000f5e4: 30 80 00 32 b,a 4000f6ac <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;
4000f5e8: 11 10 00 6d sethi %hi(0x4001b400), %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f5ec: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
4000f5f0: 90 12 20 2c or %o0, 0x2c, %o0
4000f5f4: c2 02 20 60 ld [ %o0 + 0x60 ], %g1
the_node->next = tail;
4000f5f8: 84 02 20 5c add %o0, 0x5c, %g2
tail->previous = the_node;
4000f5fc: 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;
4000f600: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
4000f604: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
4000f608: 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)
4000f60c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000f610: 80 a0 60 00 cmp %g1, 0
4000f614: 02 80 00 04 be 4000f624 <rtems_bdbuf_sync+0x80>
4000f618: 01 00 00 00 nop
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000f61c: 7f ff f8 4c call 4000d74c <rtems_bdbuf_wake>
4000f620: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake_swapper ();
4000f624: 7f ff f7 bc call 4000d514 <rtems_bdbuf_wake_swapper>
4000f628: 3b 10 00 6d sethi %hi(0x4001b400), %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);
4000f62c: ba 17 60 98 or %i5, 0x98, %i5 ! 4001b498 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000f630: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000f634: 80 a2 20 01 cmp %o0, 1
4000f638: 0a 80 00 20 bcs 4000f6b8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000f63c: 92 10 20 15 mov 0x15, %o1
4000f640: 80 a2 20 07 cmp %o0, 7
4000f644: 28 80 00 0a bleu,a 4000f66c <rtems_bdbuf_sync+0xc8>
4000f648: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000f64c: 80 a2 20 0a cmp %o0, 0xa
4000f650: 18 80 00 1a bgu 4000f6b8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
4000f654: 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);
4000f658: 90 10 00 18 mov %i0, %o0
4000f65c: 7f ff f7 f2 call 4000d624 <rtems_bdbuf_wait>
4000f660: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000f664: 10 bf ff f4 b 4000f634 <rtems_bdbuf_sync+0x90>
4000f668: 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
4000f66c: 80 a0 60 00 cmp %g1, 0
4000f670: 12 80 00 14 bne 4000f6c0 <rtems_bdbuf_sync+0x11c>
4000f674: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
4000f678: 80 a0 60 01 cmp %g1, 1
4000f67c: 18 80 00 11 bgu 4000f6c0 <rtems_bdbuf_sync+0x11c> <== NEVER TAKEN
4000f680: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
4000f684: 32 80 00 07 bne,a 4000f6a0 <rtems_bdbuf_sync+0xfc>
4000f688: 11 10 00 6d sethi %hi(0x4001b400), %o0
{
rtems_bdbuf_remove_from_tree (bd);
4000f68c: 7f ff f8 55 call 4000d7e0 <rtems_bdbuf_remove_from_tree>
4000f690: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
4000f694: 7f ff f9 39 call 4000db78 <rtems_bdbuf_make_free_and_add_to_lru_list>
4000f698: 90 10 00 18 mov %i0, %o0
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000f69c: 11 10 00 6d sethi %hi(0x4001b400), %o0
4000f6a0: 7f ff f8 2b call 4000d74c <rtems_bdbuf_wake>
4000f6a4: 90 12 20 a0 or %o0, 0xa0, %o0 ! 4001b4a0 <bdbuf_cache+0x74>
4000f6a8: 30 80 00 06 b,a 4000f6c0 <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);
4000f6ac: 7f ff fd 96 call 4000ed04 <rtems_bdbuf_discard_buffer_after_access>
4000f6b0: 90 10 00 18 mov %i0, %o0
break;
4000f6b4: 30 80 00 03 b,a 4000f6c0 <rtems_bdbuf_sync+0x11c>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
4000f6b8: 7f ff f7 82 call 4000d4c0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000f6bc: 01 00 00 00 nop <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000f6c0: 7f ff f7 8f call 4000d4fc <rtems_bdbuf_unlock_cache>
4000f6c4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
4000f6c8: 81 c7 e0 08 ret
4000f6cc: 81 e8 00 00 restore
}
4000f6d0: 81 c7 e0 08 ret <== NOT EXECUTED
4000f6d4: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
4000d4d4 <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)
{
4000d4d4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
4000d4d8: 7f ff f0 28 call 40009578 <rtems_semaphore_release>
4000d4dc: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
4000d4e0: 80 a2 20 00 cmp %o0, 0
4000d4e4: 02 80 00 04 be 4000d4f4 <rtems_bdbuf_unlock+0x20> <== ALWAYS TAKEN
4000d4e8: 01 00 00 00 nop
rtems_bdbuf_fatal (fatal_error_code);
4000d4ec: 7f ff ff de call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d4f0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000d4f4: 81 c7 e0 08 ret
4000d4f8: 81 e8 00 00 restore
4000d658 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4000d658: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
4000d65c: 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;
4000d660: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
4000d664: 90 10 00 18 mov %i0, %o0
4000d668: 94 10 20 00 clr %o2
4000d66c: 7f ff ed eb call 40008e18 <rtems_event_receive>
4000d670: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
4000d674: 80 a2 20 00 cmp %o0, 0
4000d678: 12 80 00 05 bne 4000d68c <rtems_bdbuf_wait_for_event+0x34><== NEVER TAKEN
4000d67c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000d680: 80 a0 40 18 cmp %g1, %i0
4000d684: 02 80 00 04 be 4000d694 <rtems_bdbuf_wait_for_event+0x3c> <== ALWAYS TAKEN
4000d688: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
4000d68c: 7f ff ff 76 call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d690: 90 10 20 1c mov 0x1c, %o0 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
4000d694: 81 c7 e0 08 ret
4000d698: 81 e8 00 00 restore
4000db44 <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
4000db44: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
4000db48: 11 20 00 00 sethi %hi(0x80000000), %o0
4000db4c: 92 10 20 00 clr %o1
4000db50: 94 10 20 00 clr %o2
4000db54: 40 00 0f a1 call 400119d8 <rtems_event_system_receive>
4000db58: 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)
4000db5c: 80 a2 20 00 cmp %o0, 0
4000db60: 02 80 00 04 be 4000db70 <rtems_bdbuf_wait_for_transient_event+0x2c><== ALWAYS TAKEN
4000db64: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
4000db68: 7f ff fe 3f call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000db6c: 90 10 20 1d mov 0x1d, %o0 ! 1d <PROM_START+0x1d> <== NOT EXECUTED
4000db70: 81 c7 e0 08 ret
4000db74: 81 e8 00 00 restore
4000d74c <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)
{
4000d74c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
4000d750: c2 06 00 00 ld [ %i0 ], %g1
4000d754: 80 a0 60 00 cmp %g1, 0
4000d758: 02 80 00 09 be 4000d77c <rtems_bdbuf_wake+0x30>
4000d75c: 01 00 00 00 nop
{
sc = rtems_semaphore_flush (waiters->sema);
4000d760: 40 00 10 74 call 40011930 <rtems_semaphore_flush>
4000d764: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4000d768: 80 a2 20 00 cmp %o0, 0
4000d76c: 02 80 00 04 be 4000d77c <rtems_bdbuf_wake+0x30> <== ALWAYS TAKEN
4000d770: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
4000d774: 7f ff ff 3c call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d778: 90 10 20 04 mov 4, %o0 ! 4 <PROM_START+0x4> <== NOT EXECUTED
4000d77c: 81 c7 e0 08 ret
4000d780: 81 e8 00 00 restore
4000d514 <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
4000d514: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4000d518: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000d51c: d0 00 60 2c ld [ %g1 + 0x2c ], %o0 ! 4001b42c <bdbuf_cache>
4000d520: 7f ff ee a0 call 40008fa0 <rtems_event_send>
4000d524: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000d528: 80 a2 20 00 cmp %o0, 0
4000d52c: 02 80 00 04 be 4000d53c <rtems_bdbuf_wake_swapper+0x28> <== ALWAYS TAKEN
4000d530: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
4000d534: 7f ff ff cc call 4000d464 <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d538: 90 10 20 0b mov 0xb, %o0 ! b <PROM_START+0xb> <== NOT EXECUTED
4000d53c: 81 c7 e0 08 ret
4000d540: 81 e8 00 00 restore
40003828 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
40003828: 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;
4000382c: 80 a6 60 00 cmp %i1, 0
40003830: 02 80 00 08 be 40003850 <rtems_bdpart_create+0x28> <== NEVER TAKEN
40003834: 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
40003838: c2 06 40 00 ld [ %i1 ], %g1
4000383c: 80 a0 60 00 cmp %g1, 0
40003840: 12 80 00 05 bne 40003854 <rtems_bdpart_create+0x2c> <== NEVER TAKEN
40003844: a0 10 20 00 clr %l0
&& format->mbr.dos_compatibility;
40003848: 10 80 00 03 b 40003854 <rtems_bdpart_create+0x2c>
4000384c: e0 0e 60 08 ldub [ %i1 + 8 ], %l0
40003850: 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
40003854: a0 0c 20 01 and %l0, 1, %l0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
40003858: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
4000385c: 82 0c 20 ff and %l0, 0xff, %g1
40003860: 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;
40003864: 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 =
40003868: 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) {
4000386c: 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 =
40003870: 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) {
40003874: 02 80 00 70 be 40003a34 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40003878: ba 07 60 3f add %i5, 0x3f, %i5
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
4000387c: 80 a6 a0 00 cmp %i2, 0
40003880: 02 80 00 6d be 40003a34 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40003884: b0 10 20 09 mov 9, %i0
40003888: 80 a6 60 00 cmp %i1, 0
4000388c: 02 80 00 6a be 40003a34 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40003890: 80 a6 e0 00 cmp %i3, 0
40003894: 02 80 00 68 be 40003a34 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40003898: 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);
4000389c: 94 10 20 00 clr %o2
400038a0: 40 00 01 2a call 40003d48 <rtems_bdpart_get_disk_data>
400038a4: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
400038a8: b0 92 20 00 orcc %o0, 0, %i0
400038ac: 12 80 00 62 bne 40003a34 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
400038b0: 82 10 20 00 clr %g1
400038b4: 84 10 20 00 clr %g2
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
400038b8: 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];
400038bc: c6 06 c0 03 ld [ %i3 + %g3 ], %g3
400038c0: a8 00 c0 02 add %g3, %g2, %l4
if (dist_sum < prev_sum) {
400038c4: 80 a5 00 02 cmp %l4, %g2
400038c8: 1a 80 00 04 bcc 400038d8 <rtems_bdpart_create+0xb0> <== ALWAYS TAKEN
400038cc: 80 a0 e0 00 cmp %g3, 0
return RTEMS_INVALID_NUMBER;
400038d0: 81 c7 e0 08 ret <== NOT EXECUTED
400038d4: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
}
if (dist [i] == 0) {
400038d8: 02 bf ff fe be 400038d0 <rtems_bdpart_create+0xa8> <== NEVER TAKEN
400038dc: 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) {
400038e0: 80 a0 40 1c cmp %g1, %i4
400038e4: 12 bf ff f5 bne 400038b8 <rtems_bdpart_create+0x90>
400038e8: 84 10 00 14 mov %l4, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
400038ec: c2 06 40 00 ld [ %i1 ], %g1
400038f0: 80 a0 60 00 cmp %g1, 0
400038f4: 12 80 00 52 bne 40003a3c <rtems_bdpart_create+0x214> <== NEVER TAKEN
400038f8: 80 8c 20 ff btst 0xff, %l0
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
400038fc: 02 80 00 09 be 40003920 <rtems_bdpart_create+0xf8> <== NEVER TAKEN
40003900: 80 a7 20 04 cmp %i4, 4
disk_end -= (disk_end % record_space);
40003904: f2 07 bf fc ld [ %fp + -4 ], %i1
40003908: 92 10 00 1d mov %i5, %o1
4000390c: 40 00 78 e1 call 40021c90 <.urem>
40003910: 90 10 00 19 mov %i1, %o0
40003914: 90 26 40 08 sub %i1, %o0, %o0
40003918: 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) {
4000391c: 80 a7 20 04 cmp %i4, 4
40003920: 08 80 00 06 bleu 40003938 <rtems_bdpart_create+0x110> <== NEVER TAKEN
40003924: b2 10 00 1d mov %i5, %i1
overhead += (count - 3) * record_space;
40003928: 90 10 00 1d mov %i5, %o0
4000392c: 40 00 77 f3 call 400218f8 <.umul>
40003930: 92 07 3f fd add %i4, -3, %o1
40003934: b2 02 00 1d add %o0, %i5, %i1
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
40003938: 80 8c 20 ff btst 0xff, %l0
4000393c: 02 80 00 07 be 40003958 <rtems_bdpart_create+0x130> <== NEVER TAKEN
40003940: e6 07 bf fc ld [ %fp + -4 ], %l3
overhead += (count - 1) * record_space;
40003944: 90 10 00 1d mov %i5, %o0
40003948: 40 00 77 ec call 400218f8 <.umul>
4000394c: 92 07 3f ff add %i4, -1, %o1
40003950: b2 06 40 08 add %i1, %o0, %i1
}
/* Check disk space */
if ((overhead + count) > disk_end) {
40003954: e6 07 bf fc ld [ %fp + -4 ], %l3
40003958: 82 06 40 1c add %i1, %i4, %g1
4000395c: 80 a0 40 13 cmp %g1, %l3
40003960: 38 80 00 35 bgu,a 40003a34 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
40003964: 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;
40003968: aa 24 c0 19 sub %l3, %i1, %l5
4000396c: a2 10 00 1a mov %i2, %l1
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
40003970: a0 10 00 1d mov %i5, %l0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
40003974: b2 10 20 00 clr %i1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
40003978: 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];
4000397c: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
40003980: 92 10 00 15 mov %l5, %o1
40003984: 40 00 77 dd call 400218f8 <.umul>
40003988: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
4000398c: 80 a2 00 15 cmp %o0, %l5
40003990: 0a bf ff d0 bcs 400038d0 <rtems_bdpart_create+0xa8> <== NEVER TAKEN
40003994: 80 a2 00 12 cmp %o0, %l2
40003998: 0a bf ff ce bcs 400038d0 <rtems_bdpart_create+0xa8> <== NEVER TAKEN
4000399c: 01 00 00 00 nop
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
400039a0: 40 00 78 10 call 400219e0 <.udiv>
400039a4: 92 10 00 14 mov %l4, %o1
/* Ensure that the partition is not empty */
if (s == 0) {
400039a8: a4 92 20 00 orcc %o0, 0, %l2
400039ac: 22 80 00 02 be,a 400039b4 <rtems_bdpart_create+0x18c> <== NEVER TAKEN
400039b0: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
400039b4: 90 10 00 12 mov %l2, %o0
400039b8: 40 00 78 b6 call 40021c90 <.urem>
400039bc: 92 10 00 1d mov %i5, %o1
400039c0: a4 04 80 1d add %l2, %i5, %l2
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
400039c4: 82 10 20 01 mov 1, %g1
400039c8: 80 a6 60 02 cmp %i1, 2
400039cc: 18 80 00 03 bgu 400039d8 <rtems_bdpart_create+0x1b0>
400039d0: 90 24 80 08 sub %l2, %o0, %o0
400039d4: 82 10 20 00 clr %g1
400039d8: 80 88 60 ff btst 0xff, %g1
400039dc: 22 80 00 0a be,a 40003a04 <rtems_bdpart_create+0x1dc>
400039e0: e0 24 40 00 st %l0, [ %l1 ]
400039e4: 80 a7 20 04 cmp %i4, 4
400039e8: 18 80 00 03 bgu 400039f4 <rtems_bdpart_create+0x1cc> <== ALWAYS TAKEN
400039ec: 82 10 20 01 mov 1, %g1
400039f0: 82 10 20 00 clr %g1 <== NOT EXECUTED
400039f4: 80 88 60 ff btst 0xff, %g1
400039f8: 32 80 00 02 bne,a 40003a00 <rtems_bdpart_create+0x1d8> <== ALWAYS TAKEN
400039fc: a0 04 00 1d add %l0, %i5, %l0
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
40003a00: e0 24 40 00 st %l0, [ %l1 ]
pos += s;
40003a04: a0 04 00 08 add %l0, %o0, %l0
p->end = pos;
40003a08: 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) {
40003a0c: b2 06 60 01 inc %i1
40003a10: 80 a6 40 1c cmp %i1, %i4
40003a14: 12 bf ff d9 bne 40003978 <rtems_bdpart_create+0x150>
40003a18: 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;
40003a1c: b2 06 7f ff add %i1, -1, %i1
40003a20: 83 2e 60 04 sll %i1, 4, %g1
40003a24: b3 2e 60 06 sll %i1, 6, %i1
40003a28: b2 26 40 01 sub %i1, %g1, %i1
40003a2c: b4 06 80 19 add %i2, %i1, %i2
40003a30: e6 26 a0 04 st %l3, [ %i2 + 4 ]
40003a34: 81 c7 e0 08 ret
40003a38: 81 e8 00 00 restore
40003a3c: b0 10 20 18 mov 0x18, %i0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
40003a40: 81 c7 e0 08 ret <== NOT EXECUTED
40003a44: 81 e8 00 00 restore <== NOT EXECUTED
40003a48 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
40003a48: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
40003a4c: 11 10 00 94 sethi %hi(0x40025000), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003a50: 35 10 00 94 sethi %hi(0x40025000), %i2
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
40003a54: 90 12 20 d8 or %o0, 0xd8, %o0
40003a58: 40 00 48 c6 call 40015d70 <puts>
40003a5c: 27 10 00 94 sethi %hi(0x40025000), %l3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003a60: 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";
40003a64: 37 10 00 94 sethi %hi(0x40025000), %i3
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003a68: b4 16 a2 18 or %i2, 0x218, %i2
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
40003a6c: 21 10 00 94 sethi %hi(0x40025000), %l0
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
40003a70: 23 10 00 94 sethi %hi(0x40025000), %l1
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
40003a74: 25 10 00 94 sethi %hi(0x40025000), %l2
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003a78: 10 80 00 39 b 40003b5c <rtems_bdpart_dump+0x114>
40003a7c: a6 14 e2 20 or %l3, 0x220, %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)) {
40003a80: b8 06 20 08 add %i0, 8, %i4
40003a84: 92 07 bf c7 add %fp, -57, %o1
40003a88: 40 00 00 a4 call 40003d18 <rtems_bdpart_to_mbr_partition_type>
40003a8c: 90 10 00 1c mov %i4, %o0
40003a90: 80 8a 20 ff btst 0xff, %o0
40003a94: 22 80 00 27 be,a 40003b30 <rtems_bdpart_dump+0xe8> <== NEVER TAKEN
40003a98: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
switch (type_mbr) {
40003a9c: d6 0f bf c7 ldub [ %fp + -57 ], %o3
40003aa0: 82 0a e0 ff and %o3, 0xff, %g1
40003aa4: 80 a0 60 0b cmp %g1, 0xb
40003aa8: 22 80 00 27 be,a 40003b44 <rtems_bdpart_dump+0xfc> <== ALWAYS TAKEN
40003aac: 96 16 e0 c0 or %i3, 0xc0, %o3
40003ab0: 18 80 00 09 bgu 40003ad4 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
40003ab4: 80 a0 60 0e cmp %g1, 0xe <== NOT EXECUTED
40003ab8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40003abc: 02 80 00 0e be 40003af4 <rtems_bdpart_dump+0xac> <== NOT EXECUTED
40003ac0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
40003ac4: 12 80 00 15 bne 40003b18 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
40003ac8: 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";
40003acc: 10 80 00 1d b 40003b40 <rtems_bdpart_dump+0xf8> <== NOT EXECUTED
40003ad0: 17 10 00 94 sethi %hi(0x40025000), %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) {
40003ad4: 02 80 00 0b be 40003b00 <rtems_bdpart_dump+0xb8> <== NOT EXECUTED
40003ad8: 80 a0 60 da cmp %g1, 0xda <== NOT EXECUTED
40003adc: 02 80 00 0d be 40003b10 <rtems_bdpart_dump+0xc8> <== NOT EXECUTED
40003ae0: 80 a0 60 0c cmp %g1, 0xc <== NOT EXECUTED
40003ae4: 12 80 00 0d bne 40003b18 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
40003ae8: 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";
40003aec: 10 80 00 07 b 40003b08 <rtems_bdpart_dump+0xc0> <== NOT EXECUTED
40003af0: 96 14 a0 b0 or %l2, 0xb0, %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";
40003af4: 17 10 00 94 sethi %hi(0x40025000), %o3 <== NOT EXECUTED
40003af8: 10 80 00 13 b 40003b44 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40003afc: 96 12 e0 a0 or %o3, 0xa0, %o3 ! 400250a0 <Callbacks.6428+0x140><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
40003b00: 10 80 00 11 b 40003b44 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40003b04: 96 14 20 c8 or %l0, 0xc8, %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;
40003b08: 10 80 00 10 b 40003b48 <rtems_bdpart_dump+0x100> <== NOT EXECUTED
40003b0c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
40003b10: 10 80 00 0d b 40003b44 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40003b14: 96 14 60 a8 or %l1, 0xa8, %o3 <== NOT EXECUTED
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003b18: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
40003b1c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40003b20: 40 00 48 ce call 40015e58 <snprintf> <== NOT EXECUTED
40003b24: 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;
40003b28: 10 80 00 07 b 40003b44 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40003b2c: 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);
40003b30: 40 00 2a 11 call 4000e374 <uuid_unparse_lower> <== NOT EXECUTED
40003b34: 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;
40003b38: 10 80 00 03 b 40003b44 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
40003b3c: 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";
40003b40: 96 12 e0 98 or %o3, 0x98, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40003b44: d2 06 00 00 ld [ %i0 ], %o1
40003b48: d4 06 20 04 ld [ %i0 + 4 ], %o2
40003b4c: 90 10 00 13 mov %l3, %o0
40003b50: 40 00 48 52 call 40015c98 <printf>
40003b54: ba 07 60 01 inc %i5
40003b58: b0 06 20 30 add %i0, 0x30, %i0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003b5c: 80 a7 40 19 cmp %i5, %i1
40003b60: 32 bf ff c8 bne,a 40003a80 <rtems_bdpart_dump+0x38>
40003b64: c0 2f bf c7 clrb [ %fp + -57 ]
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
40003b68: 11 10 00 94 sethi %hi(0x40025000), %o0
40003b6c: 40 00 48 81 call 40015d70 <puts>
40003b70: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 400251c8 <Callbacks.6428+0x268>
40003b74: 81 c7 e0 08 ret
40003b78: 81 e8 00 00 restore
40003d48 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
40003d48: 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);
40003d4c: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
40003d50: 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);
40003d54: 40 00 0c 66 call 40006eec <open>
40003d58: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
40003d5c: ba 92 20 00 orcc %o0, 0, %i5
40003d60: 36 80 00 04 bge,a 40003d70 <rtems_bdpart_get_disk_data+0x28><== ALWAYS TAKEN
40003d64: 13 10 01 10 sethi %hi(0x40044000), %o1
sc = RTEMS_INVALID_NAME;
40003d68: 10 80 00 12 b 40003db0 <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
40003d6c: 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);
40003d70: 94 07 bf fc add %fp, -4, %o2
40003d74: 40 00 09 43 call 40006280 <ioctl>
40003d78: 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) {
40003d7c: 80 a2 20 00 cmp %o0, 0
40003d80: 32 80 00 0c bne,a 40003db0 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
40003d84: 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;
40003d88: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
40003d8c: c4 18 60 18 ldd [ %g1 + 0x18 ], %g2
40003d90: c6 26 c0 00 st %g3, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
40003d94: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40003d98: 80 a0 61 ff cmp %g1, 0x1ff
40003d9c: 08 80 00 05 bleu 40003db0 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
40003da0: 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;
40003da4: 80 a0 00 02 cmp %g0, %g2
40003da8: b0 60 20 00 subx %g0, 0, %i0
40003dac: b0 0e 20 1b and %i0, 0x1b, %i0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
40003db0: 80 a6 20 00 cmp %i0, 0
40003db4: 12 80 00 0a bne 40003ddc <rtems_bdpart_get_disk_data+0x94><== NEVER TAKEN
40003db8: 80 a6 60 00 cmp %i1, 0
40003dbc: 02 80 00 08 be 40003ddc <rtems_bdpart_get_disk_data+0x94>
40003dc0: 80 a6 a0 00 cmp %i2, 0
40003dc4: 02 80 00 06 be 40003ddc <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
40003dc8: c2 07 bf fc ld [ %fp + -4 ], %g1
*fd_ptr = fd;
40003dcc: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
40003dd0: c2 26 80 00 st %g1, [ %i2 ]
40003dd4: 81 c7 e0 08 ret
40003dd8: 81 e8 00 00 restore
} else {
close( fd);
40003ddc: 40 00 08 8b call 40006008 <close>
40003de0: 90 10 00 1d mov %i5, %o0
}
return sc;
}
40003de4: 81 c7 e0 08 ret
40003de8: 81 e8 00 00 restore
40021954 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40021954: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
40021958: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
4002195c: 40 00 76 66 call 4003f2f4 <strrchr> <== NOT EXECUTED
40021960: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021964: 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);
40021968: 40 00 72 40 call 4003e268 <strlen> <== NOT EXECUTED
4002196c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021970: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
40021974: 40 00 72 3d call 4003e268 <strlen> <== NOT EXECUTED
40021978: 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;
4002197c: 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);
40021980: 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);
40021984: 7f ff 89 43 call 40003e90 <malloc> <== NOT EXECUTED
40021988: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
4002198c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021990: 02 80 00 4d be 40021ac4 <rtems_bdpart_mount+0x170> <== NOT EXECUTED
40021994: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
40021998: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4002199c: 40 00 72 ef call 4003e558 <strncpy> <== NOT EXECUTED
400219a0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
400219a4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400219a8: 22 80 00 06 be,a 400219c0 <rtems_bdpart_mount+0x6c> <== NOT EXECUTED
400219ac: a4 10 00 10 mov %l0, %l2 <== NOT EXECUTED
disk_file_name += 1;
400219b0: b0 07 60 01 add %i5, 1, %i0 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
400219b4: 40 00 72 2d call 4003e268 <strlen> <== NOT EXECUTED
400219b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400219bc: 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);
400219c0: a6 04 80 11 add %l2, %l1, %l3 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
400219c4: 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);
400219c8: 7f ff 89 32 call 40003e90 <malloc> <== NOT EXECUTED
400219cc: 90 04 e0 05 add %l3, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
400219d0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400219d4: 02 80 00 38 be 40021ab4 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
400219d8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
400219dc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400219e0: 40 00 72 de call 4003e558 <strncpy> <== NOT EXECUTED
400219e4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
400219e8: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400219ec: 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] = '/';
400219f0: c2 2f 40 11 stb %g1, [ %i5 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400219f4: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED
400219f8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
400219fc: 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;
40021a00: 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);
40021a04: 37 10 01 71 sethi %hi(0x4005c400), %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);
40021a08: 40 00 72 d4 call 4003e558 <strncpy> <== NOT EXECUTED
40021a0c: 31 10 01 69 sethi %hi(0x4005a400), %i0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
40021a10: a0 06 40 10 add %i1, %l0, %l0 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40021a14: a6 07 40 13 add %i5, %l3, %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40021a18: 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);
40021a1c: b6 16 e0 28 or %i3, 0x28, %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) {
40021a20: 10 80 00 1d b 40021a94 <rtems_bdpart_mount+0x140> <== NOT EXECUTED
40021a24: b0 16 21 40 or %i0, 0x140, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021a28: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40021a2c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021a30: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40021a34: 40 00 6e 6f call 4003d3f0 <snprintf> <== NOT EXECUTED
40021a38: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40021a3c: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
40021a40: 14 80 00 1a bg 40021aa8 <rtems_bdpart_mount+0x154> <== NOT EXECUTED
40021a44: 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);
40021a48: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
40021a4c: 40 00 72 c3 call 4003e558 <strncpy> <== NOT EXECUTED
40021a50: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
40021a54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021a58: 40 00 0f 07 call 40025674 <rtems_mkdir> <== NOT EXECUTED
40021a5c: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
40021a60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021a64: 12 80 00 13 bne 40021ab0 <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
40021a68: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
40021a6c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40021a70: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40021a74: 96 10 20 00 clr %o3 <== NOT EXECUTED
40021a78: 7f ff 89 8d call 400040ac <mount> <== NOT EXECUTED
40021a7c: 98 10 20 00 clr %o4 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
40021a80: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021a84: 02 80 00 05 be 40021a98 <rtems_bdpart_mount+0x144> <== NOT EXECUTED
40021a88: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
rmdir( mount_point);
40021a8c: 40 00 0e d2 call 400255d4 <rmdir> <== NOT EXECUTED
40021a90: 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) {
40021a94: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
40021a98: 32 bf ff e4 bne,a 40021a28 <rtems_bdpart_mount+0xd4> <== NOT EXECUTED
40021a9c: 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;
40021aa0: 10 80 00 05 b 40021ab4 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
40021aa4: 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;
40021aa8: 10 80 00 03 b 40021ab4 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
40021aac: 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;
40021ab0: b8 10 20 1b mov 0x1b, %i4 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
40021ab4: 7f ff 88 23 call 40003b40 <free> <== NOT EXECUTED
40021ab8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
40021abc: 7f ff 88 21 call 40003b40 <free> <== NOT EXECUTED
40021ac0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
40021ac4: 81 c7 e0 08 ret <== NOT EXECUTED
40021ac8: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
40004228 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
40004228: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
4000422c: d0 06 80 00 ld [ %i2 ], %o0
40004230: 80 a2 20 00 cmp %o0, 0
40004234: 12 80 00 0b bne 40004260 <rtems_bdpart_new_record+0x38>
40004238: 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);
4000423c: 90 10 00 18 mov %i0, %o0
40004240: 92 10 00 19 mov %i1, %o1
40004244: 40 00 30 11 call 40010288 <rtems_bdbuf_read>
40004248: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
4000424c: ba 92 20 00 orcc %o0, 0, %i5
40004250: 22 80 00 0b be,a 4000427c <rtems_bdpart_new_record+0x54> <== ALWAYS TAKEN
40004254: 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;
}
40004258: 81 c7 e0 08 ret <== NOT EXECUTED
4000425c: 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);
40004260: 40 00 30 d8 call 400105c0 <rtems_bdbuf_sync>
40004264: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40004268: ba 92 20 00 orcc %o0, 0, %i5
4000426c: 02 bf ff f5 be 40004240 <rtems_bdpart_new_record+0x18> <== ALWAYS TAKEN
40004270: 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;
}
40004274: 81 c7 e0 08 ret <== NOT EXECUTED
40004278: 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 ) {
4000427c: 80 a0 60 00 cmp %g1, 0
40004280: 02 80 00 0e be 400042b8 <rtems_bdpart_new_record+0x90> <== NEVER TAKEN
40004284: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
40004288: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4000428c: 40 00 46 30 call 40015b4c <memset>
40004290: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
40004294: c2 06 80 00 ld [ %i2 ], %g1
40004298: 84 10 20 55 mov 0x55, %g2
4000429c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400042a0: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
400042a4: c2 06 80 00 ld [ %i2 ], %g1
400042a8: 84 10 3f aa mov -86, %g2
400042ac: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400042b0: 10 80 00 03 b 400042bc <rtems_bdpart_new_record+0x94>
400042b4: 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;
400042b8: 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;
}
400042bc: b0 10 00 1d mov %i5, %i0
400042c0: 81 c7 e0 08 ret
400042c4: 81 e8 00 00 restore
40003dec <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
40003dec: 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;
40003df0: 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;
40003df4: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
40003df8: c2 27 bf ec st %g1, [ %fp + -20 ]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40003dfc: 80 a6 e0 00 cmp %i3, 0
40003e00: 02 80 00 07 be 40003e1c <rtems_bdpart_read+0x30> <== NEVER TAKEN
40003e04: 90 10 00 18 mov %i0, %o0
40003e08: c2 06 c0 00 ld [ %i3 ], %g1
40003e0c: 85 28 60 04 sll %g1, 4, %g2
40003e10: b9 28 60 06 sll %g1, 6, %i4
40003e14: 10 80 00 03 b 40003e20 <rtems_bdpart_read+0x34>
40003e18: b8 27 00 02 sub %i4, %g2, %i4
40003e1c: 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;
40003e20: 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 */
40003e24: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
40003e28: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
40003e2c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
40003e30: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
40003e34: 80 a6 a0 00 cmp %i2, 0
40003e38: 02 80 00 89 be 4000405c <rtems_bdpart_read+0x270> <== NEVER TAKEN
40003e3c: b0 10 20 09 mov 9, %i0
40003e40: 80 a6 60 00 cmp %i1, 0
40003e44: 02 80 00 86 be 4000405c <rtems_bdpart_read+0x270> <== NEVER TAKEN
40003e48: 80 a6 e0 00 cmp %i3, 0
40003e4c: 02 80 00 84 be 4000405c <rtems_bdpart_read+0x270> <== NEVER TAKEN
40003e50: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
40003e54: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40003e58: 94 07 bf fc add %fp, -4, %o2
40003e5c: 7f ff ff bb call 40003d48 <rtems_bdpart_get_disk_data>
40003e60: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003e64: b0 92 20 00 orcc %o0, 0, %i0
40003e68: 12 80 00 7d bne 4000405c <rtems_bdpart_read+0x270> <== NEVER TAKEN
40003e6c: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
40003e70: 92 10 20 00 clr %o1
40003e74: 7f ff ff 4d call 40003ba8 <rtems_bdpart_read_record>
40003e78: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40003e7c: b0 92 20 00 orcc %o0, 0, %i0
40003e80: 12 80 00 6c bne 40004030 <rtems_bdpart_read+0x244> <== NEVER TAKEN
40003e84: 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;
40003e88: 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);
40003e8c: 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;
40003e90: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40003e94: 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;
40003e98: ba 04 a1 be add %l2, 0x1be, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40003e9c: a0 07 bf f0 add %fp, -16, %l0
40003ea0: 90 10 00 1d mov %i5, %o0
40003ea4: 92 10 00 11 mov %l1, %o1
40003ea8: 94 10 00 1c mov %i4, %o2
40003eac: 7f ff ff 70 call 40003c6c <rtems_bdpart_read_mbr_partition>
40003eb0: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003eb4: b0 92 20 00 orcc %o0, 0, %i0
40003eb8: 32 80 00 5e bne,a 40004030 <rtems_bdpart_read+0x244> <== NEVER TAKEN
40003ebc: 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) {
40003ec0: c2 07 bf ec ld [ %fp + -20 ], %g1
40003ec4: c2 08 60 08 ldub [ %g1 + 8 ], %g1
40003ec8: 80 a0 60 ee cmp %g1, 0xee
40003ecc: 02 80 00 58 be 4000402c <rtems_bdpart_read+0x240> <== NEVER TAKEN
40003ed0: 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
40003ed4: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
40003ed8: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
40003edc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
40003ee0: 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(
40003ee4: 7f ff ff 26 call 40003b7c <rtems_uint32_from_little_endian>
40003ee8: 90 02 21 b8 add %o0, 0x1b8, %o0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40003eec: 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(
40003ef0: d0 26 60 04 st %o0, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40003ef4: 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;
40003ef8: ba 07 60 10 add %i5, 0x10, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40003efc: 92 10 00 11 mov %l1, %o1
40003f00: 90 10 00 1d mov %i5, %o0
40003f04: 94 10 00 1c mov %i4, %o2
40003f08: 7f ff ff 59 call 40003c6c <rtems_bdpart_read_mbr_partition>
40003f0c: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003f10: 80 a2 20 00 cmp %o0, 0
40003f14: 12 80 00 45 bne 40004028 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
40003f18: 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) {
40003f1c: 32 bf ff f8 bne,a 40003efc <rtems_bdpart_read+0x110>
40003f20: ba 07 60 10 add %i5, 0x10, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
40003f24: 10 80 00 2e b 40003fdc <rtems_bdpart_read+0x1f0>
40003f28: fa 07 bf f0 ld [ %fp + -16 ], %i5
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
40003f2c: 92 10 00 1d mov %i5, %o1
40003f30: 7f ff ff 1e call 40003ba8 <rtems_bdpart_read_record>
40003f34: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40003f38: 80 a2 20 00 cmp %o0, 0
40003f3c: 12 80 00 3b bne 40004028 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
40003f40: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
40003f44: 92 10 00 11 mov %l1, %o1
40003f48: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40003f4c: 94 10 00 1c mov %i4, %o2
40003f50: 90 02 21 be add %o0, 0x1be, %o0
40003f54: 7f ff ff 46 call 40003c6c <rtems_bdpart_read_mbr_partition>
40003f58: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
40003f5c: 80 a2 20 00 cmp %o0, 0
40003f60: 12 80 00 32 bne 40004028 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
40003f64: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
40003f68: c6 00 40 00 ld [ %g1 ], %g3
40003f6c: 84 07 40 03 add %i5, %g3, %g2
if (tmp > p->begin) {
40003f70: 80 a0 80 03 cmp %g2, %g3
40003f74: 38 80 00 04 bgu,a 40003f84 <rtems_bdpart_read+0x198> <== ALWAYS TAKEN
40003f78: c4 20 40 00 st %g2, [ %g1 ]
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
40003f7c: 10 80 00 2c b 4000402c <rtems_bdpart_read+0x240> <== NOT EXECUTED
40003f80: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
40003f84: c4 00 60 04 ld [ %g1 + 4 ], %g2
40003f88: ba 07 40 02 add %i5, %g2, %i5
if (tmp > p->end) {
40003f8c: 80 a7 40 02 cmp %i5, %g2
40003f90: 08 80 00 27 bleu 4000402c <rtems_bdpart_read+0x240> <== NEVER TAKEN
40003f94: b0 10 20 1b mov 0x1b, %i0
p->end = tmp;
40003f98: 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
40003f9c: c2 07 bf e8 ld [ %fp + -24 ], %g1
40003fa0: 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 =
40003fa4: 7f ff fe f6 call 40003b7c <rtems_uint32_from_little_endian>
40003fa8: 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) {
40003fac: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
40003fb0: 80 a0 60 05 cmp %g1, 5
40003fb4: 12 80 00 0e bne 40003fec <rtems_bdpart_read+0x200>
40003fb8: 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) {
40003fbc: 80 a2 20 00 cmp %o0, 0
40003fc0: 02 80 00 0a be 40003fe8 <rtems_bdpart_read+0x1fc> <== NEVER TAKEN
40003fc4: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
40003fc8: 82 02 00 01 add %o0, %g1, %g1
if (tmp > ebr) {
40003fcc: 80 a0 40 08 cmp %g1, %o0
40003fd0: 08 80 00 17 bleu 4000402c <rtems_bdpart_read+0x240> <== NEVER TAKEN
40003fd4: b0 10 20 1b mov 0x1b, %i0
40003fd8: ba 10 00 01 mov %g1, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
40003fdc: 80 a7 60 00 cmp %i5, 0
40003fe0: 12 bf ff d3 bne 40003f2c <rtems_bdpart_read+0x140> <== ALWAYS TAKEN
40003fe4: d0 07 bf fc ld [ %fp + -4 ], %o0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40003fe8: 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;
40003fec: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40003ff0: b4 20 40 1a sub %g1, %i2, %i2
40003ff4: b5 3e a0 04 sra %i2, 4, %i2
40003ff8: 83 2e a0 02 sll %i2, 2, %g1
40003ffc: 82 00 40 1a add %g1, %i2, %g1
40004000: 85 28 60 04 sll %g1, 4, %g2
40004004: 82 00 40 02 add %g1, %g2, %g1
40004008: 85 28 60 08 sll %g1, 8, %g2
4000400c: 82 00 40 02 add %g1, %g2, %g1
40004010: 85 28 60 10 sll %g1, 0x10, %g2
40004014: 82 00 40 02 add %g1, %g2, %g1
40004018: 82 20 00 01 neg %g1
4000401c: 82 00 60 01 inc %g1
40004020: 10 80 00 03 b 4000402c <rtems_bdpart_read+0x240>
40004024: c2 26 c0 00 st %g1, [ %i3 ]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
40004028: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
4000402c: d0 07 bf f8 ld [ %fp + -8 ], %o0
40004030: 80 a2 20 00 cmp %o0, 0
40004034: 26 80 00 05 bl,a 40004048 <rtems_bdpart_read+0x25c> <== NEVER TAKEN
40004038: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
4000403c: 40 00 07 f3 call 40006008 <close>
40004040: 01 00 00 00 nop
}
if (block != NULL) {
40004044: d0 07 bf e8 ld [ %fp + -24 ], %o0
40004048: 80 a2 20 00 cmp %o0, 0
4000404c: 02 80 00 06 be 40004064 <rtems_bdpart_read+0x278> <== NEVER TAKEN
40004050: 01 00 00 00 nop
rtems_bdbuf_release( block);
40004054: 40 00 31 09 call 40010478 <rtems_bdbuf_release>
40004058: 01 00 00 00 nop
4000405c: 81 c7 e0 08 ret
40004060: 81 e8 00 00 restore
}
return esc;
}
40004064: 81 c7 e0 08 ret <== NOT EXECUTED
40004068: 81 e8 00 00 restore <== NOT EXECUTED
40003c6c <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
40003c6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_blkdev_bnum begin =
40003c70: 7f ff ff c3 call 40003b7c <rtems_uint32_from_little_endian>
40003c74: 90 06 20 08 add %i0, 8, %o0
40003c78: ba 10 00 08 mov %o0, %i5
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
40003c7c: 7f ff ff c0 call 40003b7c <rtems_uint32_from_little_endian>
40003c80: 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) {
40003c84: f8 0e 20 04 ldub [ %i0 + 4 ], %i4
40003c88: 80 a7 20 00 cmp %i4, 0
40003c8c: 02 80 00 21 be 40003d10 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
40003c90: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
40003c94: c4 06 40 00 ld [ %i1 ], %g2
40003c98: 80 a0 80 1a cmp %g2, %i2
40003c9c: 02 80 00 1d be 40003d10 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
40003ca0: 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;
40003ca4: 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) {
40003ca8: 80 a7 40 1a cmp %i5, %i2
40003cac: 1a 80 00 19 bcc 40003d10 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
40003cb0: 82 10 20 1b mov 0x1b, %g1
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
40003cb4: 80 a7 20 05 cmp %i4, 5
40003cb8: 32 80 00 07 bne,a 40003cd4 <rtems_bdpart_read_mbr_partition+0x68>
40003cbc: 90 00 a0 30 add %g2, 0x30, %o0
if (ep_begin != NULL) {
40003cc0: 80 a6 e0 00 cmp %i3, 0
40003cc4: 32 80 00 12 bne,a 40003d0c <rtems_bdpart_read_mbr_partition+0xa0><== ALWAYS TAKEN
40003cc8: 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;
40003ccc: 10 80 00 11 b 40003d10 <rtems_bdpart_read_mbr_partition+0xa4><== NOT EXECUTED
40003cd0: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
40003cd4: 92 10 20 00 clr %o1
40003cd8: 94 10 20 30 mov 0x30, %o2
40003cdc: 40 00 47 9c call 40015b4c <memset>
40003ce0: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
40003ce4: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
40003ce8: 90 10 00 1c mov %i4, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
40003cec: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
40003cf0: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
40003cf4: 7f ff ff d6 call 40003c4c <rtems_bdpart_to_partition_type>
40003cf8: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
40003cfc: c2 06 40 00 ld [ %i1 ], %g1
40003d00: c4 0e 00 00 ldub [ %i0 ], %g2
40003d04: c0 20 60 28 clr [ %g1 + 0x28 ]
40003d08: 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;
40003d0c: 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;
}
40003d10: 81 c7 e0 08 ret
40003d14: 91 e8 00 01 restore %g0, %g1, %o0
40003ba8 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
40003ba8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
40003bac: d0 06 80 00 ld [ %i2 ], %o0
40003bb0: 80 a2 20 00 cmp %o0, 0
40003bb4: 12 80 00 0b bne 40003be0 <rtems_bdpart_read_record+0x38>
40003bb8: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
40003bbc: 90 10 00 18 mov %i0, %o0
40003bc0: 92 10 00 19 mov %i1, %o1
40003bc4: 40 00 31 b1 call 40010288 <rtems_bdbuf_read>
40003bc8: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
40003bcc: 80 a2 20 00 cmp %o0, 0
40003bd0: 22 80 00 0b be,a 40003bfc <rtems_bdpart_read_record+0x54><== ALWAYS TAKEN
40003bd4: c2 06 80 00 ld [ %i2 ], %g1
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40003bd8: 81 c7 e0 08 ret <== NOT EXECUTED
40003bdc: 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);
40003be0: 40 00 32 26 call 40010478 <rtems_bdbuf_release>
40003be4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40003be8: 80 a2 20 00 cmp %o0, 0
40003bec: 22 bf ff f5 be,a 40003bc0 <rtems_bdpart_read_record+0x18><== ALWAYS TAKEN
40003bf0: 90 10 00 18 mov %i0, %o0
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40003bf4: 81 c7 e0 08 ret <== NOT EXECUTED
40003bf8: 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 ) {
40003bfc: 80 a0 60 00 cmp %g1, 0
40003c00: 22 80 00 10 be,a 40003c40 <rtems_bdpart_read_record+0x98><== NEVER TAKEN
40003c04: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
40003c08: 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]
40003c0c: c6 08 a1 fe ldub [ %g2 + 0x1fe ], %g3
40003c10: 80 a0 e0 55 cmp %g3, 0x55
40003c14: 12 80 00 06 bne 40003c2c <rtems_bdpart_read_record+0x84> <== NEVER TAKEN
40003c18: 82 10 20 00 clr %g1
40003c1c: c2 08 a1 ff ldub [ %g2 + 0x1ff ], %g1
40003c20: 82 18 60 aa xor %g1, 0xaa, %g1
40003c24: 80 a0 00 01 cmp %g0, %g1
40003c28: 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)) {
40003c2c: 80 a0 60 00 cmp %g1, 0
40003c30: 22 80 00 04 be,a 40003c40 <rtems_bdpart_read_record+0x98><== NEVER TAKEN
40003c34: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40003c38: 81 c7 e0 08 ret
40003c3c: 91 e8 00 08 restore %g0, %o0, %o0
40003c40: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
40003c44: 81 c7 e0 08 ret <== NOT EXECUTED
40003c48: 81 e8 00 00 restore <== NOT EXECUTED
4000406c <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
4000406c: 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);
40004070: 90 10 00 18 mov %i0, %o0
40004074: 40 00 48 8a call 4001629c <strlen>
40004078: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
4000407c: 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
)
{
40004080: 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);
40004084: a0 10 00 08 mov %o0, %l0
size_t i = 0;
int fd = -1;
40004088: 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);
4000408c: 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;
40004090: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40004094: 92 07 bf f8 add %fp, -8, %o1
40004098: 94 07 bf fc add %fp, -4, %o2
4000409c: 7f ff ff 2b call 40003d48 <rtems_bdpart_get_disk_data>
400040a0: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
400040a4: b0 92 20 00 orcc %o0, 0, %i0
400040a8: 12 80 00 31 bne 4000416c <rtems_bdpart_register+0x100> <== NEVER TAKEN
400040ac: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
400040b0: 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;
400040b4: e2 00 40 00 ld [ %g1 ], %l1
400040b8: 40 00 07 d4 call 40006008 <close>
400040bc: 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);
400040c0: 90 04 20 04 add %l0, 4, %o0
400040c4: 40 00 09 83 call 400066d0 <malloc>
400040c8: b0 10 20 1a mov 0x1a, %i0
if (logical_disk_name == NULL) {
400040cc: 80 a2 20 00 cmp %o0, 0
400040d0: 02 80 00 27 be 4000416c <rtems_bdpart_register+0x100> <== NEVER TAKEN
400040d4: b8 10 00 08 mov %o0, %i4
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
400040d8: 92 10 00 1d mov %i5, %o1
400040dc: 94 10 00 10 mov %l0, %o2
400040e0: 40 00 48 f7 call 400164bc <strncpy>
400040e4: 25 10 00 94 sethi %hi(0x40025000), %l2
logical_disk_marker = logical_disk_name + disk_name_size;
400040e8: a0 07 00 10 add %i4, %l0, %l0
#include <string.h>
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_register(
400040ec: 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);
400040f0: 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) {
400040f4: 10 80 00 16 b 4000414c <rtems_bdpart_register+0xe0>
400040f8: a4 14 a2 48 or %l2, 0x248, %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);
400040fc: 90 10 00 10 mov %l0, %o0
40004100: 92 10 20 04 mov 4, %o1
40004104: 94 10 00 12 mov %l2, %o2
40004108: 40 00 47 54 call 40015e58 <snprintf>
4000410c: 96 27 40 1b sub %i5, %i3, %o3
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40004110: 80 a2 20 03 cmp %o0, 3
40004114: 14 80 00 13 bg 40004160 <rtems_bdpart_register+0xf4> <== NEVER TAKEN
40004118: 90 10 00 11 mov %l1, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
4000411c: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
40004120: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
40004124: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
40004128: 92 10 00 1d mov %i5, %o1
4000412c: 94 10 00 11 mov %l1, %o2
40004130: 96 10 00 1b mov %i3, %o3
40004134: 9a 23 40 0c sub %o5, %o4, %o5
40004138: 40 00 03 1e call 40004db0 <rtems_disk_create_log>
4000413c: b2 06 60 30 add %i1, 0x30, %i1
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
40004140: 80 a2 20 00 cmp %o0, 0
40004144: 12 80 00 08 bne 40004164 <rtems_bdpart_register+0xf8> <== NEVER TAKEN
40004148: 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) {
4000414c: 80 a7 40 1a cmp %i5, %i2
40004150: 32 bf ff eb bne,a 400040fc <rtems_bdpart_register+0x90>
40004154: 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;
40004158: 10 80 00 03 b 40004164 <rtems_bdpart_register+0xf8>
4000415c: b0 10 20 00 clr %i0
40004160: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
40004164: 40 00 07 ca call 4000608c <free>
40004168: 90 10 00 1c mov %i4, %o0
return esc;
}
4000416c: 81 c7 e0 08 ret
40004170: 81 e8 00 00 restore
40004174 <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
40004174: 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;
40004178: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
4000417c: 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;
40004180: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
40004184: 92 07 bc ec add %fp, -788, %o1
40004188: 94 07 bd 00 add %fp, -768, %o2
4000418c: 7f ff ff 18 call 40003dec <rtems_bdpart_read>
40004190: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
40004194: 80 a2 20 00 cmp %o0, 0
40004198: 12 80 00 05 bne 400041ac <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
4000419c: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
400041a0: 90 10 00 18 mov %i0, %o0
400041a4: 7f ff ff b2 call 4000406c <rtems_bdpart_register>
400041a8: 92 07 bd 00 add %fp, -768, %o1
}
400041ac: 81 c7 e0 08 ret
400041b0: 91 e8 00 08 restore %g0, %o0, %o0
40021acc <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40021acc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
40021ad0: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
40021ad4: 40 00 76 08 call 4003f2f4 <strrchr> <== NOT EXECUTED
40021ad8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021adc: 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);
40021ae0: 40 00 71 e2 call 4003e268 <strlen> <== NOT EXECUTED
40021ae4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021ae8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
40021aec: 40 00 71 df call 4003e268 <strlen> <== NOT EXECUTED
40021af0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
40021af4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40021af8: 02 80 00 07 be 40021b14 <rtems_bdpart_unmount+0x48> <== NOT EXECUTED
40021afc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
disk_file_name += 1;
40021b00: b2 06 60 01 inc %i1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
40021b04: 40 00 71 d9 call 4003e268 <strlen> <== NOT EXECUTED
40021b08: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40021b0c: 10 80 00 03 b 40021b18 <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
40021b10: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
} else {
disk_file_name = disk_name;
40021b14: 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);
40021b18: a2 04 00 1c add %l0, %i4, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
40021b1c: 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);
40021b20: 7f ff 88 dc call 40003e90 <malloc> <== NOT EXECUTED
40021b24: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
40021b28: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021b2c: 02 80 00 28 be 40021bcc <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
40021b30: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
40021b34: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40021b38: 40 00 72 88 call 4003e558 <strncpy> <== NOT EXECUTED
40021b3c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
40021b40: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40021b44: 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] = '/';
40021b48: c2 2f 40 1c stb %g1, [ %i5 + %i4 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40021b4c: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
40021b50: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40021b54: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40021b58: 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);
40021b5c: 40 00 72 7f call 4003e558 <strncpy> <== NOT EXECUTED
40021b60: 37 10 01 71 sethi %hi(0x4005c400), %i3 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40021b64: a2 07 40 11 add %i5, %l1, %l1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40021b68: b8 10 20 00 clr %i4 <== NOT EXECUTED
40021b6c: 10 80 00 14 b 40021bbc <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
40021b70: b6 16 e0 28 or %i3, 0x28, %i3 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021b74: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40021b78: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021b7c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40021b80: 40 00 6e 1c call 4003d3f0 <snprintf> <== NOT EXECUTED
40021b84: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40021b88: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
40021b8c: 14 80 00 10 bg 40021bcc <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
40021b90: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
40021b94: 40 00 10 38 call 40025c74 <unmount> <== NOT EXECUTED
40021b98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv == 0) {
40021b9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021ba0: 12 80 00 08 bne 40021bc0 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
40021ba4: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
40021ba8: 40 00 0e 8b call 400255d4 <rmdir> <== NOT EXECUTED
40021bac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
40021bb0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021bb4: 12 80 00 06 bne 40021bcc <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
40021bb8: 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) {
40021bbc: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
40021bc0: 32 bf ff ed bne,a 40021b74 <rtems_bdpart_unmount+0xa8> <== NOT EXECUTED
40021bc4: b8 07 20 01 inc %i4 <== NOT EXECUTED
40021bc8: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
40021bcc: 7f ff 87 dd call 40003b40 <free> <== NOT EXECUTED
40021bd0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
40021bd4: 81 c7 e0 08 ret <== NOT EXECUTED
40021bd8: 81 e8 00 00 restore <== NOT EXECUTED
400041b4 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
400041b4: 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;
400041b8: 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);
400041bc: 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;
400041c0: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
400041c4: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
400041c8: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400041cc: 92 07 bf f8 add %fp, -8, %o1
400041d0: 94 07 bf fc add %fp, -4, %o2
400041d4: 7f ff fe dd call 40003d48 <rtems_bdpart_get_disk_data>
400041d8: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
400041dc: b0 92 20 00 orcc %o0, 0, %i0
400041e0: 12 80 00 10 bne 40004220 <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
400041e4: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
400041e8: d0 07 bf f8 ld [ %fp + -8 ], %o0
400041ec: 40 00 07 87 call 40006008 <close>
400041f0: 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) {
400041f4: 10 80 00 08 b 40004214 <rtems_bdpart_unregister+0x60>
400041f8: 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);
400041fc: 90 10 00 1c mov %i4, %o0
40004200: 40 00 02 84 call 40004c10 <rtems_disk_delete>
40004204: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
40004208: 80 a2 20 00 cmp %o0, 0
4000420c: 32 80 00 05 bne,a 40004220 <rtems_bdpart_unregister+0x6c><== NEVER TAKEN
40004210: 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) {
40004214: 80 a7 40 1a cmp %i5, %i2
40004218: 12 bf ff f9 bne 400041fc <rtems_bdpart_unregister+0x48>
4000421c: ba 07 60 01 inc %i5
40004220: 81 c7 e0 08 ret
40004224: 81 e8 00 00 restore
4000430c <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
4000430c: 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;
40004310: 80 a6 60 00 cmp %i1, 0
40004314: 02 80 00 08 be 40004334 <rtems_bdpart_write+0x28> <== NEVER TAKEN
40004318: 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
4000431c: c4 06 40 00 ld [ %i1 ], %g2
40004320: 80 a0 a0 00 cmp %g2, 0
40004324: 12 80 00 05 bne 40004338 <rtems_bdpart_write+0x2c> <== NEVER TAKEN
40004328: 82 10 20 00 clr %g1
&& format->mbr.dos_compatibility;
4000432c: 10 80 00 03 b 40004338 <rtems_bdpart_write+0x2c>
40004330: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
40004334: 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
40004338: a2 08 60 01 and %g1, 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
4000433c: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
40004340: 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;
40004344: 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 =
40004348: 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;
4000434c: 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;
40004350: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
40004354: 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 =
40004358: 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;
4000435c: 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 =
40004360: 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) {
40004364: 80 a6 e0 00 cmp %i3, 0
40004368: 02 80 00 cd be 4000469c <rtems_bdpart_write+0x390> <== NEVER TAKEN
4000436c: b8 07 20 3f add %i4, 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
40004370: 80 a6 a0 00 cmp %i2, 0
40004374: 02 80 00 ca be 4000469c <rtems_bdpart_write+0x390> <== NEVER TAKEN
40004378: b0 10 20 09 mov 9, %i0
4000437c: 80 a6 60 00 cmp %i1, 0
40004380: 02 80 00 c7 be 4000469c <rtems_bdpart_write+0x390> <== NEVER TAKEN
40004384: 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);
40004388: 94 07 bf fc add %fp, -4, %o2
4000438c: 7f ff fe 6f call 40003d48 <rtems_bdpart_get_disk_data>
40004390: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40004394: b0 92 20 00 orcc %o0, 0, %i0
40004398: 12 80 00 c1 bne 4000469c <rtems_bdpart_write+0x390> <== NEVER TAKEN
4000439c: 80 a7 60 00 cmp %i5, 0
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
400043a0: 02 80 00 09 be 400043c4 <rtems_bdpart_write+0xb8> <== NEVER TAKEN
400043a4: c8 07 bf f4 ld [ %fp + -12 ], %g4
disk_end -= (disk_end % record_space);
400043a8: fa 07 bf f4 ld [ %fp + -12 ], %i5
400043ac: 92 10 00 1c mov %i4, %o1
400043b0: 40 00 76 38 call 40021c90 <.urem>
400043b4: 90 10 00 1d mov %i5, %o0
400043b8: 90 27 40 08 sub %i5, %o0, %o0
400043bc: 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) {
400043c0: c8 07 bf f4 ld [ %fp + -12 ], %g4
400043c4: a0 10 00 1a mov %i2, %l0
400043c8: 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) {
400043cc: 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) {
400043d0: c6 00 40 00 ld [ %g1 ], %g3
400043d4: 80 a0 c0 04 cmp %g3, %g4
400043d8: 3a 80 00 a5 bcc,a 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
400043dc: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
400043e0: fa 00 60 04 ld [ %g1 + 4 ], %i5
400043e4: 80 a7 40 04 cmp %i5, %g4
400043e8: 18 80 00 9e bgu 40004660 <rtems_bdpart_write+0x354> <== NEVER TAKEN
400043ec: 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) {
400043f0: 1a 80 00 9c bcc 40004660 <rtems_bdpart_write+0x354> <== NEVER TAKEN
400043f4: 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) {
400043f8: 02 80 00 06 be 40004410 <rtems_bdpart_write+0x104>
400043fc: 84 00 a0 01 inc %g2
40004400: fa 00 7f d4 ld [ %g1 + -44 ], %i5
40004404: 80 a7 40 03 cmp %i5, %g3
40004408: 38 80 00 99 bgu,a 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
4000440c: 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) {
40004410: 80 a0 80 1b cmp %g2, %i3
40004414: 12 bf ff ef bne 400043d0 <rtems_bdpart_write+0xc4>
40004418: 82 00 60 30 add %g1, 0x30, %g1
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
4000441c: c2 06 40 00 ld [ %i1 ], %g1
40004420: 80 a0 60 00 cmp %g1, 0
40004424: 12 80 00 92 bne 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
40004428: 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;
4000442c: 80 a6 e0 04 cmp %i3, 4
40004430: 08 80 00 03 bleu 4000443c <rtems_bdpart_write+0x130> <== NEVER TAKEN
40004434: ba 10 00 1b mov %i3, %i5
40004438: 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) {
4000443c: 80 8c 60 ff btst 0xff, %l1
40004440: 32 80 00 09 bne,a 40004464 <rtems_bdpart_write+0x158> <== ALWAYS TAKEN
40004444: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40004448: 83 2f 60 04 sll %i5, 4, %g1 <== NOT EXECUTED
4000444c: a5 2f 60 06 sll %i5, 6, %l2
40004450: 84 10 00 1d mov %i5, %g2
40004454: a4 24 80 01 sub %l2, %g1, %l2
40004458: 82 10 20 00 clr %g1
4000445c: 10 80 00 0e b 40004494 <rtems_bdpart_write+0x188>
40004460: 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) {
40004464: 80 a0 60 3f cmp %g1, 0x3f
40004468: 12 80 00 81 bne 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
4000446c: b0 10 20 0a mov 0xa, %i0
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40004470: 10 bf ff f7 b 4000444c <rtems_bdpart_write+0x140>
40004474: 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) {
40004478: c8 04 40 01 ld [ %l1 + %g1 ], %g4
4000447c: c6 00 ff d4 ld [ %g3 + -44 ], %g3
40004480: 86 21 00 03 sub %g4, %g3, %g3
40004484: 80 a0 c0 1c cmp %g3, %i4
40004488: 0a 80 00 76 bcs 40004660 <rtems_bdpart_write+0x354> <== NEVER TAKEN
4000448c: 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) {
40004490: 84 00 a0 01 inc %g2
40004494: 80 a0 80 1b cmp %g2, %i3
40004498: 0a bf ff f8 bcs 40004478 <rtems_bdpart_write+0x16c>
4000449c: 86 04 40 01 add %l1, %g1, %g3
400044a0: b0 10 00 1a mov %i2, %i0
400044a4: 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;
400044a8: 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)) {
400044ac: 90 06 20 08 add %i0, 8, %o0
400044b0: 7f ff fe 1a call 40003d18 <rtems_bdpart_to_mbr_partition_type>
400044b4: 92 07 bf ef add %fp, -17, %o1
400044b8: 80 8a 20 ff btst 0xff, %o0
400044bc: 22 80 00 6c be,a 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
400044c0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
400044c4: b0 06 20 30 add %i0, 0x30, %i0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
400044c8: c2 06 3f f8 ld [ %i0 + -8 ], %g1
400044cc: 80 a0 60 00 cmp %g1, 0
400044d0: 32 80 00 67 bne,a 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
400044d4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
400044d8: c2 06 3f fc ld [ %i0 + -4 ], %g1
400044dc: 80 a0 60 ff cmp %g1, 0xff
400044e0: 18 80 00 07 bgu 400044fc <rtems_bdpart_write+0x1f0> <== NEVER TAKEN
400044e4: 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) {
400044e8: 80 a4 c0 1b cmp %l3, %i3
400044ec: 32 bf ff f0 bne,a 400044ac <rtems_bdpart_write+0x1a0>
400044f0: c0 2f bf ef clrb [ %fp + -17 ]
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
400044f4: 10 80 00 04 b 40004504 <rtems_bdpart_write+0x1f8>
400044f8: d0 07 bf fc ld [ %fp + -4 ], %o0
400044fc: 10 80 00 5c b 4000466c <rtems_bdpart_write+0x360> <== NOT EXECUTED
40004500: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
40004504: 92 10 20 00 clr %o1
40004508: 7f ff ff 48 call 40004228 <rtems_bdpart_new_record>
4000450c: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
40004510: b0 92 20 00 orcc %o0, 0, %i0
40004514: 12 80 00 57 bne 40004670 <rtems_bdpart_write+0x364> <== NEVER TAKEN
40004518: 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
4000451c: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
40004520: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
40004524: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
40004528: 82 10 20 00 clr %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
4000452c: 86 01 00 01 add %g4, %g1, %g3
data [i] = (uint8_t) value;
40004530: 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) {
40004534: 82 00 60 01 inc %g1
40004538: 80 a0 60 04 cmp %g1, 4
4000453c: 12 bf ff fc bne 4000452c <rtems_bdpart_write+0x220>
40004540: 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;
40004544: c2 07 bf f0 ld [ %fp + -16 ], %g1
for (i = 0; i < ppc; ++i) {
40004548: 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;
4000454c: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
40004550: a6 04 e1 be add %l3, 0x1be, %l3
for (i = 0; i < ppc; ++i) {
40004554: 10 80 00 0b b 40004580 <rtems_bdpart_write+0x274>
40004558: b0 10 00 13 mov %l3, %i0
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
4000455c: d4 04 20 04 ld [ %l0 + 4 ], %o2
40004560: d6 0c 20 08 ldub [ %l0 + 8 ], %o3
40004564: d8 0c 20 2f ldub [ %l0 + 0x2f ], %o4
40004568: 90 10 00 18 mov %i0, %o0
4000456c: 94 22 80 09 sub %o2, %o1, %o2
40004570: 7f ff ff 56 call 400042c8 <rtems_bdpart_write_mbr_partition>
40004574: 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) {
40004578: b2 06 60 01 inc %i1
4000457c: a0 04 20 30 add %l0, 0x30, %l0
40004580: 80 a6 40 1d cmp %i1, %i5
40004584: 32 bf ff f6 bne,a 4000455c <rtems_bdpart_write+0x250>
40004588: d2 04 00 00 ld [ %l0 ], %o1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
4000458c: 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;
40004590: b0 10 20 00 clr %i0
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
40004594: 80 a7 40 1b cmp %i5, %i3
40004598: 02 80 00 35 be 4000466c <rtems_bdpart_write+0x360> <== NEVER TAKEN
4000459c: 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;
400045a0: e0 06 80 12 ld [ %i2 + %l2 ], %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
400045a4: 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;
400045a8: a0 24 00 1c sub %l0, %i4, %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
400045ac: 96 10 20 05 mov 5, %o3
400045b0: 92 10 00 10 mov %l0, %o1
400045b4: 94 22 80 10 sub %o2, %l0, %o2
400045b8: 98 10 20 00 clr %o4
400045bc: 7f ff ff 43 call 400042c8 <rtems_bdpart_write_mbr_partition>
400045c0: b4 10 00 11 mov %l1, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
400045c4: 10 80 00 22 b 4000464c <rtems_bdpart_write+0x340>
400045c8: b2 10 00 1d mov %i5, %i1
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
400045cc: 28 80 00 0e bleu,a 40004604 <rtems_bdpart_write+0x2f8>
400045d0: 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,
400045d4: 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;
400045d8: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
400045dc: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
400045e0: 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;
400045e4: 82 20 40 1c sub %g1, %i4, %g1
rtems_bdpart_write_mbr_partition(
400045e8: 90 02 21 ce add %o0, 0x1ce, %o0
400045ec: 92 20 40 10 sub %g1, %l0, %o1
400045f0: 94 22 80 01 sub %o2, %g1, %o2
400045f4: 96 10 20 05 mov 5, %o3
400045f8: 7f ff ff 34 call 400042c8 <rtems_bdpart_write_mbr_partition>
400045fc: 98 10 20 00 clr %o4
0
);
}
/* New EBR */
ebr = p->begin - record_space;
40004600: d2 06 80 00 ld [ %i2 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
40004604: d0 07 bf fc ld [ %fp + -4 ], %o0
40004608: 92 22 40 1c sub %o1, %i4, %o1
4000460c: 7f ff ff 07 call 40004228 <rtems_bdpart_new_record>
40004610: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
40004614: 80 a2 20 00 cmp %o0, 0
40004618: 12 80 00 14 bne 40004668 <rtems_bdpart_write+0x35c> <== NEVER TAKEN
4000461c: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
40004620: d4 06 a0 04 ld [ %i2 + 4 ], %o2
40004624: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40004628: d6 0e a0 08 ldub [ %i2 + 8 ], %o3
4000462c: c2 06 80 00 ld [ %i2 ], %g1
40004630: d8 0e a0 2f ldub [ %i2 + 0x2f ], %o4
40004634: 90 02 21 be add %o0, 0x1be, %o0
40004638: 92 10 00 1c mov %i4, %o1
4000463c: 94 22 80 01 sub %o2, %g1, %o2
40004640: 7f ff ff 22 call 400042c8 <rtems_bdpart_write_mbr_partition>
40004644: b2 06 60 01 inc %i1
40004648: b4 06 a0 30 add %i2, 0x30, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
4000464c: 80 a6 40 1b cmp %i1, %i3
40004650: 0a bf ff df bcs 400045cc <rtems_bdpart_write+0x2c0>
40004654: 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;
40004658: 10 80 00 05 b 4000466c <rtems_bdpart_write+0x360>
4000465c: 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;
40004660: 10 80 00 03 b 4000466c <rtems_bdpart_write+0x360> <== NOT EXECUTED
40004664: 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) {
40004668: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
4000466c: d0 07 bf f8 ld [ %fp + -8 ], %o0
40004670: 80 a2 20 00 cmp %o0, 0
40004674: 26 80 00 05 bl,a 40004688 <rtems_bdpart_write+0x37c> <== NEVER TAKEN
40004678: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
4000467c: 40 00 06 63 call 40006008 <close>
40004680: 01 00 00 00 nop
}
if (block != NULL) {
40004684: d0 07 bf f0 ld [ %fp + -16 ], %o0
40004688: 80 a2 20 00 cmp %o0, 0
4000468c: 02 80 00 06 be 400046a4 <rtems_bdpart_write+0x398> <== NEVER TAKEN
40004690: 01 00 00 00 nop
rtems_bdbuf_sync( block);
40004694: 40 00 2f cb call 400105c0 <rtems_bdbuf_sync>
40004698: 01 00 00 00 nop
4000469c: 81 c7 e0 08 ret
400046a0: 81 e8 00 00 restore
}
return esc;
}
400046a4: 81 c7 e0 08 ret <== NOT EXECUTED
400046a8: 81 e8 00 00 restore <== NOT EXECUTED
40004534 <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
40004534: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
40004538: 92 10 20 02 mov 2, %o1
4000453c: 90 10 00 19 mov %i1, %o0
40004540: 40 00 09 2e call 400069f8 <open>
40004544: ba 10 20 04 mov 4, %i5
if (fd >= 0) {
40004548: 80 a2 20 00 cmp %o0, 0
4000454c: 06 80 00 33 bl 40004618 <rtems_blkdev_create_partition+0xe4>
40004550: b2 10 00 08 mov %o0, %i1
int rv;
struct stat st;
rv = fstat(fd, &st);
40004554: 40 00 05 bb call 40005c40 <fstat>
40004558: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
4000455c: 80 a2 20 00 cmp %o0, 0
40004560: 12 80 00 2c bne 40004610 <rtems_blkdev_create_partition+0xdc><== NEVER TAKEN
40004564: ba 10 20 15 mov 0x15, %i5
40004568: e0 07 bf c4 ld [ %fp + -60 ], %l0
4000456c: 03 00 00 3c sethi %hi(0xf000), %g1
40004570: a0 0c 00 01 and %l0, %g1, %l0
40004574: 03 00 00 18 sethi %hi(0x6000), %g1
40004578: 80 a4 00 01 cmp %l0, %g1
4000457c: 12 80 00 25 bne 40004610 <rtems_blkdev_create_partition+0xdc>
40004580: 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);
40004584: 13 10 01 10 sethi %hi(0x40044000), %o1
40004588: 94 07 bf b4 add %fp, -76, %o2
4000458c: 92 12 62 09 or %o1, 0x209, %o1
40004590: 40 00 05 ff call 40005d8c <ioctl>
40004594: 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) {
40004598: 80 a2 20 00 cmp %o0, 0
4000459c: 12 80 00 1d bne 40004610 <rtems_blkdev_create_partition+0xdc>
400045a0: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
400045a4: 40 00 07 0e call 400061dc <malloc>
400045a8: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
400045ac: b8 92 20 00 orcc %o0, 0, %i4
400045b0: 02 80 00 17 be 4000460c <rtems_blkdev_create_partition+0xd8>
400045b4: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
400045b8: 94 10 00 1a mov %i2, %o2
400045bc: 40 00 00 90 call 400047fc <rtems_disk_init_log>
400045c0: 96 10 00 1b mov %i3, %o3
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
400045c4: ba 92 20 00 orcc %o0, 0, %i5
400045c8: 12 80 00 0e bne 40004600 <rtems_blkdev_create_partition+0xcc>
400045cc: 90 10 00 18 mov %i0, %o0
ctx->fd = fd;
400045d0: f2 27 20 78 st %i1, [ %i4 + 0x78 ]
rv = IMFS_make_generic_node(
400045d4: 92 14 21 ff or %l0, 0x1ff, %o1
400045d8: 15 10 00 68 sethi %hi(0x4001a000), %o2
400045dc: 96 10 00 1c mov %i4, %o3
400045e0: 40 00 03 90 call 40005420 <IMFS_make_generic_node>
400045e4: 94 12 a2 d8 or %o2, 0x2d8, %o2
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
400045e8: 80 a2 20 00 cmp %o0, 0
400045ec: 02 80 00 0b be 40004618 <rtems_blkdev_create_partition+0xe4>
400045f0: 90 10 00 1c mov %i4, %o0
free(ctx);
400045f4: 40 00 05 69 call 40005b98 <free>
400045f8: ba 10 20 0d mov 0xd, %i5
400045fc: 30 80 00 05 b,a 40004610 <rtems_blkdev_create_partition+0xdc>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
40004600: 40 00 05 66 call 40005b98 <free>
40004604: 90 10 00 1c mov %i4, %o0
40004608: 30 80 00 02 b,a 40004610 <rtems_blkdev_create_partition+0xdc>
4000460c: ba 10 20 1a mov 0x1a, %i5
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
40004610: 40 00 05 41 call 40005b14 <close>
40004614: 90 10 00 19 mov %i1, %o0
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
40004618: 81 c7 e0 08 ret
4000461c: 91 e8 00 1d restore %g0, %i5, %o0
4000fd98 <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)
{
4000fd98: 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;
4000fd9c: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
4000fda0: 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;
4000fda4: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
4000fda8: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000fdac: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000fdb0: 80 a2 40 01 cmp %o1, %g1
4000fdb4: 02 80 00 07 be 4000fdd0 <rtems_blkdev_generic_ioctl+0x38> <== NEVER TAKEN
4000fdb8: 82 10 3f ff mov -1, %g1
{
args->ioctl_return = dd->ioctl(dd,
4000fdbc: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000fdc0: 9f c0 40 00 call %g1
4000fdc4: d4 06 a0 08 ld [ %i2 + 8 ], %o2
4000fdc8: 10 80 00 03 b 4000fdd4 <rtems_blkdev_generic_ioctl+0x3c>
4000fdcc: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
4000fdd0: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
4000fdd4: 81 c7 e0 08 ret
4000fdd8: 91 e8 20 00 restore %g0, 0, %o0
4000fb78 <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)
{
4000fb78: 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;
4000fb7c: 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);
4000fb80: 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;
4000fb84: 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);
4000fb88: 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;
4000fb8c: 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);
4000fb90: 94 10 20 00 clr %o2
4000fb94: 96 10 00 10 mov %l0, %o3
4000fb98: 40 00 20 d1 call 40017edc <__divdi3>
4000fb9c: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000fba0: 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);
4000fba4: a6 10 00 09 mov %o1, %l3
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000fba8: 94 10 20 00 clr %o2
4000fbac: 92 10 00 1d mov %i5, %o1
4000fbb0: 96 10 00 10 mov %l0, %o3
4000fbb4: 40 00 21 b5 call 40018288 <__moddi3>
4000fbb8: 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;
4000fbbc: 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);
4000fbc0: a2 10 00 09 mov %o1, %l1
args->bytes_moved = 0;
4000fbc4: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
4000fbc8: 10 80 00 1c b 4000fc38 <rtems_blkdev_generic_read+0xc0>
4000fbcc: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
4000fbd0: 90 10 00 12 mov %l2, %o0
4000fbd4: 7f ff fd a6 call 4000f26c <rtems_bdbuf_read>
4000fbd8: 94 07 bf fc add %fp, -4, %o2
if (rc != RTEMS_SUCCESSFUL)
4000fbdc: 80 a2 20 00 cmp %o0, 0
4000fbe0: 12 80 00 1a bne 4000fc48 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
4000fbe4: ba 24 00 11 sub %l0, %l1, %i5
4000fbe8: 80 a7 40 1b cmp %i5, %i3
4000fbec: 38 80 00 02 bgu,a 4000fbf4 <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
4000fbf0: 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);
4000fbf4: c2 07 bf fc ld [ %fp + -4 ], %g1
4000fbf8: 94 10 00 1d mov %i5, %o2
4000fbfc: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
4000fc00: 90 10 00 19 mov %i1, %o0
4000fc04: 40 00 13 7e call 400149fc <memcpy>
4000fc08: 92 02 40 11 add %o1, %l1, %o1
rc = rtems_bdbuf_release(diskbuf);
4000fc0c: d0 07 bf fc ld [ %fp + -4 ], %o0
4000fc10: 7f ff fe 13 call 4000f45c <rtems_bdbuf_release>
4000fc14: b8 07 20 01 inc %i4
args->bytes_moved += copy;
4000fc18: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
if (rc != RTEMS_SUCCESSFUL)
4000fc1c: 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;
4000fc20: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
4000fc24: 12 80 00 09 bne 4000fc48 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
4000fc28: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
4000fc2c: b6 26 c0 1d sub %i3, %i5, %i3
buf += copy;
4000fc30: b2 06 40 1d add %i1, %i5, %i1
blkofs = 0;
4000fc34: 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)
4000fc38: 80 a6 e0 00 cmp %i3, 0
4000fc3c: 12 bf ff e5 bne 4000fbd0 <rtems_blkdev_generic_read+0x58>
4000fc40: 92 07 00 13 add %i4, %l3, %o1
4000fc44: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
4000fc48: 81 c7 e0 08 ret
4000fc4c: 91 e8 00 08 restore %g0, %o0, %o0
4000fc50 <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)
{
4000fc50: 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;
4000fc54: 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);
4000fc58: 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;
4000fc5c: 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);
4000fc60: 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;
4000fc64: 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);
4000fc68: 94 10 20 00 clr %o2
4000fc6c: 96 10 00 19 mov %i1, %o3
4000fc70: 40 00 20 9b call 40017edc <__divdi3>
4000fc74: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000fc78: 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);
4000fc7c: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000fc80: 94 10 20 00 clr %o2
4000fc84: 92 10 00 1d mov %i5, %o1
4000fc88: 96 10 00 19 mov %i1, %o3
4000fc8c: 40 00 21 7f call 40018288 <__moddi3>
4000fc90: 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;
4000fc94: 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);
4000fc98: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
4000fc9c: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
4000fca0: 10 80 00 26 b 4000fd38 <rtems_blkdev_generic_write+0xe8>
4000fca4: 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);
4000fca8: 90 10 00 11 mov %l1, %o0
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
4000fcac: 80 a6 c0 19 cmp %i3, %i1
4000fcb0: 0a 80 00 09 bcs 4000fcd4 <rtems_blkdev_generic_write+0x84><== NEVER TAKEN
4000fcb4: 94 07 bf fc add %fp, -4, %o2
4000fcb8: 80 a7 20 00 cmp %i4, 0
4000fcbc: 12 80 00 06 bne 4000fcd4 <rtems_blkdev_generic_write+0x84><== NEVER TAKEN
4000fcc0: 01 00 00 00 nop
rc = rtems_bdbuf_get(dd, block, &diskbuf);
4000fcc4: 7f ff fd 39 call 4000f1a8 <rtems_bdbuf_get>
4000fcc8: 01 00 00 00 nop
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
4000fccc: 10 80 00 05 b 4000fce0 <rtems_blkdev_generic_write+0x90>
4000fcd0: 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);
4000fcd4: 7f ff fd 66 call 4000f26c <rtems_bdbuf_read> <== NOT EXECUTED
4000fcd8: 01 00 00 00 nop <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
4000fcdc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000fce0: 12 80 00 1a bne 4000fd48 <rtems_blkdev_generic_write+0xf8><== NEVER TAKEN
4000fce4: ba 26 40 1c sub %i1, %i4, %i5
4000fce8: 80 a7 40 1b cmp %i5, %i3
4000fcec: 38 80 00 02 bgu,a 4000fcf4 <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
4000fcf0: 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);
4000fcf4: c2 07 bf fc ld [ %fp + -4 ], %g1
4000fcf8: 92 10 00 10 mov %l0, %o1
4000fcfc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4000fd00: 94 10 00 1d mov %i5, %o2
4000fd04: 40 00 13 3e call 400149fc <memcpy>
4000fd08: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
4000fd0c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
4000fd10: 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;
4000fd14: 82 00 40 1d add %g1, %i5, %g1
4000fd18: b0 06 20 01 inc %i0
rc = rtems_bdbuf_release_modified(diskbuf);
4000fd1c: 7f ff fe 05 call 4000f530 <rtems_bdbuf_release_modified>
4000fd20: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
4000fd24: 80 a2 20 00 cmp %o0, 0
4000fd28: 12 80 00 08 bne 4000fd48 <rtems_blkdev_generic_write+0xf8><== NEVER TAKEN
4000fd2c: b6 26 c0 1d sub %i3, %i5, %i3
break;
count -= copy;
buf += copy;
4000fd30: a0 04 00 1d add %l0, %i5, %l0
blkofs = 0;
4000fd34: 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)
4000fd38: 80 a6 e0 00 cmp %i3, 0
4000fd3c: 12 bf ff db bne 4000fca8 <rtems_blkdev_generic_write+0x58>
4000fd40: 92 06 00 12 add %i0, %l2, %o1
4000fd44: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
4000fd48: 81 c7 e0 08 ret
4000fd4c: 91 e8 00 08 restore %g0, %o0, %o0
40004420 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
40004420: 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;
40004424: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv = 0;
40004428: 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);
4000442c: 40 00 2f 79 call 40010210 <rtems_bdbuf_syncdev>
40004430: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
40004434: 80 a2 20 00 cmp %o0, 0
40004438: 02 80 00 06 be 40004450 <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== ALWAYS TAKEN
4000443c: 01 00 00 00 nop
errno = EIO;
40004440: 40 00 40 b8 call 40014720 <__errno> <== NOT EXECUTED
40004444: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40004448: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000444c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40004450: 81 c7 e0 08 ret
40004454: 81 e8 00 00 restore
40004458 <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
40004458: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
4000445c: 03 30 06 10 sethi %hi(0xc0184000), %g1
40004460: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40004464: 80 a6 40 01 cmp %i1, %g1
40004468: 02 80 00 09 be 4000448c <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
4000446c: 92 10 00 19 mov %i1, %o1
40004470: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40004474: 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);
40004478: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000447c: 9f c0 40 00 call %g1
40004480: 94 10 00 1a mov %i2, %o2
40004484: 81 c7 e0 08 ret
40004488: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
4000448c: 40 00 40 a5 call 40014720 <__errno> <== NOT EXECUTED
40004490: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004494: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40004498: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
4000449c: 81 c7 e0 08 ret <== NOT EXECUTED
400044a0: 81 e8 00 00 restore <== NOT EXECUTED
400042a4 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
400042a4: 9d e3 bf 98 save %sp, -104, %sp
400042a8: 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;
400042ac: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
400042b0: 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);
400042b4: 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);
400042b8: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
400042bc: 90 10 00 1c mov %i4, %o0
400042c0: a3 3e e0 1f sra %i3, 0x1f, %l1
400042c4: 96 10 00 1b mov %i3, %o3
400042c8: 40 00 50 e6 call 40018660 <__divdi3>
400042cc: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
400042d0: 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);
400042d4: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
400042d8: 90 10 00 1c mov %i4, %o0
400042dc: 92 10 00 1d mov %i5, %o1
400042e0: 96 10 00 1b mov %i3, %o3
400042e4: 40 00 51 ca call 40018a0c <__moddi3>
400042e8: ba 10 00 1a mov %i2, %i5
char *dst = buffer;
while (remaining > 0) {
400042ec: 10 80 00 19 b 40004350 <rtems_blkdev_imfs_read+0xac>
400042f0: a2 10 00 09 mov %o1, %l1
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
400042f4: 92 10 00 10 mov %l0, %o1
400042f8: 40 00 2e ab call 4000fda4 <rtems_bdbuf_read>
400042fc: 94 07 bf fc add %fp, -4, %o2
if (sc == RTEMS_SUCCESSFUL) {
40004300: 80 a2 20 00 cmp %o0, 0
40004304: 12 80 00 1f bne 40004380 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
40004308: b8 26 c0 11 sub %i3, %l1, %i4
4000430c: 80 a7 00 1d cmp %i4, %i5
40004310: 34 80 00 02 bg,a 40004318 <rtems_blkdev_imfs_read+0x74>
40004314: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
40004318: c2 07 bf fc ld [ %fp + -4 ], %g1
4000431c: 94 10 00 1c mov %i4, %o2
40004320: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
40004324: 90 10 00 19 mov %i1, %o0
40004328: 40 00 43 5f call 400150a4 <memcpy>
4000432c: 92 02 40 11 add %o1, %l1, %o1
sc = rtems_bdbuf_release(bd);
40004330: 40 00 2f 19 call 4000ff94 <rtems_bdbuf_release>
40004334: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
40004338: 80 a2 20 00 cmp %o0, 0
4000433c: 12 80 00 11 bne 40004380 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
40004340: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
dst += copy;
40004344: b2 06 40 1c add %i1, %i4, %i1
++block;
40004348: 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;
4000434c: 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) {
40004350: 80 a7 60 00 cmp %i5, 0
40004354: 14 bf ff e8 bg 400042f4 <rtems_blkdev_imfs_read+0x50>
40004358: 90 10 00 12 mov %l2, %o0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
4000435c: 80 a7 60 00 cmp %i5, 0
40004360: 12 80 00 08 bne 40004380 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
40004364: 01 00 00 00 nop
iop->offset += count;
40004368: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4000436c: 86 80 c0 1a addcc %g3, %i2, %g3
40004370: 84 40 a0 00 addx %g2, 0, %g2
40004374: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
40004378: 81 c7 e0 08 ret
4000437c: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
40004380: 40 00 40 e8 call 40014720 <__errno> <== NOT EXECUTED
40004384: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004388: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000438c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40004390: 81 c7 e0 08 ret <== NOT EXECUTED
40004394: 81 e8 00 00 restore <== NOT EXECUTED
40004178 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
40004178: 9d e3 bf 98 save %sp, -104, %sp
4000417c: 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;
40004180: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40004184: 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);
40004188: 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);
4000418c: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004190: 90 10 00 1c mov %i4, %o0
40004194: a3 3e e0 1f sra %i3, 0x1f, %l1
40004198: 96 10 00 1b mov %i3, %o3
4000419c: 40 00 51 31 call 40018660 <__divdi3>
400041a0: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
400041a4: 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);
400041a8: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
400041ac: 90 10 00 1c mov %i4, %o0
400041b0: 92 10 00 1d mov %i5, %o1
400041b4: 96 10 00 1b mov %i3, %o3
400041b8: 40 00 52 15 call 40018a0c <__moddi3>
400041bc: ba 10 00 1a mov %i2, %i5
const char *src = buffer;
while (remaining > 0) {
400041c0: 10 80 00 27 b 4000425c <rtems_blkdev_imfs_write+0xe4>
400041c4: a2 10 00 09 mov %o1, %l1
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
400041c8: 16 80 00 03 bge 400041d4 <rtems_blkdev_imfs_write+0x5c>
400041cc: 82 10 20 01 mov 1, %g1
400041d0: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
400041d4: 90 10 00 12 mov %l2, %o0
400041d8: 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) {
400041dc: 80 88 60 ff btst 0xff, %g1
400041e0: 02 80 00 09 be 40004204 <rtems_blkdev_imfs_write+0x8c>
400041e4: 94 07 bf fc add %fp, -4, %o2
400041e8: 80 a4 60 00 cmp %l1, 0
400041ec: 12 80 00 06 bne 40004204 <rtems_blkdev_imfs_write+0x8c>
400041f0: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
400041f4: 40 00 2e bb call 4000fce0 <rtems_bdbuf_get>
400041f8: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
400041fc: 10 80 00 05 b 40004210 <rtems_blkdev_imfs_write+0x98>
40004200: 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);
40004204: 40 00 2e e8 call 4000fda4 <rtems_bdbuf_read>
40004208: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
4000420c: 80 a2 20 00 cmp %o0, 0
40004210: 12 80 00 1f bne 4000428c <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
40004214: b8 26 c0 11 sub %i3, %l1, %i4
40004218: 80 a7 00 1d cmp %i4, %i5
4000421c: 34 80 00 02 bg,a 40004224 <rtems_blkdev_imfs_write+0xac>
40004220: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
40004224: c2 07 bf fc ld [ %fp + -4 ], %g1
40004228: 92 10 00 19 mov %i1, %o1
4000422c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40004230: 94 10 00 1c mov %i4, %o2
40004234: 40 00 43 9c call 400150a4 <memcpy>
40004238: 90 02 00 11 add %o0, %l1, %o0
sc = rtems_bdbuf_release_modified(bd);
4000423c: 40 00 2f 8b call 40010068 <rtems_bdbuf_release_modified>
40004240: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
40004244: 80 a2 20 00 cmp %o0, 0
40004248: 12 80 00 11 bne 4000428c <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
4000424c: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
src += copy;
40004250: b2 06 40 1c add %i1, %i4, %i1
++block;
40004254: 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;
40004258: 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) {
4000425c: 80 a7 60 00 cmp %i5, 0
40004260: 14 bf ff da bg 400041c8 <rtems_blkdev_imfs_write+0x50>
40004264: 80 a7 40 1b cmp %i5, %i3
} else {
remaining = -1;
}
}
if (remaining >= 0) {
40004268: 80 a7 60 00 cmp %i5, 0
4000426c: 12 80 00 08 bne 4000428c <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
40004270: 01 00 00 00 nop
iop->offset += count;
40004274: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40004278: 86 80 c0 1a addcc %g3, %i2, %g3
4000427c: 84 40 a0 00 addx %g2, 0, %g2
40004280: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
40004284: 81 c7 e0 08 ret
40004288: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
4000428c: 40 00 41 25 call 40014720 <__errno> <== NOT EXECUTED
40004290: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004294: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40004298: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
4000429c: 81 c7 e0 08 ret <== NOT EXECUTED
400042a0: 81 e8 00 00 restore <== NOT EXECUTED
4000fa20 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000fa20: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
4000fa24: 03 10 01 10 sethi %hi(0x40044000), %g1
4000fa28: 84 10 62 03 or %g1, 0x203, %g2 ! 40044203 <__end+0x27d93>
4000fa2c: 80 a6 40 02 cmp %i1, %g2
4000fa30: 02 80 00 2f be 4000faec <rtems_blkdev_ioctl+0xcc>
4000fa34: 90 10 00 18 mov %i0, %o0
4000fa38: 80 a6 40 02 cmp %i1, %g2
4000fa3c: 18 80 00 16 bgu 4000fa94 <rtems_blkdev_ioctl+0x74>
4000fa40: 84 10 62 09 or %g1, 0x209, %g2
4000fa44: 05 08 00 10 sethi %hi(0x20004000), %g2
4000fa48: 86 10 a2 0a or %g2, 0x20a, %g3 ! 2000420a <RAM_SIZE+0x1fc0420a>
4000fa4c: 80 a6 40 03 cmp %i1, %g3
4000fa50: 02 80 00 38 be 4000fb30 <rtems_blkdev_ioctl+0x110>
4000fa54: 01 00 00 00 nop
4000fa58: 38 80 00 07 bgu,a 4000fa74 <rtems_blkdev_ioctl+0x54>
4000fa5c: 84 10 a2 0c or %g2, 0x20c, %g2
4000fa60: 84 10 a2 06 or %g2, 0x206, %g2
4000fa64: 80 a6 40 02 cmp %i1, %g2
4000fa68: 12 80 00 3d bne 4000fb5c <rtems_blkdev_ioctl+0x13c>
4000fa6c: 01 00 00 00 nop
4000fa70: 30 80 00 27 b,a 4000fb0c <rtems_blkdev_ioctl+0xec>
4000fa74: 80 a6 40 02 cmp %i1, %g2
4000fa78: 02 80 00 35 be 4000fb4c <rtems_blkdev_ioctl+0x12c>
4000fa7c: 82 10 62 02 or %g1, 0x202, %g1
4000fa80: 80 a6 40 01 cmp %i1, %g1
4000fa84: 12 80 00 36 bne 4000fb5c <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
4000fa88: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
4000fa8c: 10 80 00 16 b 4000fae4 <rtems_blkdev_ioctl+0xc4>
4000fa90: 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)
4000fa94: 80 a6 40 02 cmp %i1, %g2
4000fa98: 22 80 00 2f be,a 4000fb54 <rtems_blkdev_ioctl+0x134>
4000fa9c: f0 26 80 00 st %i0, [ %i2 ]
4000faa0: 38 80 00 08 bgu,a 4000fac0 <rtems_blkdev_ioctl+0xa0>
4000faa4: 82 10 62 0b or %g1, 0x20b, %g1
4000faa8: 82 10 62 05 or %g1, 0x205, %g1
4000faac: 80 a6 40 01 cmp %i1, %g1
4000fab0: 12 80 00 2b bne 4000fb5c <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
4000fab4: 01 00 00 00 nop
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000fab8: 10 80 00 13 b 4000fb04 <rtems_blkdev_ioctl+0xe4>
4000fabc: 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)
4000fac0: 80 a6 40 01 cmp %i1, %g1
4000fac4: 02 80 00 1e be 4000fb3c <rtems_blkdev_ioctl+0x11c>
4000fac8: 03 20 01 10 sethi %hi(0x80044000), %g1
4000facc: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <LEON_REG+0x44204>
4000fad0: 80 a6 40 01 cmp %i1, %g1
4000fad4: 12 80 00 22 bne 4000fb5c <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
4000fad8: 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);
4000fadc: 10 80 00 06 b 4000faf4 <rtems_blkdev_ioctl+0xd4>
4000fae0: d2 06 80 00 ld [ %i2 ], %o1
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000fae4: 10 80 00 1c b 4000fb54 <rtems_blkdev_ioctl+0x134>
4000fae8: 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;
4000faec: 10 80 00 06 b 4000fb04 <rtems_blkdev_ioctl+0xe4>
4000faf0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
4000faf4: 7f ff ff 7c call 4000f8e4 <rtems_bdbuf_set_block_size>
4000faf8: 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) {
4000fafc: 10 80 00 07 b 4000fb18 <rtems_blkdev_ioctl+0xf8>
4000fb00: 80 a2 20 00 cmp %o0, 0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000fb04: 10 80 00 14 b 4000fb54 <rtems_blkdev_ioctl+0x134>
4000fb08: c2 26 80 00 st %g1, [ %i2 ]
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
4000fb0c: 7f ff fe f3 call 4000f6d8 <rtems_bdbuf_syncdev>
4000fb10: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
4000fb14: 80 a2 20 00 cmp %o0, 0
4000fb18: 22 80 00 16 be,a 4000fb70 <rtems_blkdev_ioctl+0x150> <== ALWAYS TAKEN
4000fb1c: b0 10 20 00 clr %i0
errno = EIO;
4000fb20: 40 00 11 80 call 40014120 <__errno> <== NOT EXECUTED
4000fb24: 01 00 00 00 nop <== NOT EXECUTED
4000fb28: 10 80 00 10 b 4000fb68 <rtems_blkdev_ioctl+0x148> <== NOT EXECUTED
4000fb2c: 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);
4000fb30: 7f ff ff 01 call 4000f734 <rtems_bdbuf_purge_dev>
4000fb34: b0 10 20 00 clr %i0
4000fb38: 30 80 00 0e b,a 4000fb70 <rtems_blkdev_ioctl+0x150>
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
4000fb3c: 7f ff ff a7 call 4000f9d8 <rtems_bdbuf_get_device_stats>
4000fb40: 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;
4000fb44: 81 c7 e0 08 ret
4000fb48: 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);
4000fb4c: 7f ff ff ac call 4000f9fc <rtems_bdbuf_reset_device_stats>
4000fb50: 01 00 00 00 nop
break;
4000fb54: 81 c7 e0 08 ret
4000fb58: 91 e8 20 00 restore %g0, 0, %o0
default:
errno = EINVAL;
4000fb5c: 40 00 11 71 call 40014120 <__errno>
4000fb60: 01 00 00 00 nop
4000fb64: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4000fb68: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
4000fb6c: b0 10 3f ff mov -1, %i0
break;
}
return rc;
}
4000fb70: 81 c7 e0 08 ret
4000fb74: 81 e8 00 00 restore
4002270c <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
4002270c: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
40022710: 92 10 20 00 clr %o1 <== NOT EXECUTED
40022714: 7f ff 87 e6 call 400046ac <open> <== NOT EXECUTED
40022718: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
4002271c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40022720: 06 80 00 51 bl 40022864 <rtems_blkstats+0x158> <== NOT EXECUTED
40022724: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
40022728: 40 00 07 05 call 4002433c <fstat> <== NOT EXECUTED
4002272c: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
40022730: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40022734: 12 80 00 34 bne 40022804 <rtems_blkstats+0xf8> <== NOT EXECUTED
40022738: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
4002273c: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
40022740: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
40022744: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
40022748: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4002274c: 32 80 00 2a bne,a 400227f4 <rtems_blkstats+0xe8> <== NOT EXECUTED
40022750: 11 10 01 69 sethi %hi(0x4005a400), %o0 <== NOT EXECUTED
if (reset) {
40022754: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40022758: 02 80 00 11 be 4002279c <rtems_blkstats+0x90> <== NOT EXECUTED
4002275c: 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);
40022760: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
40022764: 40 00 09 b3 call 40024e30 <ioctl> <== NOT EXECUTED
40022768: 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) {
4002276c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40022770: 02 80 00 2f be 4002282c <rtems_blkstats+0x120> <== NOT EXECUTED
40022774: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
40022778: 40 00 52 c8 call 40037298 <__errno> <== NOT EXECUTED
4002277c: 01 00 00 00 nop <== NOT EXECUTED
40022780: 40 00 6e 93 call 4003e1cc <strerror> <== NOT EXECUTED
40022784: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40022788: 13 10 01 69 sethi %hi(0x4005a400), %o1 <== NOT EXECUTED
4002278c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40022790: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
40022794: 10 80 00 24 b 40022824 <rtems_blkstats+0x118> <== NOT EXECUTED
40022798: 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);
4002279c: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
400227a0: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
400227a4: 40 00 09 a3 call 40024e30 <ioctl> <== NOT EXECUTED
400227a8: 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) {
400227ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400227b0: 12 80 00 08 bne 400227d0 <rtems_blkstats+0xc4> <== NOT EXECUTED
400227b4: 01 00 00 00 nop <== NOT EXECUTED
rtems_blkdev_print_stats(
400227b8: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
400227bc: 13 10 00 df sethi %hi(0x40037c00), %o1 <== NOT EXECUTED
400227c0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
400227c4: 40 00 00 34 call 40022894 <rtems_blkdev_print_stats> <== NOT EXECUTED
400227c8: 92 12 61 a4 or %o1, 0x1a4, %o1 <== NOT EXECUTED
400227cc: 30 80 00 18 b,a 4002282c <rtems_blkstats+0x120> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
400227d0: 40 00 52 b2 call 40037298 <__errno> <== NOT EXECUTED
400227d4: 01 00 00 00 nop <== NOT EXECUTED
400227d8: 40 00 6e 7d call 4003e1cc <strerror> <== NOT EXECUTED
400227dc: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400227e0: 13 10 01 69 sethi %hi(0x4005a400), %o1 <== NOT EXECUTED
400227e4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400227e8: 92 12 61 70 or %o1, 0x170, %o1 <== NOT EXECUTED
400227ec: 10 80 00 0e b 40022824 <rtems_blkstats+0x118> <== NOT EXECUTED
400227f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
}
} else {
fprintf(output, "error: not a block device\n");
400227f4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400227f8: 40 00 55 bb call 40037ee4 <fputs> <== NOT EXECUTED
400227fc: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
40022800: 30 80 00 0b b,a 4002282c <rtems_blkstats+0x120> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
40022804: 40 00 52 a5 call 40037298 <__errno> <== NOT EXECUTED
40022808: 01 00 00 00 nop <== NOT EXECUTED
4002280c: 40 00 6e 70 call 4003e1cc <strerror> <== NOT EXECUTED
40022810: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40022814: 13 10 01 69 sethi %hi(0x4005a400), %o1 <== NOT EXECUTED
40022818: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002281c: 92 12 61 a8 or %o1, 0x1a8, %o1 <== NOT EXECUTED
40022820: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40022824: 40 00 55 60 call 40037da4 <fprintf> <== NOT EXECUTED
40022828: 01 00 00 00 nop <== NOT EXECUTED
}
rv = close(fd);
4002282c: 40 00 05 a6 call 40023ec4 <close> <== NOT EXECUTED
40022830: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
40022834: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40022838: 02 80 00 15 be 4002288c <rtems_blkstats+0x180> <== NOT EXECUTED
4002283c: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
40022840: 40 00 52 96 call 40037298 <__errno> <== NOT EXECUTED
40022844: 01 00 00 00 nop <== NOT EXECUTED
40022848: 40 00 6e 61 call 4003e1cc <strerror> <== NOT EXECUTED
4002284c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40022850: 13 10 01 69 sethi %hi(0x4005a400), %o1 <== NOT EXECUTED
40022854: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40022858: 92 12 61 c8 or %o1, 0x1c8, %o1 <== NOT EXECUTED
4002285c: 10 80 00 0a b 40022884 <rtems_blkstats+0x178> <== NOT EXECUTED
40022860: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
40022864: 40 00 52 8d call 40037298 <__errno> <== NOT EXECUTED
40022868: 01 00 00 00 nop <== NOT EXECUTED
4002286c: 40 00 6e 58 call 4003e1cc <strerror> <== NOT EXECUTED
40022870: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40022874: 13 10 01 69 sethi %hi(0x4005a400), %o1 <== NOT EXECUTED
40022878: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002287c: 92 12 61 e8 or %o1, 0x1e8, %o1 <== NOT EXECUTED
40022880: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40022884: 40 00 55 48 call 40037da4 <fprintf> <== NOT EXECUTED
40022888: 01 00 00 00 nop <== NOT EXECUTED
4002288c: 81 c7 e0 08 ret <== NOT EXECUTED
40022890: 81 e8 00 00 restore <== NOT EXECUTED
4000895c <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
4000895c: 9d e3 bf 98 save %sp, -104, %sp
40008960: 30 80 00 08 b,a 40008980 <rtems_chain_get_with_wait+0x24>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
40008964: 92 10 20 00 clr %o1
40008968: 94 10 00 1a mov %i2, %o2
4000896c: 7f ff fc fb call 40007d58 <rtems_event_receive>
40008970: 96 07 bf fc add %fp, -4, %o3
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
40008974: 80 a2 20 00 cmp %o0, 0
40008978: 32 80 00 09 bne,a 4000899c <rtems_chain_get_with_wait+0x40><== ALWAYS TAKEN
4000897c: 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 );
40008980: 40 00 01 83 call 40008f8c <_Chain_Get>
40008984: 90 10 00 18 mov %i0, %o0
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
40008988: ba 92 20 00 orcc %o0, 0, %i5
4000898c: 02 bf ff f6 be 40008964 <rtems_chain_get_with_wait+0x8>
40008990: 90 10 00 19 mov %i1, %o0
40008994: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
40008998: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
4000899c: 81 c7 e0 08 ret
400089a0: 91 e8 00 08 restore %g0, %o0, %o0
40004464 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40004464: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
40004468: 80 a6 60 00 cmp %i1, 0
4000446c: 02 80 00 7c be 4000465c <rtems_cpu_usage_report_with_plugin+0x1f8><== NEVER TAKEN
40004470: 03 10 00 89 sethi %hi(0x40022400), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
40004474: c0 27 bf e0 clr [ %fp + -32 ]
40004478: 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;
4000447c: f8 18 62 80 ldd [ %g1 + 0x280 ], %i4
}
}
}
#endif
(*print)(
40004480: 90 10 00 18 mov %i0, %o0
40004484: 13 10 00 7b sethi %hi(0x4001ec00), %o1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40004488: 29 10 00 7c sethi %hi(0x4001f000), %l4
}
}
}
#endif
(*print)(
4000448c: 92 12 63 f8 or %o1, 0x3f8, %o1
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40004490: 27 10 00 88 sethi %hi(0x40022000), %l3
40004494: 9f c6 40 00 call %i1
40004498: 2b 10 00 7c sethi %hi(0x4001f000), %l5
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
4000449c: a2 10 20 01 mov 1, %l1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
400044a0: a8 15 21 70 or %l4, 0x170, %l4
400044a4: a6 14 e0 20 or %l3, 0x20, %l3
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400044a8: aa 15 61 88 or %l5, 0x188, %l5
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
400044ac: 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 ];
400044b0: 05 10 00 88 sethi %hi(0x40022000), %g2
400044b4: 84 10 a0 34 or %g2, 0x34, %g2 ! 40022034 <_Objects_Information_table>
400044b8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
400044bc: e4 00 60 04 ld [ %g1 + 4 ], %l2
if ( information ) {
400044c0: 80 a4 a0 00 cmp %l2, 0
400044c4: 12 80 00 4a bne 400045ec <rtems_cpu_usage_report_with_plugin+0x188><== ALWAYS TAKEN
400044c8: 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++ ) {
400044cc: a2 04 60 01 inc %l1 <== NOT EXECUTED
400044d0: 80 a4 60 04 cmp %l1, 4
400044d4: 12 bf ff f7 bne 400044b0 <rtems_cpu_usage_report_with_plugin+0x4c>
400044d8: 83 2c 60 02 sll %l1, 2, %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
400044dc: 10 80 00 4a b 40004604 <rtems_cpu_usage_report_with_plugin+0x1a0>
400044e0: 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 ];
400044e4: 83 2c 20 02 sll %l0, 2, %g1
400044e8: f6 00 80 01 ld [ %g2 + %g1 ], %i3
if ( !the_thread )
400044ec: 80 a6 e0 00 cmp %i3, 0
400044f0: 02 80 00 3e be 400045e8 <rtems_cpu_usage_report_with_plugin+0x184><== NEVER TAKEN
400044f4: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
400044f8: d0 06 e0 08 ld [ %i3 + 8 ], %o0
400044fc: 40 00 13 52 call 40009244 <rtems_object_get_name>
40004500: 94 07 bf f0 add %fp, -16, %o2
(*print)(
40004504: d4 06 e0 08 ld [ %i3 + 8 ], %o2
40004508: 90 10 00 18 mov %i0, %o0
4000450c: 92 10 00 14 mov %l4, %o1
40004510: 9f c6 40 00 call %i1
40004514: 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;
40004518: 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 ) {
4000451c: 03 10 00 89 sethi %hi(0x40022400), %g1
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
40004520: 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 ) {
40004524: 82 10 62 20 or %g1, 0x220, %g1
40004528: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000452c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
40004530: c4 06 e0 08 ld [ %i3 + 8 ], %g2
40004534: 80 a0 c0 02 cmp %g3, %g2
40004538: 12 80 00 4b bne 40004664 <rtems_cpu_usage_report_with_plugin+0x200>
4000453c: 90 07 bf d8 add %fp, -40, %o0
*time_of_context_switch = _Thread_Time_of_last_context_switch;
40004540: f4 18 60 20 ldd [ %g1 + 0x20 ], %i2
40004544: 40 00 18 56 call 4000a69c <_TOD_Get_with_nanoseconds>
40004548: 92 10 00 13 mov %l3, %o1
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
4000454c: d8 1f bf e8 ldd [ %fp + -24 ], %o4
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40004550: c4 1f bf d8 ldd [ %fp + -40 ], %g2
40004554: 86 a0 c0 1b subcc %g3, %i3, %g3
40004558: 84 60 80 1a subx %g2, %i2, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
4000455c: 96 83 40 03 addcc %o5, %g3, %o3
40004560: 94 43 00 02 addx %o4, %g2, %o2
40004564: d4 3f bf e8 std %o2, [ %fp + -24 ]
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40004568: 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 );
4000456c: 90 07 bf e8 add %fp, -24, %o0
40004570: 86 a0 c0 1d subcc %g3, %i5, %g3
40004574: 84 60 80 1c subx %g2, %i4, %g2
40004578: 92 07 bf e0 add %fp, -32, %o1
4000457c: c4 3f bf e0 std %g2, [ %fp + -32 ]
40004580: 94 07 bf d0 add %fp, -48, %o2
40004584: 40 00 21 88 call 4000cba4 <_Timestamp64_Divide>
40004588: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
4000458c: 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);
40004590: 94 10 20 00 clr %o2
40004594: 90 10 00 1a mov %i2, %o0
40004598: 92 10 00 1b mov %i3, %o1
4000459c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400045a0: 40 00 5b 8c call 4001b3d0 <__divdi3>
400045a4: 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);
400045a8: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400045ac: ac 10 00 09 mov %o1, %l6
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400045b0: 90 10 00 1a mov %i2, %o0
400045b4: 92 10 00 1b mov %i3, %o1
400045b8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400045bc: 40 00 5c 70 call 4001b77c <__moddi3>
400045c0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
400045c4: 90 10 00 09 mov %o1, %o0
400045c8: 40 00 5a 2a call 4001ae70 <.udiv>
400045cc: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400045d0: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
400045d4: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400045d8: 92 10 00 15 mov %l5, %o1
400045dc: 90 10 00 18 mov %i0, %o0
400045e0: 9f c6 40 00 call %i1
400045e4: 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++ ) {
400045e8: a0 04 20 01 inc %l0
400045ec: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1
400045f0: 80 a4 00 01 cmp %l0, %g1
400045f4: 28 bf ff bc bleu,a 400044e4 <rtems_cpu_usage_report_with_plugin+0x80>
400045f8: 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++ ) {
400045fc: 10 bf ff b5 b 400044d0 <rtems_cpu_usage_report_with_plugin+0x6c>
40004600: a2 04 60 01 inc %l1
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
40004604: 94 10 20 00 clr %o2
40004608: 90 10 00 1c mov %i4, %o0
4000460c: 92 10 00 1d mov %i5, %o1
40004610: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40004614: 40 00 5b 6f call 4001b3d0 <__divdi3>
40004618: 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);
4000461c: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
40004620: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
40004624: 90 10 00 1c mov %i4, %o0
40004628: 92 10 00 1d mov %i5, %o1
4000462c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40004630: 40 00 5c 53 call 4001b77c <__moddi3>
40004634: 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 ) /
40004638: 90 10 00 09 mov %o1, %o0
4000463c: 40 00 5a 0d call 4001ae70 <.udiv>
40004640: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
40004644: 13 10 00 7c sethi %hi(0x4001f000), %o1
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
40004648: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
4000464c: 92 12 61 a0 or %o1, 0x1a0, %o1
40004650: 90 10 00 18 mov %i0, %o0
40004654: 9f c6 40 00 call %i1
40004658: 94 10 00 1b mov %i3, %o2
4000465c: 81 c7 e0 08 ret
40004660: 81 e8 00 00 restore
40004664: 40 00 18 0e call 4000a69c <_TOD_Get_with_nanoseconds>
40004668: 92 10 00 13 mov %l3, %o1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4000466c: 10 bf ff c0 b 4000456c <rtems_cpu_usage_report_with_plugin+0x108>
40004670: c4 1f bf d8 ldd [ %fp + -40 ], %g2
4000f9fc <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
4000f9fc: 9d e3 bf a0 save %sp, -96, %sp
if (sc == RTEMS_SUCCESSFUL) {
4000fa00: 80 a6 20 00 cmp %i0, 0
4000fa04: 02 80 00 0d be 4000fa38 <rtems_deviceio_errno+0x3c>
4000fa08: 82 10 20 00 clr %g1
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4000fa0c: 80 a6 20 1c cmp %i0, 0x1c
4000fa10: 18 80 00 06 bgu 4000fa28 <rtems_deviceio_errno+0x2c> <== NEVER TAKEN
4000fa14: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
4000fa18: b1 2e 20 02 sll %i0, 2, %i0
4000fa1c: 03 10 00 76 sethi %hi(0x4001d800), %g1
4000fa20: 82 10 61 78 or %g1, 0x178, %g1 ! 4001d978 <status_code_to_errno>
4000fa24: fa 00 40 18 ld [ %g1 + %i0 ], %i5
}
errno = eno;
4000fa28: 40 00 00 2f call 4000fae4 <__errno>
4000fa2c: 01 00 00 00 nop
return -1;
4000fa30: 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;
4000fa34: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
4000fa38: 81 c7 e0 08 ret
4000fa3c: 91 e8 00 01 restore %g0, %g1, %o0
40004514 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
40004514: 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;
40004518: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
4000451c: 7f ff ff 11 call 40004160 <disk_lock>
40004520: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
40004524: a0 92 20 00 orcc %o0, 0, %l0
40004528: 32 80 00 2b bne,a 400045d4 <rtems_disk_create_log+0xc0> <== NEVER TAKEN
4000452c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return sc;
}
phys_dd = get_disk_entry(phys, true);
40004530: 92 10 00 1b mov %i3, %o1
40004534: 90 10 00 1a mov %i2, %o0
40004538: 7f ff fe cf call 40004074 <get_disk_entry>
4000453c: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
40004540: b6 92 20 00 orcc %o0, 0, %i3
40004544: 12 80 00 06 bne 4000455c <rtems_disk_create_log+0x48>
40004548: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
4000454c: 7f ff ff 14 call 4000419c <disk_unlock>
40004550: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
40004554: 81 c7 e0 08 ret
40004558: 91 e8 00 10 restore %g0, %l0, %o0
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
4000455c: 90 10 00 18 mov %i0, %o0
40004560: 92 10 00 19 mov %i1, %o1
40004564: 96 07 bf f8 add %fp, -8, %o3
40004568: 7f ff ff 1a call 400041d0 <create_disk>
4000456c: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
40004570: a0 92 20 00 orcc %o0, 0, %l0
40004574: 12 80 00 16 bne 400045cc <rtems_disk_create_log+0xb8>
40004578: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
4000457c: 92 10 00 1b mov %i3, %o1
40004580: 94 10 00 1c mov %i4, %o2
40004584: 40 00 2e 83 call 4000ff90 <rtems_disk_init_log>
40004588: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
4000458c: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
40004590: c4 07 bf fc ld [ %fp + -4 ], %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
40004594: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
40004598: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
++phys_dd->uses;
4000459c: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
400045a0: a0 10 00 08 mov %o0, %l0
);
dd->dev = dev;
dd->name = alloc_name;
++phys_dd->uses;
400045a4: 84 00 a0 01 inc %g2
if (sc != RTEMS_SUCCESSFUL) {
400045a8: 80 a2 20 00 cmp %o0, 0
400045ac: 02 80 00 08 be 400045cc <rtems_disk_create_log+0xb8>
400045b0: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
dd->ioctl = null_handler;
400045b4: 05 10 00 10 sethi %hi(0x40004000), %g2
400045b8: 84 10 a1 04 or %g2, 0x104, %g2 ! 40004104 <null_handler>
rtems_disk_delete(dev);
400045bc: 90 10 00 18 mov %i0, %o0
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
400045c0: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
400045c4: 7f ff ff 6c call 40004374 <rtems_disk_delete>
400045c8: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
400045cc: 7f ff fe f4 call 4000419c <disk_unlock>
400045d0: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
400045d4: 81 c7 e0 08 ret
400045d8: 81 e8 00 00 restore
400045dc <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
400045dc: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
400045e0: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
400045e4: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
400045e8: 80 a7 20 00 cmp %i4, 0
400045ec: 02 80 00 23 be 40004678 <rtems_disk_create_phys+0x9c>
400045f0: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
400045f4: 7f ff fe db call 40004160 <disk_lock>
400045f8: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400045fc: a0 92 20 00 orcc %o0, 0, %l0
40004600: 12 80 00 1e bne 40004678 <rtems_disk_create_phys+0x9c> <== NEVER TAKEN
40004604: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
40004608: 90 10 00 18 mov %i0, %o0
4000460c: 92 10 00 19 mov %i1, %o1
40004610: 96 07 bf f8 add %fp, -8, %o3
40004614: 7f ff fe ef call 400041d0 <create_disk>
40004618: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
4000461c: a0 92 20 00 orcc %o0, 0, %l0
40004620: 12 80 00 14 bne 40004670 <rtems_disk_create_phys+0x94>
40004624: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
40004628: 92 10 00 1a mov %i2, %o1
4000462c: 94 10 00 1b mov %i3, %o2
40004630: 96 10 00 1c mov %i4, %o3
40004634: 40 00 2e 3d call 4000ff28 <rtems_disk_init_phys>
40004638: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
4000463c: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
40004640: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
40004644: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
40004648: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
4000464c: 80 a2 20 00 cmp %o0, 0
40004650: 02 80 00 08 be 40004670 <rtems_disk_create_phys+0x94>
40004654: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
40004658: 05 10 00 10 sethi %hi(0x40004000), %g2
4000465c: 84 10 a1 04 or %g2, 0x104, %g2 ! 40004104 <null_handler>
rtems_disk_delete(dev);
40004660: 90 10 00 18 mov %i0, %o0
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
40004664: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
40004668: 7f ff ff 43 call 40004374 <rtems_disk_delete>
4000466c: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
40004670: 7f ff fe cb call 4000419c <disk_unlock>
40004674: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
40004678: 81 c7 e0 08 ret
4000467c: 91 e8 00 10 restore %g0, %l0, %o0
40004374 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
40004374: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
40004378: 7f ff ff 7a call 40004160 <disk_lock>
4000437c: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
40004380: b0 92 20 00 orcc %o0, 0, %i0
40004384: 12 80 00 0a bne 400043ac <rtems_disk_delete+0x38> <== NEVER TAKEN
40004388: 90 10 00 1c mov %i4, %o0
return sc;
}
dd = get_disk_entry(dev, true);
4000438c: 92 10 00 19 mov %i1, %o1
40004390: 7f ff ff 39 call 40004074 <get_disk_entry>
40004394: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
40004398: 82 92 20 00 orcc %o0, 0, %g1
4000439c: 32 80 00 06 bne,a 400043b4 <rtems_disk_delete+0x40> <== ALWAYS TAKEN
400043a0: fa 00 60 08 ld [ %g1 + 8 ], %i5
disk_unlock();
400043a4: 7f ff ff 7e call 4000419c <disk_unlock> <== NOT EXECUTED
400043a8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
400043ac: 81 c7 e0 08 ret <== NOT EXECUTED
400043b0: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INVALID_ID;
}
dd->deleted = true;
400043b4: 84 10 20 01 mov 1, %g2
400043b8: 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) {
400043bc: c4 0f 60 40 ldub [ %i5 + 0x40 ], %g2
400043c0: 80 a0 a0 00 cmp %g2, 0
400043c4: 22 80 00 41 be,a 400044c8 <rtems_disk_delete+0x154>
400043c8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
400043cc: e2 07 40 00 ld [ %i5 ], %l1
400043d0: e4 07 60 04 ld [ %i5 + 4 ], %l2
unsigned deleted_count = 0;
400043d4: b4 10 20 00 clr %i2
for (major = 0; major < disktab_size; ++major) {
400043d8: b8 10 20 00 clr %i4
400043dc: 21 10 00 6c sethi %hi(0x4001b000), %l0
rtems_disk_device_table *dtab = disktab + major;
400043e0: 27 10 00 6c sethi %hi(0x4001b000), %l3
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
400043e4: 10 80 00 26 b 4000447c <rtems_disk_delete+0x108>
400043e8: a8 10 20 01 mov 1, %l4
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400043ec: 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) {
400043f0: 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;
400043f4: 10 80 00 1d b 40004468 <rtems_disk_delete+0xf4>
400043f8: b2 06 40 01 add %i1, %g1, %i1
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400043fc: 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];
40004400: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
40004404: 80 a2 20 00 cmp %o0, 0
40004408: 22 80 00 18 be,a 40004468 <rtems_disk_delete+0xf4>
4000440c: b6 06 e0 01 inc %i3
40004410: c8 02 20 08 ld [ %o0 + 8 ], %g4
40004414: de 01 00 00 ld [ %g4 ], %o7
40004418: 80 a3 c0 11 cmp %o7, %l1
4000441c: 32 80 00 13 bne,a 40004468 <rtems_disk_delete+0xf4> <== NEVER TAKEN
40004420: b6 06 e0 01 inc %i3 <== NOT EXECUTED
40004424: c8 01 20 04 ld [ %g4 + 4 ], %g4
40004428: 80 a1 00 12 cmp %g4, %l2
4000442c: 32 80 00 0f bne,a 40004468 <rtems_disk_delete+0xf4> <== NEVER TAKEN
40004430: b6 06 e0 01 inc %i3 <== NOT EXECUTED
40004434: 80 a2 00 1d cmp %o0, %i5
40004438: 22 80 00 0c be,a 40004468 <rtems_disk_delete+0xf4>
4000443c: b6 06 e0 01 inc %i3
if (dd->uses == 0) {
40004440: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
40004444: 80 a1 20 00 cmp %g4, 0
40004448: 32 80 00 07 bne,a 40004464 <rtems_disk_delete+0xf0>
4000444c: e8 2a 20 40 stb %l4, [ %o0 + 0x40 ]
++deleted_count;
40004450: b4 06 a0 01 inc %i2
dtab->minor [minor] = NULL;
free_disk_device(dd);
40004454: 7f ff ff 2e call 4000410c <free_disk_device>
40004458: 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) {
4000445c: 10 80 00 03 b 40004468 <rtems_disk_delete+0xf4>
40004460: b6 06 e0 01 inc %i3
40004464: b6 06 e0 01 inc %i3
40004468: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000446c: 80 a6 c0 01 cmp %i3, %g1
40004470: 2a bf ff e3 bcs,a 400043fc <rtems_disk_delete+0x88>
40004474: 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) {
40004478: b8 07 20 01 inc %i4
4000447c: c2 04 23 10 ld [ %l0 + 0x310 ], %g1
40004480: 80 a7 00 01 cmp %i4, %g1
40004484: 2a bf ff da bcs,a 400043ec <rtems_disk_delete+0x78>
40004488: f2 04 e3 14 ld [ %l3 + 0x314 ], %i1
}
}
}
}
physical_disk->uses -= deleted_count;
4000448c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40004490: b4 20 40 1a sub %g1, %i2, %i2
if (physical_disk->uses == 0) {
40004494: 80 a6 a0 00 cmp %i2, 0
40004498: 12 80 00 1b bne 40004504 <rtems_disk_delete+0x190>
4000449c: f4 27 60 14 st %i2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
400044a0: c4 07 40 00 ld [ %i5 ], %g2
disktab [major].minor [minor] = NULL;
400044a4: 07 10 00 6c sethi %hi(0x4001b000), %g3
400044a8: c6 00 e3 14 ld [ %g3 + 0x314 ], %g3 ! 4001b314 <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
400044ac: c2 07 60 04 ld [ %i5 + 4 ], %g1
disktab [major].minor [minor] = NULL;
400044b0: 85 28 a0 03 sll %g2, 3, %g2
400044b4: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
400044b8: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
400044bc: 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;
400044c0: 10 80 00 0f b 400044fc <rtems_disk_delete+0x188>
400044c4: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
400044c8: 80 a0 a0 00 cmp %g2, 0
400044cc: 12 80 00 0e bne 40004504 <rtems_disk_delete+0x190> <== NEVER TAKEN
400044d0: 07 10 00 6c sethi %hi(0x4001b000), %g3
--physical_disk->uses;
400044d4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
400044d8: 84 00 bf ff add %g2, -1, %g2
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
400044dc: c6 00 e3 14 ld [ %g3 + 0x314 ], %g3
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
400044e0: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
400044e4: c4 00 40 00 ld [ %g1 ], %g2
400044e8: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
400044ec: 85 28 a0 03 sll %g2, 3, %g2
400044f0: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
400044f4: 83 28 60 02 sll %g1, 2, %g1
400044f8: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(disk_to_remove);
400044fc: 7f ff ff 04 call 4000410c <free_disk_device>
40004500: 01 00 00 00 nop
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
40004504: 7f ff ff 26 call 4000419c <disk_unlock>
40004508: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
4000450c: 81 c7 e0 08 ret
40004510: 81 e8 00 00 restore
40004834 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
40004834: 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) {
40004838: 39 10 00 6c sethi %hi(0x4001b000), %i4
4000483c: c2 07 23 10 ld [ %i4 + 0x310 ], %g1 ! 4001b310 <disktab_size>
40004840: 80 a0 60 00 cmp %g1, 0
40004844: 12 80 00 19 bne 400048a8 <rtems_disk_io_initialize+0x74>
40004848: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
4000484c: 90 10 20 08 mov 8, %o0
40004850: 92 10 20 08 mov 8, %o1
40004854: 40 00 02 1d call 400050c8 <calloc>
40004858: 3b 10 00 6c sethi %hi(0x4001b000), %i5
4000485c: d0 27 63 14 st %o0, [ %i5 + 0x314 ] ! 4001b314 <disktab>
if (disktab == NULL) {
40004860: 80 a2 20 00 cmp %o0, 0
40004864: 02 80 00 11 be 400048a8 <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
40004868: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
4000486c: 03 10 00 6c sethi %hi(0x4001b000), %g1
sc = rtems_semaphore_create(
40004870: 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;
40004874: c0 28 63 08 clrb [ %g1 + 0x308 ]
sc = rtems_semaphore_create(
40004878: 90 12 21 56 or %o0, 0x156, %o0
4000487c: 92 10 20 01 mov 1, %o1
40004880: 94 10 20 10 mov 0x10, %o2
40004884: 96 10 20 00 clr %o3
40004888: 37 10 00 6c sethi %hi(0x4001b000), %i3
4000488c: 40 00 12 55 call 400091e0 <rtems_semaphore_create>
40004890: 98 16 e3 0c or %i3, 0x30c, %o4 ! 4001b30c <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
40004894: 80 a2 20 00 cmp %o0, 0
40004898: 02 80 00 06 be 400048b0 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
4000489c: 01 00 00 00 nop
free(disktab);
400048a0: 40 00 02 42 call 400051a8 <free> <== NOT EXECUTED
400048a4: d0 07 63 14 ld [ %i5 + 0x314 ], %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
400048a8: 81 c7 e0 08 ret
400048ac: 81 e8 00 00 restore
}
sc = rtems_bdbuf_init();
400048b0: 40 00 29 2c call 4000ed60 <rtems_bdbuf_init>
400048b4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400048b8: 80 a2 20 00 cmp %o0, 0
400048bc: 02 80 00 09 be 400048e0 <rtems_disk_io_initialize+0xac> <== ALWAYS TAKEN
400048c0: 82 10 20 08 mov 8, %g1
rtems_semaphore_delete(diskdevs_mutex);
400048c4: d0 06 e3 0c ld [ %i3 + 0x30c ], %o0 <== NOT EXECUTED
400048c8: 40 00 12 b4 call 40009398 <rtems_semaphore_delete> <== NOT EXECUTED
400048cc: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
free(disktab);
400048d0: 40 00 02 36 call 400051a8 <free> <== NOT EXECUTED
400048d4: d0 07 63 14 ld [ %i5 + 0x314 ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
400048d8: 81 c7 e0 08 ret <== NOT EXECUTED
400048dc: 81 e8 00 00 restore <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
400048e0: b0 10 20 00 clr %i0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
400048e4: c2 27 23 10 st %g1, [ %i4 + 0x310 ]
return RTEMS_SUCCESSFUL;
}
400048e8: 81 c7 e0 08 ret
400048ec: 81 e8 00 00 restore
40004744 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
40004744: 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) {
40004748: 80 a6 3f ff cmp %i0, -1
4000474c: 12 80 00 05 bne 40004760 <rtems_disk_next+0x1c>
40004750: b8 06 60 01 add %i1, 1, %i4
40004754: 80 a6 7f ff cmp %i1, -1
40004758: 22 80 00 0b be,a 40004784 <rtems_disk_next+0x40> <== ALWAYS TAKEN
4000475c: b8 10 20 00 clr %i4
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
40004760: 80 a7 00 19 cmp %i4, %i1
40004764: 1a 80 00 09 bcc 40004788 <rtems_disk_next+0x44> <== ALWAYS TAKEN
40004768: ba 10 00 18 mov %i0, %i5
/* If major wraps around */
if ((major + 1) < major) {
4000476c: ba 06 20 01 add %i0, 1, %i5 <== NOT EXECUTED
40004770: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
40004774: 1a 80 00 05 bcc 40004788 <rtems_disk_next+0x44> <== NOT EXECUTED
40004778: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
if (major >= disktab_size) {
disk_unlock();
return NULL;
4000477c: 81 c7 e0 08 ret <== NOT EXECUTED
40004780: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40004784: ba 10 20 00 clr %i5
} else {
++minor;
}
}
sc = disk_lock();
40004788: 7f ff fe 76 call 40004160 <disk_lock>
4000478c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40004790: 80 a2 20 00 cmp %o0, 0
40004794: 12 80 00 08 bne 400047b4 <rtems_disk_next+0x70> <== NEVER TAKEN
40004798: 03 10 00 6c sethi %hi(0x4001b000), %g1
return NULL;
}
if (major >= disktab_size) {
4000479c: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 4001b310 <disktab_size>
400047a0: 80 a7 40 02 cmp %i5, %g2
400047a4: 0a 80 00 06 bcs 400047bc <rtems_disk_next+0x78> <== ALWAYS TAKEN
400047a8: 03 10 00 6c sethi %hi(0x4001b000), %g1
disk_unlock();
400047ac: 7f ff fe 7c call 4000419c <disk_unlock>
400047b0: 01 00 00 00 nop
return NULL;
400047b4: 81 c7 e0 08 ret
400047b8: 91 e8 20 00 restore %g0, 0, %o0
}
dtab = disktab + major;
400047bc: c6 00 63 14 ld [ %g1 + 0x314 ], %g3
400047c0: b7 2f 60 03 sll %i5, 3, %i3
400047c4: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
400047c8: c2 06 c0 00 ld [ %i3 ], %g1
400047cc: 80 a0 60 00 cmp %g1, 0
400047d0: 22 80 00 07 be,a 400047ec <rtems_disk_next+0xa8>
400047d4: ba 07 60 01 inc %i5
400047d8: c8 06 e0 04 ld [ %i3 + 4 ], %g4
400047dc: 80 a7 00 04 cmp %i4, %g4
400047e0: 0a 80 00 09 bcs 40004804 <rtems_disk_next+0xc0>
400047e4: b5 2f 20 02 sll %i4, 2, %i2
minor = 0;
++major;
400047e8: ba 07 60 01 inc %i5
if (major >= disktab_size) {
400047ec: 80 a7 40 02 cmp %i5, %g2
400047f0: 1a bf ff ef bcc 400047ac <rtems_disk_next+0x68>
400047f4: b7 2f 60 03 sll %i5, 3, %i3
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
400047f8: b8 10 20 00 clr %i4
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
400047fc: 10 bf ff f3 b 400047c8 <rtems_disk_next+0x84>
40004800: b6 00 c0 1b add %g3, %i3, %i3
} else if (dtab->minor [minor] == NULL) {
40004804: c2 00 40 1a ld [ %g1 + %i2 ], %g1
40004808: 80 a0 60 00 cmp %g1, 0
4000480c: 02 bf ff ef be 400047c8 <rtems_disk_next+0x84>
40004810: b8 07 20 01 inc %i4
++minor;
} else {
++dtab->minor [minor]->uses;
40004814: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40004818: 84 00 a0 01 inc %g2
disk_unlock();
4000481c: 7f ff fe 60 call 4000419c <disk_unlock>
40004820: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return dtab->minor [minor];
40004824: c2 06 c0 00 ld [ %i3 ], %g1
40004828: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
4000482c: 81 c7 e0 08 ret
40004830: 81 e8 00 00 restore
40004680 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
40004680: 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);
40004684: 7f ff f9 74 call 40002c54 <sparc_disable_interrupts>
40004688: b8 10 00 18 mov %i0, %i4
4000468c: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
40004690: 03 10 00 6c sethi %hi(0x4001b000), %g1
40004694: c2 08 63 08 ldub [ %g1 + 0x308 ], %g1 ! 4001b308 <diskdevs_protected>
40004698: 80 a0 60 00 cmp %g1, 0
4000469c: 12 80 00 0a bne 400046c4 <rtems_disk_obtain+0x44> <== NEVER TAKEN
400046a0: 92 10 00 19 mov %i1, %o1
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
400046a4: 90 10 00 18 mov %i0, %o0
400046a8: 7f ff fe 73 call 40004074 <get_disk_entry>
400046ac: 94 10 20 00 clr %o2
400046b0: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
400046b4: 7f ff f9 6c call 40002c64 <sparc_enable_interrupts>
400046b8: 90 10 00 1b mov %i3, %o0
400046bc: 81 c7 e0 08 ret
400046c0: 81 e8 00 00 restore
} else {
rtems_interrupt_enable(level);
400046c4: 7f ff f9 68 call 40002c64 <sparc_enable_interrupts> <== NOT EXECUTED
400046c8: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
400046cc: 7f ff fe a5 call 40004160 <disk_lock> <== NOT EXECUTED
400046d0: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
400046d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400046d8: 12 bf ff f9 bne 400046bc <rtems_disk_obtain+0x3c> <== NOT EXECUTED
400046dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
400046e0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400046e4: 7f ff fe 64 call 40004074 <get_disk_entry> <== NOT EXECUTED
400046e8: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
400046ec: 7f ff fe ac call 4000419c <disk_unlock> <== NOT EXECUTED
400046f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
400046f4: 81 c7 e0 08 ret <== NOT EXECUTED
400046f8: 81 e8 00 00 restore <== NOT EXECUTED
400119d8 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
400119d8: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
400119dc: 80 a6 e0 00 cmp %i3, 0
400119e0: 02 80 00 1e be 40011a58 <rtems_event_system_receive+0x80> <== NEVER TAKEN
400119e4: 82 10 20 09 mov 9, %g1
Thread_Control *executing = _Thread_Executing;
400119e8: 03 10 00 6f sethi %hi(0x4001bc00), %g1
400119ec: fa 00 62 60 ld [ %g1 + 0x260 ], %i5 ! 4001be60 <_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 ) ) {
400119f0: 80 a6 20 00 cmp %i0, 0
400119f4: 02 80 00 16 be 40011a4c <rtems_event_system_receive+0x74> <== NEVER TAKEN
400119f8: 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;
400119fc: 03 10 00 6e sethi %hi(0x4001b800), %g1
40011a00: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001b940 <_Thread_Dispatch_disable_level>
++level;
40011a04: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40011a08: c4 20 61 40 st %g2, [ %g1 + 0x140 ]
_Thread_Disable_dispatch();
_Event_Seize(
40011a0c: 03 10 00 70 sethi %hi(0x4001c000), %g1
40011a10: 82 10 62 50 or %g1, 0x250, %g1 ! 4001c250 <_System_event_Sync_state>
40011a14: 90 10 00 18 mov %i0, %o0
40011a18: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40011a1c: 92 10 00 19 mov %i1, %o1
40011a20: 03 00 01 00 sethi %hi(0x40000), %g1
40011a24: 94 10 00 1a mov %i2, %o2
40011a28: 96 10 00 1b mov %i3, %o3
40011a2c: 98 10 00 1d mov %i5, %o4
40011a30: 9a 03 60 04 add %o5, 4, %o5
40011a34: 7f ff dd 1a call 40008e9c <_Event_Seize>
40011a38: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
40011a3c: 7f ff e8 f9 call 4000be20 <_Thread_Enable_dispatch>
40011a40: 01 00 00 00 nop
sc = executing->Wait.return_code;
40011a44: 10 80 00 05 b 40011a58 <rtems_event_system_receive+0x80>
40011a48: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
} else {
*event_out = event->pending_events;
40011a4c: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED
40011a50: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40011a54: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
40011a58: 81 c7 e0 08 ret
40011a5c: 91 e8 00 01 restore %g0, %g1, %o0
400081c0 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
400081c0: 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 );
400081c4: 90 10 00 18 mov %i0, %o0
400081c8: 40 00 09 c0 call 4000a8c8 <_Thread_Get>
400081cc: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
400081d0: c4 07 bf fc ld [ %fp + -4 ], %g2
400081d4: 80 a0 a0 00 cmp %g2, 0
400081d8: 12 80 00 0d bne 4000820c <rtems_event_system_send+0x4c> <== NEVER TAKEN
400081dc: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
400081e0: d4 02 21 4c ld [ %o0 + 0x14c ], %o2
400081e4: 94 02 a0 04 add %o2, 4, %o2
400081e8: 19 00 01 00 sethi %hi(0x40000), %o4
400081ec: 17 10 00 7f sethi %hi(0x4001fc00), %o3
400081f0: 96 12 e1 90 or %o3, 0x190, %o3 ! 4001fd90 <_System_event_Sync_state>
400081f4: 7f ff fe 64 call 40007b84 <_Event_Surrender>
400081f8: b0 10 20 00 clr %i0
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
400081fc: 40 00 09 a7 call 4000a898 <_Thread_Enable_dispatch>
40008200: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
break;
40008204: 81 c7 e0 08 ret
40008208: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
4000820c: 81 c7 e0 08 ret <== NOT EXECUTED
40008210: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
40007e5c <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, ...)
40007e5c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
40007e60: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
40007e64: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
40007e68: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
40007e6c: 3b 10 00 de sethi %hi(0x40037800), %i5 <== NOT EXECUTED
40007e70: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 ! 40037bc8 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
40007e74: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40007e78: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40007e7c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40007e80: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
40007e84: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40007e88: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40007e8c: 40 00 67 1b call 40021af8 <fputs> <== NOT EXECUTED
40007e90: 90 12 21 78 or %o0, 0x178, %o0 ! 40032978 <Callbacks.6428+0x160><== NOT EXECUTED
vfprintf (stderr, format, args);
40007e94: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40007e98: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40007e9c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40007ea0: 40 00 67 16 call 40021af8 <fputs> <== NOT EXECUTED
40007ea4: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
40007ea8: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40007eac: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
40007eb0: 40 00 66 de call 40021a28 <fputc> <== NOT EXECUTED
40007eb4: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
40007eb8: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40007ebc: 40 00 65 c3 call 400215c8 <fflush> <== NOT EXECUTED
40007ec0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
40007ec4: 40 00 64 c1 call 400211c8 <exit> <== NOT EXECUTED
40007ec8: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
40006594 <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)
{
40006594: 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)
40006598: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
4000659c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400065a0: 80 a0 80 01 cmp %g2, %g1
400065a4: 1a 80 00 72 bcc 4000676c <rtems_fdisk_compact+0x1d8>
400065a8: ba 10 00 18 mov %i0, %i5
fd->starvations++;
400065ac: 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");
400065b0: 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++;
400065b4: 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");
400065b8: 13 10 00 cb sethi %hi(0x40032c00), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
400065bc: 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");
400065c0: 7f ff fc ac call 40005870 <rtems_fdisk_printf>
400065c4: 92 12 61 50 or %o1, 0x150, %o1
#endif
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
400065c8: 7f ff fb d6 call 40005520 <rtems_fdisk_segment_queue_pop_head>
400065cc: 90 06 20 40 add %i0, 0x40, %o0
if (!ssc)
400065d0: b8 92 20 00 orcc %o0, 0, %i4
400065d4: 12 80 00 07 bne 400065f0 <rtems_fdisk_compact+0x5c> <== ALWAYS TAKEN
400065d8: 01 00 00 00 nop
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
400065dc: 7f ff fb d1 call 40005520 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
400065e0: 90 06 20 34 add %i0, 0x34, %o0 <== NOT EXECUTED
if (ssc)
400065e4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400065e8: 02 80 00 12 be 40006630 <rtems_fdisk_compact+0x9c> <== NOT EXECUTED
400065ec: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
400065f0: 7f ff fc 6e call 400057a8 <rtems_fdisk_seg_most_available>
400065f4: 90 07 60 34 add %i5, 0x34, %o0
if (dsc)
400065f8: 94 92 20 00 orcc %o0, 0, %o2
400065fc: 02 80 00 0a be 40006624 <rtems_fdisk_compact+0x90> <== NEVER TAKEN
40006600: 92 10 00 1c mov %i4, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
40006604: 90 10 00 1d mov %i5, %o0
40006608: 7f ff ff 02 call 40006210 <rtems_fdisk_recycle_segment>
4000660c: 96 07 bf fc add %fp, -4, %o3
if (ret)
40006610: 80 a2 20 00 cmp %o0, 0
40006614: 02 80 00 57 be 40006770 <rtems_fdisk_compact+0x1dc> <== ALWAYS TAKEN
40006618: 21 10 00 cb sethi %hi(0x40032c00), %l0
compacted_segs += segments;
}
return 0;
}
4000661c: 81 c7 e0 08 ret <== NOT EXECUTED
40006620: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
40006624: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006628: 10 80 00 03 b 40006634 <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
4000662c: 90 12 21 68 or %o0, 0x168, %o0 ! 40032d68 <Callbacks.6428+0x550><== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
40006630: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
40006634: 7f ff fc cf call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006638: 01 00 00 00 nop <== NOT EXECUTED
return EIO;
4000663c: 10 80 00 61 b 400067c0 <rtems_fdisk_compact+0x22c> <== NOT EXECUTED
40006640: 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");
40006644: 7f ff fc 8b call 40005870 <rtems_fdisk_printf>
40006648: 90 10 00 1d mov %i5, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
4000664c: 7f ff fc 57 call 400057a8 <rtems_fdisk_seg_most_available>
40006650: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
40006654: b6 92 20 00 orcc %o0, 0, %i3
40006658: 12 80 00 05 bne 4000666c <rtems_fdisk_compact+0xd8> <== ALWAYS TAKEN
4000665c: 01 00 00 00 nop
{
rtems_fdisk_error ("compacting: no available segments to compact too");
40006660: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006664: 10 bf ff f4 b 40006634 <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
40006668: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 40032db0 <Callbacks.6428+0x598><== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
4000666c: 7f ff fc 47 call 40005788 <rtems_fdisk_seg_pages_available>
40006670: 01 00 00 00 nop
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
40006674: d4 06 e0 08 ld [ %i3 + 8 ], %o2
40006678: d6 06 e0 0c ld [ %i3 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
4000667c: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
dst_pages = rtems_fdisk_seg_pages_available (dsc);
40006680: b0 10 00 08 mov %o0, %i0
segments = 0;
pages = 0;
40006684: c0 27 bf fc clr [ %fp + -4 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
40006688: 90 10 00 1d mov %i5, %o0
4000668c: 7f ff fc 79 call 40005870 <rtems_fdisk_printf>
40006690: 92 10 00 11 mov %l1, %o1
40006694: 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 &&
40006698: 10 80 00 04 b 400066a8 <rtems_fdisk_compact+0x114>
4000669c: 9a 10 20 00 clr %o5
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
400066a0: 9a 03 60 01 inc %o5
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
400066a4: 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 &&
400066a8: 80 a7 20 00 cmp %i4, 0
400066ac: 32 80 00 09 bne,a 400066d0 <rtems_fdisk_compact+0x13c>
400066b0: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
400066b4: 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");
400066b8: 90 10 00 1d mov %i5, %o0
400066bc: 13 10 00 cb sethi %hi(0x40032c00), %o1
400066c0: 7f ff fc 6c call 40005870 <rtems_fdisk_printf>
400066c4: 92 12 62 08 or %o1, 0x208, %o1 ! 40032e08 <Callbacks.6428+0x5f0>
}
compacted_segs += segments;
}
return 0;
400066c8: 10 80 00 3e b 400067c0 <rtems_fdisk_compact+0x22c>
400066cc: 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) &&
400066d0: 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 &&
400066d4: 80 a0 40 18 cmp %g1, %i0
400066d8: 1a 80 00 34 bcc 400067a8 <rtems_fdisk_compact+0x214>
400066dc: 86 03 40 1a add %o5, %i2, %g3
((pages + ssc->pages_active) < dst_pages) &&
400066e0: c4 07 60 0c ld [ %i5 + 0xc ], %g2
400066e4: 80 a0 c0 02 cmp %g3, %g2
400066e8: 2a bf ff ee bcs,a 400066a0 <rtems_fdisk_compact+0x10c> <== ALWAYS TAKEN
400066ec: f8 07 00 00 ld [ %i4 ], %i4
400066f0: 10 80 00 2f b 400067ac <rtems_fdisk_compact+0x218> <== NOT EXECUTED
400066f4: 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))
400066f8: 80 a6 a0 01 cmp %i2, 1
400066fc: 22 bf ff f0 be,a 400066bc <rtems_fdisk_compact+0x128>
40006700: 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",
40006704: d4 07 20 08 ld [ %i4 + 8 ], %o2
40006708: d6 07 20 0c ld [ %i4 + 0xc ], %o3
4000670c: 92 10 00 12 mov %l2, %o1
40006710: 7f ff fc 58 call 40005870 <rtems_fdisk_printf>
40006714: 90 10 00 1d mov %i5, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
40006718: 90 10 00 19 mov %i1, %o0
4000671c: 7f ff fb a3 call 400055a8 <rtems_fdisk_segment_queue_remove>
40006720: 92 10 00 1b mov %i3, %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
40006724: 10 80 00 0e b 4000675c <rtems_fdisk_compact+0x1c8>
40006728: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
4000672c: 7f ff fb 7d call 40005520 <rtems_fdisk_segment_queue_pop_head>
40006730: 90 10 00 13 mov %l3, %o0
if (ssc)
40006734: 92 92 20 00 orcc %o0, 0, %o1
40006738: 02 80 00 09 be 4000675c <rtems_fdisk_compact+0x1c8> <== NEVER TAKEN
4000673c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
40006740: 90 10 00 1d mov %i5, %o0
40006744: 94 10 00 1b mov %i3, %o2
40006748: 7f ff fe b2 call 40006210 <rtems_fdisk_recycle_segment>
4000674c: 96 07 bf fc add %fp, -4, %o3
if (ret)
40006750: 80 a2 20 00 cmp %o0, 0
40006754: 12 80 00 1b bne 400067c0 <rtems_fdisk_compact+0x22c> <== NEVER TAKEN
40006758: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* We now copy the pages to the new segment.
*/
while (pages)
4000675c: 80 a0 60 00 cmp %g1, 0
40006760: 22 80 00 0d be,a 40006794 <rtems_fdisk_compact+0x200>
40006764: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
40006768: 30 bf ff f1 b,a 4000672c <rtems_fdisk_compact+0x198>
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4000676c: 21 10 00 cb sethi %hi(0x40032c00), %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",
40006770: 23 10 00 cb sethi %hi(0x40032c00), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40006774: 25 10 00 cb sethi %hi(0x40032c00), %l2
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
40006778: b4 10 20 00 clr %i2
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4000677c: a0 14 21 a0 or %l0, 0x1a0, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
40006780: 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",
40006784: a2 14 61 e8 or %l1, 0x1e8, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40006788: a4 14 a2 20 or %l2, 0x220, %l2
* We now copy the pages to the new segment.
*/
while (pages)
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
4000678c: a6 07 60 40 add %i5, 0x40, %l3
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
40006790: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
40006794: 80 a0 60 00 cmp %g1, 0
40006798: 12 bf ff ab bne 40006644 <rtems_fdisk_compact+0xb0>
4000679c: 92 10 00 10 mov %l0, %o1
}
compacted_segs += segments;
}
return 0;
400067a0: 10 80 00 08 b 400067c0 <rtems_fdisk_compact+0x22c>
400067a4: 90 10 20 00 clr %o0
400067a8: 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))
400067ac: 80 a3 20 00 cmp %o4, 0
400067b0: 32 bf ff d2 bne,a 400066f8 <rtems_fdisk_compact+0x164>
400067b4: b4 06 80 0d add %i2, %o5, %i2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
400067b8: 10 bf ff c1 b 400066bc <rtems_fdisk_compact+0x128>
400067bc: 90 10 00 1d mov %i5, %o0
compacted_segs += segments;
}
return 0;
}
400067c0: b0 10 00 08 mov %o0, %i0
400067c4: 81 c7 e0 08 ret
400067c8: 81 e8 00 00 restore
400059e4 <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
400059e4: 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;
400059e8: d2 06 60 08 ld [ %i1 + 8 ], %o1
segment = sc->segment;
400059ec: 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;
400059f0: 85 2a 60 04 sll %o1, 4, %g2
400059f4: 83 2a 60 02 sll %o1, 2, %g1
400059f8: 82 20 80 01 sub %g2, %g1, %g1
400059fc: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40005a00: 89 2a a0 06 sll %o2, 6, %g4
40005a04: 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;
40005a08: 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;
40005a0c: 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);
40005a10: 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;
40005a14: 85 2a a0 04 sll %o2, 4, %g2
40005a18: 84 21 00 02 sub %g4, %g2, %g2
40005a1c: 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);
40005a20: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
40005a24: 9f c0 40 00 call %g1
40005a28: d0 00 a0 04 ld [ %g2 + 4 ], %o0
if (ret)
40005a2c: ba 92 20 00 orcc %o0, 0, %i5
40005a30: 22 80 00 16 be,a 40005a88 <rtems_fdisk_erase_segment+0xa4><== ALWAYS TAKEN
40005a34: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
40005a38: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
40005a3c: 40 00 77 a5 call 400238d0 <strerror> <== NOT EXECUTED
40005a40: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
40005a44: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40005a48: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40005a4c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40005a50: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
40005a54: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40005a58: 7f ff ff c6 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40005a5c: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400329a8 <Callbacks.6428+0x190><== NOT EXECUTED
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
40005a60: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
40005a64: 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;
40005a68: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
40005a6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005a70: 7f ff ff 09 call 40005694 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
40005a74: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005a78: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40005a7c: 12 80 00 18 bne 40005adc <rtems_fdisk_erase_segment+0xf8> <== NOT EXECUTED
40005a80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005a84: 30 80 00 14 b,a 40005ad4 <rtems_fdisk_erase_segment+0xf0><== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
40005a88: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005a8c: 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;
40005a90: 82 00 80 01 add %g2, %g1, %g1
40005a94: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
sc->erased++;
40005a98: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005a9c: 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++;
40005aa0: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005aa4: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
40005aa8: 7f ff f2 bb call 40002594 <.umul>
40005aac: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
40005ab0: 92 10 20 ff mov 0xff, %o1
40005ab4: 94 10 00 08 mov %o0, %o2
40005ab8: 40 00 72 9c call 40022528 <memset>
40005abc: 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);
40005ac0: 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;
40005ac4: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
40005ac8: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
40005acc: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
40005ad0: 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);
40005ad4: 7f ff fe a3 call 40005560 <rtems_fdisk_segment_queue_push_tail>
40005ad8: 92 10 00 19 mov %i1, %o1
return 0;
}
40005adc: 81 c7 e0 08 ret
40005ae0: 91 e8 00 1d restore %g0, %i5, %o0
40005970 <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, ...)
{
40005970: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
40005974: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
40005978: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
4000597c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40005980: 3b 10 00 de sethi %hi(0x40037800), %i5 <== NOT EXECUTED
40005984: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 ! 40037bc8 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
40005988: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
4000598c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40005990: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40005994: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40005998: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
4000599c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
400059a0: 40 00 70 56 call 40021af8 <fputs> <== NOT EXECUTED
400059a4: 90 12 21 68 or %o0, 0x168, %o0 ! 40032968 <Callbacks.6428+0x150><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
400059a8: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
400059ac: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
400059b0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
400059b4: 40 00 93 4d call 4002a6e8 <vfprintf> <== NOT EXECUTED
400059b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
400059bc: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
400059c0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
400059c4: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
400059c8: 40 00 70 18 call 40021a28 <fputc> <== NOT EXECUTED
400059cc: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
400059d0: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
400059d4: 40 00 6e fd call 400215c8 <fflush> <== NOT EXECUTED
400059d8: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
400059dc: 81 c7 e0 08 ret <== NOT EXECUTED
400059e0: 81 e8 00 00 restore <== NOT EXECUTED
400057f0 <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, ...)
{
400057f0: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
400057f4: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400057f8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400057fc: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40005800: 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)
40005804: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
40005808: 80 a0 60 01 cmp %g1, 1
4000580c: 08 80 00 17 bleu 40005868 <rtems_fdisk_info+0x78> <== ALWAYS TAKEN
40005810: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
40005814: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
40005818: 3b 10 00 de sethi %hi(0x40037800), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
4000581c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
40005820: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40005824: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40005828: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
4000582c: 40 00 70 b3 call 40021af8 <fputs> <== NOT EXECUTED
40005830: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
40005834: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40005838: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4000583c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005840: 40 00 93 aa call 4002a6e8 <vfprintf> <== NOT EXECUTED
40005844: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
40005848: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
4000584c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
40005850: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40005854: 40 00 70 75 call 40021a28 <fputc> <== NOT EXECUTED
40005858: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
4000585c: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40005860: 40 00 6f 5a call 400215c8 <fflush> <== NOT EXECUTED
40005864: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40005868: 81 c7 e0 08 ret
4000586c: 81 e8 00 00 restore
40007958 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
40007958: 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 ();
4000795c: 7f ff f6 8c call 4000538c <rtems_disk_io_initialize>
40007960: b4 10 00 18 mov %i0, %i2
if (sc != RTEMS_SUCCESSFUL)
40007964: b0 92 20 00 orcc %o0, 0, %i0
40007968: 12 80 01 3b bne 40007e54 <rtems_fdisk_initialize+0x4fc> <== NEVER TAKEN
4000796c: 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);
40007970: 40 00 05 1c call 40008de0 <malloc>
40007974: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200>
40007978: 03 10 01 20 sethi %hi(0x40048000), %g1
4000797c: d0 20 61 c8 st %o0, [ %g1 + 0x1c8 ] ! 400481c8 <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;
40007980: 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)
40007984: 82 10 20 00 clr %g1
40007988: 80 a2 20 00 cmp %o0, 0
4000798c: 12 80 00 04 bne 4000799c <rtems_fdisk_initialize+0x44> <== ALWAYS TAKEN
40007990: 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;
40007994: 81 c7 e0 08 ret <== NOT EXECUTED
40007998: 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;
4000799c: 84 10 00 01 mov %g1, %g2
400079a0: 10 80 00 06 b 400079b8 <rtems_fdisk_initialize+0x60>
400079a4: 86 10 20 09 mov 9, %g3
400079a8: 85 28 a0 10 sll %g2, 0x10, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
400079ac: 02 80 00 03 be 400079b8 <rtems_fdisk_initialize+0x60>
400079b0: 85 30 a0 11 srl %g2, 0x11, %g2
400079b4: 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--;)
400079b8: 86 80 ff ff addcc %g3, -1, %g3
400079bc: 12 bf ff fb bne 400079a8 <rtems_fdisk_initialize+0x50>
400079c0: 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,
400079c4: 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++)
400079c8: 82 00 60 01 inc %g1
400079cc: 80 a0 61 00 cmp %g1, 0x100
400079d0: 12 bf ff f3 bne 4000799c <rtems_fdisk_initialize+0x44>
400079d4: 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,
400079d8: 10 80 01 0f b 40007e14 <rtems_fdisk_initialize+0x4bc>
400079dc: 2f 10 00 de sethi %hi(0x40037800), %l7
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
400079e0: c2 05 61 c0 ld [ %l5 + 0x1c0 ], %g1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
400079e4: 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";
400079e8: 05 0b d9 19 sethi %hi(0x2f646400), %g2
400079ec: 07 0b d9 99 sethi %hi(0x2f666400), %g3
400079f0: 84 10 a1 76 or %g2, 0x176, %g2
400079f4: 86 10 e0 64 or %g3, 0x64, %g3
400079f8: 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];
400079fc: ba 00 40 10 add %g1, %l0, %i5
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
40007a00: f4 20 40 10 st %i2, [ %g1 + %l0 ]
fd->minor = minor;
fd->flags = c->flags;
40007a04: 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;
40007a08: 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;
40007a0c: c2 27 60 08 st %g1, [ %i5 + 8 ]
fd->compact_segs = c->compact_segs;
40007a10: 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;
40007a14: f6 27 60 04 st %i3, [ %i5 + 4 ]
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
40007a18: c2 27 60 0c st %g1, [ %i5 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
40007a1c: 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++)
40007a20: 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;
40007a24: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
40007a28: 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;
40007a2c: e2 27 60 14 st %l1, [ %i5 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
40007a30: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
fd->info_level = c->info_level;
40007a34: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
for (device = 0; device < c->device_count; device++)
40007a38: 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;
40007a3c: 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;
40007a40: 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++)
40007a44: 10 80 00 28 b 40007ae4 <rtems_fdisk_initialize+0x18c>
40007a48: 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++)
40007a4c: 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],
40007a50: 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++)
40007a54: d8 00 40 12 ld [ %g1 + %l2 ], %o4
40007a58: 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;
40007a5c: 10 80 00 1c b 40007acc <rtems_fdisk_initialize+0x174>
40007a60: 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;
40007a64: 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];
40007a68: 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;
40007a6c: d0 03 e0 08 ld [ %o7 + 8 ], %o0
40007a70: c4 3f bf e0 std %g2, [ %fp + -32 ]
40007a74: d8 3f bf c8 std %o4, [ %fp + -56 ]
40007a78: c8 27 bf dc st %g4, [ %fp + -36 ]
40007a7c: 7f ff eb 00 call 4000267c <.udiv>
40007a80: 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;
40007a84: 94 02 3f ff add %o0, -1, %o2
40007a88: 92 10 00 11 mov %l1, %o1
40007a8c: 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);
40007a90: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
40007a94: 7f ff ea fa call 4000267c <.udiv>
40007a98: 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;
40007a9c: c8 07 bf dc ld [ %fp + -36 ], %g4
40007aa0: d4 1f bf d0 ldd [ %fp + -48 ], %o2
40007aa4: d2 11 00 13 lduh [ %g4 + %l3 ], %o1
40007aa8: 90 22 80 08 sub %o2, %o0, %o0
40007aac: 7f ff ea ba call 40002594 <.umul>
40007ab0: 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 +=
40007ab4: c4 1f bf e0 ldd [ %fp + -32 ], %g2
40007ab8: d8 1f bf c8 ldd [ %fp + -56 ], %o4
40007abc: d6 07 bf d4 ld [ %fp + -44 ], %o3
40007ac0: 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++)
40007ac4: 86 00 e0 01 inc %g3
40007ac8: a6 04 e0 0c add %l3, 0xc, %l3
40007acc: 80 a0 c0 0c cmp %g3, %o4
40007ad0: 32 bf ff e5 bne,a 40007a64 <rtems_fdisk_initialize+0x10c>
40007ad4: 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],
40007ad8: 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++)
40007adc: b0 06 20 01 inc %i0
40007ae0: a4 04 a0 0c add %l2, 0xc, %l2
40007ae4: 80 a6 00 0d cmp %i0, %o5
40007ae8: 32 bf ff d9 bne,a 40007a4c <rtems_fdisk_initialize+0xf4>
40007aec: 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);
40007af0: 40 00 04 bc call 40008de0 <malloc>
40007af4: 90 10 00 11 mov %l1, %o0
if (!fd->copy_buffer)
40007af8: 80 a2 20 00 cmp %o0, 0
40007afc: 02 80 00 bc be 40007dec <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40007b00: d0 27 60 68 st %o0, [ %i5 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
40007b04: 90 10 00 19 mov %i1, %o0
40007b08: 40 00 02 c1 call 4000860c <calloc>
40007b0c: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
40007b10: 80 a2 20 00 cmp %o0, 0
40007b14: 02 80 00 b6 be 40007dec <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40007b18: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
40007b1c: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40007b20: 90 10 00 18 mov %i0, %o0
40007b24: 40 00 02 ba call 4000860c <calloc>
40007b28: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
40007b2c: 80 a2 20 00 cmp %o0, 0
40007b30: 02 80 00 af be 40007dec <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40007b34: d0 27 60 2c st %o0, [ %i5 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
40007b38: 90 10 00 14 mov %l4, %o0
40007b3c: 92 10 20 01 mov 1, %o1
40007b40: 94 10 20 54 mov 0x54, %o2
40007b44: 96 10 20 00 clr %o3
40007b48: 40 00 14 df call 4000cec4 <rtems_semaphore_create>
40007b4c: 98 07 60 64 add %i5, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
40007b50: b0 92 20 00 orcc %o0, 0, %i0
40007b54: 22 80 00 0d be,a 40007b88 <rtems_fdisk_initialize+0x230> <== ALWAYS TAKEN
40007b58: d6 07 60 20 ld [ %i5 + 0x20 ], %o3
{
rtems_fdisk_error ("disk lock create failed");
40007b5c: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40007b60: 7f ff f7 84 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40007b64: 90 12 20 78 or %o0, 0x78, %o0 ! 40033478 <Callbacks.6428+0xc60><== NOT EXECUTED
free (fd->copy_buffer);
40007b68: 40 00 03 0d call 4000879c <free> <== NOT EXECUTED
40007b6c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007b70: 40 00 03 0b call 4000879c <free> <== NOT EXECUTED
40007b74: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007b78: 40 00 03 09 call 4000879c <free> <== NOT EXECUTED
40007b7c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
40007b80: 81 c7 e0 08 ret <== NOT EXECUTED
40007b84: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
40007b88: d4 07 00 00 ld [ %i4 ], %o2
40007b8c: 86 07 bf f0 add %fp, -16, %g3
40007b90: 90 10 00 1a mov %i2, %o0
40007b94: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
40007b98: 92 10 00 1b mov %i3, %o1
40007b9c: 96 26 40 0b sub %i1, %o3, %o3
40007ba0: 19 10 00 19 sethi %hi(0x40006400), %o4
40007ba4: 9a 10 20 00 clr %o5
40007ba8: 7f ff f5 63 call 40005134 <rtems_disk_create_phys>
40007bac: 98 13 23 cc or %o4, 0x3cc, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
40007bb0: b0 92 20 00 orcc %o0, 0, %i0
40007bb4: 22 80 00 56 be,a 40007d0c <rtems_fdisk_initialize+0x3b4> <== ALWAYS TAKEN
40007bb8: b2 10 20 00 clr %i1
{
rtems_semaphore_delete (fd->lock);
40007bbc: 40 00 15 30 call 4000d07c <rtems_semaphore_delete> <== NOT EXECUTED
40007bc0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
40007bc4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40007bc8: 7f ff f4 c1 call 40004ecc <rtems_disk_delete> <== NOT EXECUTED
40007bcc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007bd0: 40 00 02 f3 call 4000879c <free> <== NOT EXECUTED
40007bd4: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007bd8: 40 00 02 f1 call 4000879c <free> <== NOT EXECUTED
40007bdc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007be0: 40 00 02 ef call 4000879c <free> <== NOT EXECUTED
40007be4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
40007be8: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40007bec: 7f ff f7 61 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40007bf0: 90 12 20 90 or %o0, 0x90, %o0 ! 40033490 <Callbacks.6428+0xc78><== NOT EXECUTED
40007bf4: 81 c7 e0 08 ret <== NOT EXECUTED
40007bf8: 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++)
40007bfc: 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]);
40007c00: 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++)
40007c04: 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;
40007c08: a2 10 20 00 clr %l1
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
40007c0c: 10 80 00 06 b 40007c24 <rtems_fdisk_initialize+0x2cc>
40007c10: 82 10 20 00 clr %g1
40007c14: 82 00 60 01 inc %g1
count += dd->segments[segment].count;
40007c18: c6 10 c0 02 lduh [ %g3 + %g2 ], %g3
40007c1c: 84 00 a0 0c add %g2, 0xc, %g2
40007c20: 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++)
40007c24: 80 a0 40 0c cmp %g1, %o4
40007c28: 32 bf ff fb bne,a 40007c14 <rtems_fdisk_initialize+0x2bc>
40007c2c: 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,
40007c30: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40007c34: 90 10 00 11 mov %l1, %o0
40007c38: 9a 00 40 19 add %g1, %i1, %o5
40007c3c: c2 27 bf ec st %g1, [ %fp + -20 ]
40007c40: d8 3f bf c8 std %o4, [ %fp + -56 ]
40007c44: 40 00 02 72 call 4000860c <calloc>
40007c48: 92 10 20 30 mov 0x30, %o1
40007c4c: c2 07 bf ec ld [ %fp + -20 ], %g1
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40007c50: 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,
40007c54: d0 20 40 19 st %o0, [ %g1 + %i1 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40007c58: 12 80 00 23 bne 40007ce4 <rtems_fdisk_initialize+0x38c> <== ALWAYS TAKEN
40007c5c: d8 1f bf c8 ldd [ %fp + -56 ], %o4
{
rtems_disk_delete (dev);
40007c60: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40007c64: 7f ff f4 9a call 40004ecc <rtems_disk_delete> <== NOT EXECUTED
40007c68: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40007c6c: 40 00 15 04 call 4000d07c <rtems_semaphore_delete> <== NOT EXECUTED
40007c70: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007c74: 40 00 02 ca call 4000879c <free> <== NOT EXECUTED
40007c78: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007c7c: 40 00 02 c8 call 4000879c <free> <== NOT EXECUTED
40007c80: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007c84: 40 00 02 c6 call 4000879c <free> <== NOT EXECUTED
40007c88: 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;
40007c8c: 81 c7 e0 08 ret <== NOT EXECUTED
40007c90: 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++)
40007c94: 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];
40007c98: 96 00 40 02 add %g1, %g2, %o3
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40007c9c: de 10 40 02 lduh [ %g1 + %g2 ], %o7
40007ca0: 10 80 00 07 b 40007cbc <rtems_fdisk_initialize+0x364>
40007ca4: 82 10 00 08 mov %o0, %g1
{
sc->descriptor = sd;
40007ca8: d6 20 60 04 st %o3, [ %g1 + 4 ]
sc->device = device;
40007cac: f0 20 60 08 st %i0, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
40007cb0: 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++)
40007cb4: 86 00 e0 01 inc %g3
40007cb8: 82 00 60 30 add %g1, 0x30, %g1
40007cbc: 80 a0 c0 0f cmp %g3, %o7
40007cc0: 2a bf ff fa bcs,a 40007ca8 <rtems_fdisk_initialize+0x350>
40007cc4: 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,
40007cc8: 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++)
40007ccc: 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,
40007cd0: 9f 2b e0 06 sll %o7, 6, %o7
40007cd4: 84 00 a0 0c add %g2, 0xc, %g2
40007cd8: 9e 23 c0 01 sub %o7, %g1, %o7
40007cdc: 10 80 00 04 b 40007cec <rtems_fdisk_initialize+0x394>
40007ce0: 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)
40007ce4: 84 10 20 00 clr %g2
40007ce8: 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++)
40007cec: 80 a1 00 0c cmp %g4, %o4
40007cf0: 32 bf ff e9 bne,a 40007c94 <rtems_fdisk_initialize+0x33c>
40007cf4: c2 04 a0 04 ld [ %l2 + 4 ], %g1
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
40007cf8: e2 23 60 04 st %l1, [ %o5 + 4 ]
fd->devices[device].descriptor = &c->devices[device];
40007cfc: 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++)
40007d00: b0 06 20 01 inc %i0
40007d04: 10 80 00 03 b 40007d10 <rtems_fdisk_initialize+0x3b8>
40007d08: 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)
40007d0c: 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++)
40007d10: c2 07 20 04 ld [ %i4 + 4 ], %g1
40007d14: 80 a6 00 01 cmp %i0, %g1
40007d18: 2a bf ff b9 bcs,a 40007bfc <rtems_fdisk_initialize+0x2a4>
40007d1c: 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;
40007d20: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
40007d24: 7f ff f8 47 call 40005e40 <rtems_fdisk_recover_block_mappings>
40007d28: 90 10 00 1d mov %i5, %o0
if (ret)
40007d2c: b0 92 20 00 orcc %o0, 0, %i0
40007d30: 22 80 00 13 be,a 40007d7c <rtems_fdisk_initialize+0x424> <== ALWAYS TAKEN
40007d34: 90 10 00 1d mov %i5, %o0
{
rtems_disk_delete (dev);
40007d38: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40007d3c: 7f ff f4 64 call 40004ecc <rtems_disk_delete> <== NOT EXECUTED
40007d40: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40007d44: 40 00 14 ce call 4000d07c <rtems_semaphore_delete> <== NOT EXECUTED
40007d48: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007d4c: 40 00 02 94 call 4000879c <free> <== NOT EXECUTED
40007d50: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007d54: 40 00 02 92 call 4000879c <free> <== NOT EXECUTED
40007d58: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007d5c: 40 00 02 90 call 4000879c <free> <== NOT EXECUTED
40007d60: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
40007d64: 40 00 6e db call 400238d0 <strerror> <== NOT EXECUTED
40007d68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40007d6c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40007d70: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40007d74: 10 80 00 17 b 40007dd0 <rtems_fdisk_initialize+0x478> <== NOT EXECUTED
40007d78: 90 12 20 a8 or %o0, 0xa8, %o0 ! 400334a8 <Callbacks.6428+0xc90><== NOT EXECUTED
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
40007d7c: 7f ff fa 06 call 40006594 <rtems_fdisk_compact>
40007d80: a0 04 20 74 add %l0, 0x74, %l0
if (ret)
40007d84: 80 a2 20 00 cmp %o0, 0
40007d88: 02 80 00 16 be 40007de0 <rtems_fdisk_initialize+0x488> <== ALWAYS TAKEN
40007d8c: b0 10 00 08 mov %o0, %i0
{
rtems_disk_delete (dev);
40007d90: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40007d94: 7f ff f4 4e call 40004ecc <rtems_disk_delete> <== NOT EXECUTED
40007d98: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40007d9c: 40 00 14 b8 call 4000d07c <rtems_semaphore_delete> <== NOT EXECUTED
40007da0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007da4: 40 00 02 7e call 4000879c <free> <== NOT EXECUTED
40007da8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007dac: 40 00 02 7c call 4000879c <free> <== NOT EXECUTED
40007db0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007db4: 40 00 02 7a call 4000879c <free> <== NOT EXECUTED
40007db8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
40007dbc: 40 00 6e c5 call 400238d0 <strerror> <== NOT EXECUTED
40007dc0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40007dc4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40007dc8: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED
40007dcc: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400334d0 <Callbacks.6428+0xcb8><== NOT EXECUTED
40007dd0: 7f ff f6 e8 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40007dd4: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40007dd8: 81 c7 e0 08 ret <== NOT EXECUTED
40007ddc: 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++)
40007de0: b6 06 e0 01 inc %i3
40007de4: 10 80 00 04 b 40007df4 <rtems_fdisk_initialize+0x49c>
40007de8: 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;
40007dec: 81 c7 e0 08 ret <== NOT EXECUTED
40007df0: 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++)
40007df4: c2 05 e2 0c ld [ %l7 + 0x20c ], %g1
40007df8: 80 a6 c0 01 cmp %i3, %g1
40007dfc: 2a bf fe f9 bcs,a 400079e0 <rtems_fdisk_initialize+0x88>
40007e00: ec 37 bf f8 sth %l6, [ %fp + -8 ]
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
40007e04: 05 10 01 20 sethi %hi(0x40048000), %g2
40007e08: c2 20 a1 c4 st %g1, [ %g2 + 0x1c4 ] ! 400481c4 <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
40007e0c: 81 c7 e0 08 ret
40007e10: 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,
40007e14: d0 05 e2 0c ld [ %l7 + 0x20c ], %o0
40007e18: 92 10 20 74 mov 0x74, %o1
40007e1c: 40 00 01 fc call 4000860c <calloc>
40007e20: 2b 10 01 20 sethi %hi(0x40048000), %l5
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
40007e24: 80 a2 20 00 cmp %o0, 0
40007e28: 02 bf ff f1 be 40007dec <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
40007e2c: d0 25 61 c0 st %o0, [ %l5 + 0x1c0 ]
40007e30: 39 10 00 c8 sethi %hi(0x40032000), %i4
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
40007e34: 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,
40007e38: 29 11 91 14 sethi %hi(0x46445000), %l4
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
40007e3c: a0 10 20 00 clr %l0
40007e40: b8 17 23 10 or %i4, 0x310, %i4
40007e44: 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";
40007e48: 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,
40007e4c: 10 bf ff ea b 40007df4 <rtems_fdisk_initialize+0x49c>
40007e50: a8 15 23 4b or %l4, 0x34b, %l4
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
40007e54: 81 c7 e0 08 ret <== NOT EXECUTED
40007e58: 81 e8 00 00 restore <== NOT EXECUTED
400067cc <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)
{
400067cc: 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;
400067d0: 40 00 6a 7b call 400211bc <__errno>
400067d4: f8 06 20 04 ld [ %i0 + 4 ], %i4
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
400067d8: 83 2f 20 02 sll %i4, 2, %g1
400067dc: b7 2f 20 05 sll %i4, 5, %i3
400067e0: 3b 10 01 20 sethi %hi(0x40048000), %i5
400067e4: b6 26 c0 01 sub %i3, %g1, %i3
400067e8: c2 07 61 c0 ld [ %i5 + 0x1c0 ], %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;
400067ec: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
400067f0: b6 06 c0 1c add %i3, %i4, %i3
400067f4: b7 2e e0 02 sll %i3, 2, %i3
400067f8: 82 00 40 1b add %g1, %i3, %g1
400067fc: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
40006800: 92 10 20 00 clr %o1
40006804: 40 00 1a 4d call 4000d138 <rtems_semaphore_obtain>
40006808: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
4000680c: 80 a2 20 00 cmp %o0, 0
40006810: 12 80 04 41 bne 40007914 <rtems_fdisk_ioctl+0x1148> <== NEVER TAKEN
40006814: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
40006818: 40 00 6a 69 call 400211bc <__errno>
4000681c: 01 00 00 00 nop
switch (req)
40006820: 03 08 00 10 sethi %hi(0x20004000), %g1
40006824: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_SIZE+0x1fc04283>
40006828: 80 a6 40 02 cmp %i1, %g2
4000682c: 02 80 02 ce be 40007364 <rtems_fdisk_ioctl+0xb98> <== NEVER TAKEN
40006830: c0 22 00 00 clr [ %o0 ]
40006834: 80 a6 40 02 cmp %i1, %g2
40006838: 38 80 00 0c bgu,a 40006868 <rtems_fdisk_ioctl+0x9c>
4000683c: 82 10 62 85 or %g1, 0x285, %g1
40006840: 84 10 62 81 or %g1, 0x281, %g2
40006844: 80 a6 40 02 cmp %i1, %g2
40006848: 02 80 02 a9 be 400072ec <rtems_fdisk_ioctl+0xb20> <== NEVER TAKEN
4000684c: 01 00 00 00 nop
40006850: 18 80 02 af bgu 4000730c <rtems_fdisk_ioctl+0xb40> <== NEVER TAKEN
40006854: 82 10 62 80 or %g1, 0x280, %g1
40006858: 80 a6 40 01 cmp %i1, %g1
4000685c: 32 80 04 23 bne,a 400078e8 <rtems_fdisk_ioctl+0x111c> <== ALWAYS TAKEN
40006860: 90 10 00 18 mov %i0, %o0
40006864: 30 80 02 66 b,a 400071fc <rtems_fdisk_ioctl+0xa30> <== NOT EXECUTED
40006868: 80 a6 40 01 cmp %i1, %g1
4000686c: 02 80 03 1e be 400074e4 <rtems_fdisk_ioctl+0xd18>
40006870: 01 00 00 00 nop
40006874: 0a 80 03 19 bcs 400074d8 <rtems_fdisk_ioctl+0xd0c> <== NEVER TAKEN
40006878: c2 07 61 c0 ld [ %i5 + 0x1c0 ], %g1
4000687c: 03 30 06 10 sethi %hi(0xc0184000), %g1
40006880: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40006884: 80 a6 40 01 cmp %i1, %g1
40006888: 12 80 04 18 bne 400078e8 <rtems_fdisk_ioctl+0x111c>
4000688c: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40006890: 03 10 01 20 sethi %hi(0x40048000), %g1
40006894: c2 00 61 c4 ld [ %g1 + 0x1c4 ], %g1 ! 400481c4 <rtems_flashdisk_count>
40006898: 80 a7 00 01 cmp %i4, %g1
4000689c: 1a 80 00 08 bcc 400068bc <rtems_fdisk_ioctl+0xf0> <== NEVER TAKEN
400068a0: 01 00 00 00 nop
(rtems_flashdisks[minor].device_count == 0))
400068a4: c2 07 61 c0 ld [ %i5 + 0x1c0 ], %g1
400068a8: 82 00 40 1b add %g1, %i3, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
400068ac: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
400068b0: 80 a0 60 00 cmp %g1, 0
400068b4: 32 80 00 06 bne,a 400068cc <rtems_fdisk_ioctl+0x100> <== ALWAYS TAKEN
400068b8: c2 06 80 00 ld [ %i2 ], %g1
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
400068bc: 40 00 6a 40 call 400211bc <__errno> <== NOT EXECUTED
400068c0: 01 00 00 00 nop <== NOT EXECUTED
400068c4: 10 80 02 4c b 400071f4 <rtems_fdisk_ioctl+0xa28> <== NOT EXECUTED
400068c8: 82 10 20 13 mov 0x13, %g1 ! 13 <PROM_START+0x13> <== NOT EXECUTED
}
else
{
switch (r->req)
400068cc: 80 a0 60 00 cmp %g1, 0
400068d0: 02 80 00 05 be 400068e4 <rtems_fdisk_ioctl+0x118>
400068d4: 80 a0 60 01 cmp %g1, 1
400068d8: 12 80 02 44 bne 400071e8 <rtems_fdisk_ioctl+0xa1c> <== NEVER TAKEN
400068dc: 01 00 00 00 nop
400068e0: 30 80 00 b4 b,a 40006bb0 <rtems_fdisk_ioctl+0x3e4>
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
400068e4: 40 00 6a 36 call 400211bc <__errno>
400068e8: b0 06 a0 18 add %i2, 0x18, %i0
400068ec: f8 07 61 c0 ld [ %i5 + 0x1c0 ], %i4
400068f0: d0 27 bf ec st %o0, [ %fp + -20 ]
400068f4: 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++)
400068f8: 10 80 00 a2 b 40006b80 <rtems_fdisk_ioctl+0x3b4>
400068fc: a4 10 20 00 clr %l2
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40006900: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
40006904: 7f ff ef 5e call 4000267c <.udiv>
40006908: 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,
4000690c: 2d 10 00 ca sethi %hi(0x40032800), %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;
40006910: d0 27 bf e8 st %o0, [ %fp + -24 ]
data = sg->buffer;
40006914: 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,
40006918: 10 80 00 91 b 40006b5c <rtems_fdisk_ioctl+0x390>
4000691c: 2f 10 00 ca sethi %hi(0x40032800), %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);
40006920: 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);
40006924: 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);
40006928: 13 10 00 cb sethi %hi(0x40032c00), %o1
4000692c: 94 10 00 19 mov %i1, %o2
40006930: 7f ff fb b0 call 400057f0 <rtems_fdisk_info>
40006934: 92 12 62 58 or %o1, 0x258, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40006938: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
4000693c: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40006940: 82 20 80 01 sub %g2, %g1, %g1
40006944: 80 a6 40 01 cmp %i1, %g1
40006948: 2a 80 00 08 bcs,a 40006968 <rtems_fdisk_ioctl+0x19c> <== ALWAYS TAKEN
4000694c: c6 07 20 18 ld [ %i4 + 0x18 ], %g3
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
40006950: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006954: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006958: 7f ff fc 06 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
4000695c: 90 12 22 68 or %o0, 0x268, %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)
40006960: 10 80 00 84 b 40006b70 <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
40006964: 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];
40006968: 83 2e 60 03 sll %i1, 3, %g1
if (!bc->segment)
4000696c: fa 00 c0 01 ld [ %g3 + %g1 ], %i5
40006970: 80 a7 60 00 cmp %i5, 0
40006974: 12 80 00 0d bne 400069a8 <rtems_fdisk_ioctl+0x1dc>
40006978: aa 00 c0 01 add %g3, %g1, %l5
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
4000697c: 94 10 00 19 mov %i1, %o2
40006980: 90 10 00 1c mov %i4, %o0
40006984: 13 10 00 cb sethi %hi(0x40032c00), %o1
40006988: 7f ff fb 9a call 400057f0 <rtems_fdisk_info>
4000698c: 92 12 62 90 or %o1, 0x290, %o1 ! 40032e90 <Callbacks.6428+0x678>
#endif
memset (buffer, 0xff, fd->block_size);
40006990: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
40006994: 90 10 00 10 mov %l0, %o0
40006998: 40 00 6e e4 call 40022528 <memset>
4000699c: 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)
400069a0: 10 80 03 e9 b 40007944 <rtems_fdisk_ioctl+0x1178>
400069a4: 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];
400069a8: da 05 60 04 ld [ %l5 + 4 ], %o5
400069ac: e8 07 60 10 ld [ %i5 + 0x10 ], %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
400069b0: 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];
400069b4: a7 2b 60 03 sll %o5, 3, %l3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
400069b8: 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];
400069bc: 86 05 00 13 add %l4, %l3, %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
400069c0: d8 07 60 0c ld [ %i5 + 0xc ], %o4
400069c4: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
400069c8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
400069cc: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
400069d0: 80 a1 20 00 cmp %g4, 0
400069d4: 02 80 00 04 be 400069e4 <rtems_fdisk_ioctl+0x218>
400069d8: de 07 60 24 ld [ %i5 + 0x24 ], %o7
400069dc: 10 80 00 03 b 400069e8 <rtems_fdisk_ioctl+0x21c>
400069e0: 88 15 e1 f0 or %l7, 0x1f0, %g4
400069e4: 88 15 a1 f8 or %l6, 0x1f8, %g4
400069e8: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
400069ec: d2 23 a0 60 st %o1, [ %sp + 0x60 ]
400069f0: d4 23 a0 64 st %o2, [ %sp + 0x64 ]
400069f4: de 23 a0 68 st %o7, [ %sp + 0x68 ]
400069f8: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
400069fc: c8 10 e0 02 lduh [ %g3 + 2 ], %g4
40006a00: 90 10 00 1c mov %i4, %o0
40006a04: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
40006a08: c8 15 00 13 lduh [ %l4 + %l3 ], %g4
40006a0c: 13 10 00 cb sethi %hi(0x40032c00), %o1
40006a10: c8 23 a0 74 st %g4, [ %sp + 0x74 ]
40006a14: c8 00 e0 04 ld [ %g3 + 4 ], %g4
40006a18: 92 12 62 b8 or %o1, 0x2b8, %o1
40006a1c: c6 27 bf d4 st %g3, [ %fp + -44 ]
40006a20: c8 23 a0 78 st %g4, [ %sp + 0x78 ]
40006a24: 7f ff fb 73 call 400057f0 <rtems_fdisk_info>
40006a28: 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;
40006a2c: c6 07 bf d4 ld [ %fp + -44 ], %g3
40006a30: 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))
40006a34: 80 88 e0 01 btst 1, %g3
40006a38: 12 80 00 41 bne 40006b3c <rtems_fdisk_ioctl+0x370> <== NEVER TAKEN
40006a3c: d8 05 60 04 ld [ %l5 + 4 ], %o4
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
40006a40: 80 88 e0 02 btst 2, %g3
40006a44: 02 80 00 3c be 40006b34 <rtems_fdisk_ioctl+0x368> <== NEVER TAKEN
40006a48: 11 10 00 cb sethi %hi(0x40032c00), %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);
40006a4c: 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,
40006a50: 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,
40006a54: 92 10 00 03 mov %g3, %o1
40006a58: 90 02 00 0c add %o0, %o4, %o0
40006a5c: 7f ff ee ce call 40002594 <.umul>
40006a60: c6 27 bf d4 st %g3, [ %fp + -44 ]
40006a64: c6 07 bf d4 ld [ %fp + -44 ], %g3
40006a68: 94 10 00 08 mov %o0, %o2
40006a6c: 98 10 00 03 mov %g3, %o4
40006a70: 90 10 00 1c mov %i4, %o0
40006a74: 92 10 00 1d mov %i5, %o1
40006a78: 7f ff fc 78 call 40005c58 <rtems_fdisk_seg_read>
40006a7c: 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)
40006a80: 86 92 20 00 orcc %o0, 0, %g3
40006a84: 22 80 00 13 be,a 40006ad0 <rtems_fdisk_ioctl+0x304> <== ALWAYS TAKEN
40006a88: 03 10 01 20 sethi %hi(0x40048000), %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40006a8c: e0 07 60 08 ld [ %i5 + 8 ], %l0 <== NOT EXECUTED
40006a90: f2 07 60 0c ld [ %i5 + 0xc ], %i1 <== NOT EXECUTED
40006a94: fa 05 60 04 ld [ %l5 + 4 ], %i5 <== NOT EXECUTED
40006a98: 40 00 73 8e call 400238d0 <strerror> <== NOT EXECUTED
40006a9c: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED
40006aa0: c6 07 bf d4 ld [ %fp + -44 ], %g3 <== NOT EXECUTED
40006aa4: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006aa8: c6 23 a0 5c st %g3, [ %sp + 0x5c ] <== NOT EXECUTED
40006aac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40006ab0: 13 10 00 cb sethi %hi(0x40032c00), %o1 <== NOT EXECUTED
40006ab4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40006ab8: 92 12 63 00 or %o1, 0x300, %o1 <== NOT EXECUTED
40006abc: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
40006ac0: 7f ff fb 4c call 400057f0 <rtems_fdisk_info> <== NOT EXECUTED
40006ac4: 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)
40006ac8: 10 80 00 2a b 40006b70 <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
40006acc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
40006ad0: 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);
40006ad4: c8 00 61 c8 ld [ %g1 + 0x1c8 ], %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++)
40006ad8: 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;
40006adc: 10 80 00 09 b 40006b00 <rtems_fdisk_ioctl+0x334>
40006ae0: 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);
40006ae4: fa 0c 00 02 ldub [ %l0 + %g2 ], %i5
40006ae8: 95 32 a0 10 srl %o2, 0x10, %o2
40006aec: 94 1f 40 0a xor %i5, %o2, %o2
40006af0: 94 0a a0 ff and %o2, 0xff, %o2
40006af4: 95 2a a0 01 sll %o2, 1, %o2
40006af8: 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++)
40006afc: 84 00 a0 01 inc %g2
40006b00: 80 a0 80 03 cmp %g2, %g3
40006b04: 12 bf ff f8 bne 40006ae4 <rtems_fdisk_ioctl+0x318>
40006b08: 95 2a a0 10 sll %o2, 0x10, %o2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
40006b0c: d6 15 00 13 lduh [ %l4 + %l3 ], %o3
40006b10: 95 32 a0 10 srl %o2, 0x10, %o2
40006b14: 80 a2 80 0b cmp %o2, %o3
40006b18: 02 80 03 8a be 40007940 <rtems_fdisk_ioctl+0x1174> <== ALWAYS TAKEN
40006b1c: 11 10 00 cb sethi %hi(0x40032c00), %o0
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
40006b20: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006b24: 7f ff fb 93 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006b28: 90 12 23 38 or %o0, 0x338, %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)
40006b2c: 10 80 00 11 b 40006b70 <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
40006b30: 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",
40006b34: 10 80 00 04 b 40006b44 <rtems_fdisk_ioctl+0x378> <== NOT EXECUTED
40006b38: 90 12 23 70 or %o0, 0x370, %o0 <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
40006b3c: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006b40: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 40032fa8 <Callbacks.6428+0x790><== NOT EXECUTED
40006b44: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
40006b48: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
40006b4c: 7f ff fb 89 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006b50: 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)
40006b54: 10 80 03 7f b 40007950 <rtems_fdisk_ioctl+0x1184> <== NOT EXECUTED
40006b58: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40006b5c: c4 07 bf e8 ld [ %fp + -24 ], %g2
40006b60: 80 a4 40 02 cmp %l1, %g2
40006b64: 32 bf ff 6f bne,a 40006920 <rtems_fdisk_ioctl+0x154>
40006b68: f2 06 00 00 ld [ %i0 ], %i1
40006b6c: 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++)
40006b70: a4 04 a0 01 inc %l2
40006b74: 80 a0 60 00 cmp %g1, 0
40006b78: 12 80 00 08 bne 40006b98 <rtems_fdisk_ioctl+0x3cc> <== NEVER TAKEN
40006b7c: b0 06 20 10 add %i0, 0x10, %i0
40006b80: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40006b84: 80 a4 80 01 cmp %l2, %g1
40006b88: 2a bf ff 5e bcs,a 40006900 <rtems_fdisk_ioctl+0x134>
40006b8c: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006b90: 10 80 00 03 b 40006b9c <rtems_fdisk_ioctl+0x3d0>
40006b94: 92 10 20 00 clr %o1
40006b98: 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);
40006b9c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40006ba0: 9f c0 40 00 call %g1
40006ba4: 90 10 00 1a mov %i2, %o0
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
40006ba8: 10 80 01 8e b 400071e0 <rtems_fdisk_ioctl+0xa14>
40006bac: c2 07 bf ec ld [ %fp + -20 ], %g1
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40006bb0: 40 00 69 83 call 400211bc <__errno>
40006bb4: a0 06 a0 18 add %i2, 0x18, %l0
40006bb8: 03 10 01 20 sethi %hi(0x40048000), %g1
40006bbc: fa 00 61 c0 ld [ %g1 + 0x1c0 ], %i5 ! 400481c0 <rtems_flashdisks>
40006bc0: d0 27 bf e8 st %o0, [ %fp + -24 ]
40006bc4: 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++)
40006bc8: 10 80 01 7a b 400071b0 <rtems_fdisk_ioctl+0x9e4>
40006bcc: c0 27 bf ec clr [ %fp + -20 ]
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40006bd0: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
40006bd4: 7f ff ee aa call 4000267c <.udiv>
40006bd8: a4 10 20 00 clr %l2
data = sg->buffer;
40006bdc: 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;
40006be0: 10 80 01 69 b 40007184 <rtems_fdisk_ioctl+0x9b8>
40006be4: 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);
40006be8: 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);
40006bec: 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);
40006bf0: 13 10 00 cb sethi %hi(0x40032c00), %o1
40006bf4: 94 10 00 19 mov %i1, %o2
40006bf8: 7f ff fa fe call 400057f0 <rtems_fdisk_info>
40006bfc: 92 12 63 d8 or %o1, 0x3d8, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40006c00: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
40006c04: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40006c08: 82 20 80 01 sub %g2, %g1, %g1
40006c0c: 80 a6 40 01 cmp %i1, %g1
40006c10: 2a 80 00 08 bcs,a 40006c30 <rtems_fdisk_ioctl+0x464> <== ALWAYS TAKEN
40006c14: ec 07 60 18 ld [ %i5 + 0x18 ], %l6
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
40006c18: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006c1c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006c20: 7f ff fb 54 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006c24: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
rtems_fdisk_queue_segment (fd, sc);
return EIO;
40006c28: 10 80 01 5c b 40007198 <rtems_fdisk_ioctl+0x9cc> <== NOT EXECUTED
40006c2c: 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];
40006c30: ab 2e 60 03 sll %i1, 3, %l5
/*
* Does the page exist in flash ?
*/
if (bc->segment)
40006c34: f8 05 80 15 ld [ %l6 + %l5 ], %i4
40006c38: 80 a7 20 00 cmp %i4, 0
40006c3c: 02 80 00 95 be 40006e90 <rtems_fdisk_ioctl+0x6c4>
40006c40: b0 05 80 15 add %l6, %l5, %i0
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
40006c44: c2 06 20 04 ld [ %i0 + 4 ], %g1
40006c48: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
40006c4c: d4 07 20 08 ld [ %i4 + 8 ], %o2
40006c50: d6 07 20 0c ld [ %i4 + 0xc ], %o3
40006c54: 98 10 00 01 mov %g1, %o4
40006c58: 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];
40006c5c: c4 27 bf e0 st %g2, [ %fp + -32 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
40006c60: 90 10 00 1d mov %i5, %o0
40006c64: 13 10 00 cc sethi %hi(0x40033000), %o1
40006c68: 7f ff fa e2 call 400057f0 <rtems_fdisk_info>
40006c6c: 92 12 60 10 or %o1, 0x10, %o1 ! 40033010 <Callbacks.6428+0x7f8>
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
40006c70: 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);
40006c74: 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,
40006c78: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
40006c7c: 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,
40006c80: 90 02 00 02 add %o0, %g2, %o0
40006c84: 7f ff ee 44 call 40002594 <.umul>
40006c88: 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;
40006c8c: 89 2d 20 04 sll %l4, 4, %g4
40006c90: 87 2d 20 02 sll %l4, 2, %g3
40006c94: 86 21 00 03 sub %g4, %g3, %g3
40006c98: 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,
40006c9c: 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;
40006ca0: 9e 01 00 03 add %g4, %g3, %o7
40006ca4: c8 01 00 03 ld [ %g4 + %g3 ], %g4
40006ca8: 9b 2c e0 06 sll %l3, 6, %o5
40006cac: 87 2c e0 04 sll %l3, 4, %g3
40006cb0: 86 23 40 03 sub %o5, %g3, %g3
40006cb4: 86 01 00 03 add %g4, %g3, %g3
40006cb8: 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;
40006cbc: 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,
40006cc0: 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;
40006cc4: c6 00 e0 08 ld [ %g3 + 8 ], %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
40006cc8: 94 10 00 14 mov %l4, %o2
40006ccc: 98 10 00 02 mov %g2, %o4
40006cd0: c4 3f bf d0 std %g2, [ %fp + -48 ]
40006cd4: 96 10 00 13 mov %l3, %o3
40006cd8: 9a 10 00 17 mov %l7, %o5
40006cdc: c8 27 bf cc st %g4, [ %fp + -52 ]
40006ce0: 90 10 00 1d mov %i5, %o0
40006ce4: 13 10 00 cc sethi %hi(0x40033000), %o1
40006ce8: 7f ff fa e2 call 40005870 <rtems_fdisk_printf>
40006cec: 92 12 60 38 or %o1, 0x38, %o1 ! 40033038 <Callbacks.6428+0x820>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
40006cf0: c6 07 bf d4 ld [ %fp + -44 ], %g3
40006cf4: c8 07 bf cc ld [ %fp + -52 ], %g4
40006cf8: c4 07 bf d0 ld [ %fp + -48 ], %g2
40006cfc: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
40006d00: 92 10 00 14 mov %l4, %o1
40006d04: 90 10 00 04 mov %g4, %o0
40006d08: 94 10 00 13 mov %l3, %o2
40006d0c: 96 10 00 02 mov %g2, %o3
40006d10: 98 10 00 11 mov %l1, %o4
40006d14: 9f c0 c0 00 call %g3
40006d18: 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,
40006d1c: c2 07 bf dc ld [ %fp + -36 ], %g1
40006d20: 80 a2 20 00 cmp %o0, 0
40006d24: 12 80 00 0c bne 40006d54 <rtems_fdisk_ioctl+0x588>
40006d28: 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",
40006d2c: d6 07 20 08 ld [ %i4 + 8 ], %o3
40006d30: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40006d34: 90 10 00 1d mov %i5, %o0
40006d38: 13 10 00 cc sethi %hi(0x40033000), %o1
40006d3c: 94 10 00 19 mov %i1, %o2
40006d40: 92 12 60 60 or %o1, 0x60, %o1
40006d44: 7f ff fa ab call 400057f0 <rtems_fdisk_info>
40006d48: 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)
40006d4c: 10 80 01 0c b 4000717c <rtems_fdisk_ioctl+0x9b0>
40006d50: 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];
40006d54: c4 07 bf e0 ld [ %fp + -32 ], %g2
40006d58: 83 28 60 03 sll %g1, 3, %g1
40006d5c: 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;
40006d60: 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))
40006d64: 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;
40006d68: 82 08 7f fd and %g1, -3, %g1
40006d6c: 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))
40006d70: 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)) +
40006d74: 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))
40006d78: 02 80 00 1e be 40006df0 <rtems_fdisk_ioctl+0x624> <== NEVER TAKEN
40006d7c: 82 00 60 02 add %g1, 2, %g1
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
40006d80: 94 10 00 01 mov %g1, %o2
40006d84: c2 27 bf dc st %g1, [ %fp + -36 ]
40006d88: 90 10 00 1d mov %i5, %o0
40006d8c: 92 10 00 1c mov %i4, %o1
40006d90: 96 07 bf f6 add %fp, -10, %o3
40006d94: 7f ff fb b1 call 40005c58 <rtems_fdisk_seg_read>
40006d98: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
40006d9c: a6 92 20 00 orcc %o0, 0, %l3
40006da0: 12 80 00 1d bne 40006e14 <rtems_fdisk_ioctl+0x648> <== NEVER TAKEN
40006da4: c2 07 bf dc ld [ %fp + -36 ], %g1
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
40006da8: c4 15 e0 02 lduh [ %l7 + 2 ], %g2
40006dac: d8 17 bf f6 lduh [ %fp + -10 ], %o4
40006db0: 86 08 80 0c and %g2, %o4, %g3
40006db4: 85 28 a0 10 sll %g2, 0x10, %g2
40006db8: 87 28 e0 10 sll %g3, 0x10, %g3
40006dbc: 80 a0 c0 02 cmp %g3, %g2
40006dc0: 02 80 00 0c be 40006df0 <rtems_fdisk_ioctl+0x624> <== ALWAYS TAKEN
40006dc4: 9b 30 a0 10 srl %g2, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
40006dc8: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
40006dcc: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
40006dd0: 99 2b 20 10 sll %o4, 0x10, %o4 <== NOT EXECUTED
40006dd4: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40006dd8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
40006ddc: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
40006de0: 7f ff fa e4 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006de4: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40006de8: 10 80 00 1c b 40006e58 <rtems_fdisk_ioctl+0x68c> <== NOT EXECUTED
40006dec: 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,
40006df0: 90 10 00 1d mov %i5, %o0
40006df4: 92 10 00 1c mov %i4, %o1
40006df8: 94 10 00 01 mov %g1, %o2
40006dfc: 96 05 e0 02 add %l7, 2, %o3
40006e00: 7f ff fb d9 call 40005d64 <rtems_fdisk_seg_write>
40006e04: 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)
40006e08: a6 92 20 00 orcc %o0, 0, %l3
40006e0c: 22 80 00 13 be,a 40006e58 <rtems_fdisk_ioctl+0x68c> <== ALWAYS TAKEN
40006e10: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
40006e14: d4 07 20 08 ld [ %i4 + 8 ], %o2 <== NOT EXECUTED
40006e18: ee 07 20 0c ld [ %i4 + 0xc ], %l7 <== NOT EXECUTED
40006e1c: e8 06 20 04 ld [ %i0 + 4 ], %l4 <== NOT EXECUTED
40006e20: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40006e24: 40 00 72 ab call 400238d0 <strerror> <== NOT EXECUTED
40006e28: d4 27 bf c8 st %o2, [ %fp + -56 ] <== NOT EXECUTED
40006e2c: d4 07 bf c8 ld [ %fp + -56 ], %o2 <== NOT EXECUTED
40006e30: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006e34: e6 23 a0 5c st %l3, [ %sp + 0x5c ] <== NOT EXECUTED
40006e38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006e3c: 13 10 00 cc sethi %hi(0x40033000), %o1 <== NOT EXECUTED
40006e40: 96 10 00 17 mov %l7, %o3 <== NOT EXECUTED
40006e44: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED
40006e48: 7f ff fa 6a call 400057f0 <rtems_fdisk_info> <== NOT EXECUTED
40006e4c: 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);
40006e50: 10 80 00 08 b 40006e70 <rtems_fdisk_ioctl+0x6a4> <== NOT EXECUTED
40006e54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40006e58: 82 00 7f ff add %g1, -1, %g1
40006e5c: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
sc->pages_used++;
40006e60: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40006e64: 82 00 60 01 inc %g1
40006e68: 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);
40006e6c: 90 10 00 1d mov %i5, %o0
40006e70: 7f ff fb 1d call 40005ae4 <rtems_fdisk_queue_segment>
40006e74: 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)
40006e78: c2 07 60 08 ld [ %i5 + 8 ], %g1
40006e7c: 80 88 60 02 btst 2, %g1
40006e80: 12 80 00 05 bne 40006e94 <rtems_fdisk_ioctl+0x6c8> <== NEVER TAKEN
40006e84: b8 07 60 34 add %i5, 0x34, %i4
rtems_fdisk_compact (fd);
40006e88: 7f ff fd c3 call 40006594 <rtems_fdisk_compact>
40006e8c: 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) <=
40006e90: b8 07 60 34 add %i5, 0x34, %i4
40006e94: 7f ff f9 f7 call 40005670 <rtems_fdisk_segment_count_queue>
40006e98: 90 10 00 1c mov %i4, %o0
40006e9c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40006ea0: 80 a2 00 01 cmp %o0, %g1
40006ea4: 18 80 00 04 bgu 40006eb4 <rtems_fdisk_ioctl+0x6e8>
40006ea8: 01 00 00 00 nop
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
40006eac: 7f ff fd ba call 40006594 <rtems_fdisk_compact>
40006eb0: 90 10 00 1d mov %i5, %o0
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
40006eb4: 7f ff f9 9b call 40005520 <rtems_fdisk_segment_queue_pop_head>
40006eb8: 90 10 00 1c mov %i4, %o0
/*
* Is the flash disk full ?
*/
if (!sc)
40006ebc: a6 92 20 00 orcc %o0, 0, %l3
40006ec0: 32 80 00 13 bne,a 40006f0c <rtems_fdisk_ioctl+0x740> <== ALWAYS TAKEN
40006ec4: 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))
40006ec8: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40006ecc: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40006ed0: 02 80 00 04 be 40006ee0 <rtems_fdisk_ioctl+0x714> <== NOT EXECUTED
40006ed4: 01 00 00 00 nop <== NOT EXECUTED
rtems_fdisk_compact (fd);
40006ed8: 7f ff fd af call 40006594 <rtems_fdisk_compact> <== NOT EXECUTED
40006edc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* Try again for some free space.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
40006ee0: 7f ff f9 90 call 40005520 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
40006ee4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (!sc)
40006ee8: a6 92 20 00 orcc %o0, 0, %l3 <== NOT EXECUTED
40006eec: 32 80 00 08 bne,a 40006f0c <rtems_fdisk_ioctl+0x740> <== NOT EXECUTED
40006ef0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: no available pages");
40006ef4: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
return ENOSPC;
40006ef8: 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");
40006efc: 7f ff fa 9d call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006f00: 90 12 21 20 or %o0, 0x120, %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++)
40006f04: 10 80 00 a6 b 4000719c <rtems_fdisk_ioctl+0x9d0> <== NOT EXECUTED
40006f08: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
40006f0c: 80 a0 60 02 cmp %g1, 2
40006f10: 28 80 00 0f bleu,a 40006f4c <rtems_fdisk_ioctl+0x780> <== ALWAYS TAKEN
40006f14: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
40006f18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006f1c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40006f20: 7f ff f9 e8 call 400056c0 <rtems_fdisk_queue_status> <== NOT EXECUTED
40006f24: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
40006f28: d6 04 e0 08 ld [ %l3 + 8 ], %o3 <== NOT EXECUTED
40006f2c: d8 04 e0 0c ld [ %l3 + 0xc ], %o4 <== NOT EXECUTED
40006f30: 13 10 00 cc sethi %hi(0x40033000), %o1 <== NOT EXECUTED
40006f34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006f38: 92 12 61 40 or %o1, 0x140, %o1 <== NOT EXECUTED
40006f3c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40006f40: 7f ff fa 2c call 400057f0 <rtems_fdisk_info> <== NOT EXECUTED
40006f44: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
40006f48: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1 <== NOT EXECUTED
for (page = 0; page < sc->pages; page++, pd++)
40006f4c: ee 04 e0 14 ld [ %l3 + 0x14 ], %l7
40006f50: 10 80 00 77 b 4000712c <rtems_fdisk_ioctl+0x960>
40006f54: b8 10 20 00 clr %i4
{
if (rtems_fdisk_page_desc_erased (pd))
40006f58: c2 27 bf dc st %g1, [ %fp + -36 ]
40006f5c: 7f ff fa 01 call 40005760 <rtems_fdisk_page_desc_erased>
40006f60: 90 10 00 14 mov %l4, %o0
40006f64: 80 8a 20 ff btst 0xff, %o0
40006f68: 02 80 00 70 be 40007128 <rtems_fdisk_ioctl+0x95c>
40006f6c: 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);
40006f70: 03 10 01 20 sethi %hi(0x40048000), %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);
40006f74: 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);
40006f78: c8 00 61 c8 ld [ %g1 + 0x1c8 ], %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++)
40006f7c: 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;
40006f80: 10 80 00 07 b 40006f9c <rtems_fdisk_ioctl+0x7d0>
40006f84: 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);
40006f88: 82 08 60 ff and %g1, 0xff, %g1
40006f8c: 82 18 40 0f xor %g1, %o7, %g1
40006f90: 83 28 60 01 sll %g1, 1, %g1
40006f94: 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++)
40006f98: 84 00 a0 01 inc %g2
40006f9c: 80 a0 80 03 cmp %g2, %g3
40006fa0: 32 bf ff fa bne,a 40006f88 <rtems_fdisk_ioctl+0x7bc>
40006fa4: 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);
40006fa8: c2 35 00 00 sth %g1, [ %l4 ]
pd->block = block;
40006fac: 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;
40006fb0: 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;
40006fb4: e6 25 80 15 st %l3, [ %l6 + %l5 ]
bc->page = page;
40006fb8: 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: " \
40006fbc: 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;
40006fc0: 84 08 bf fe and %g2, -2, %g2
40006fc4: 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: " \
40006fc8: d6 04 e0 08 ld [ %l3 + 8 ], %o3
40006fcc: d8 04 e0 0c ld [ %l3 + 0xc ], %o4
40006fd0: da 04 e0 1c ld [ %l3 + 0x1c ], %o5
40006fd4: de 04 e0 20 ld [ %l3 + 0x20 ], %o7
40006fd8: 80 a0 e0 00 cmp %g3, 0
40006fdc: 02 80 00 05 be 40006ff0 <rtems_fdisk_ioctl+0x824> <== ALWAYS TAKEN
40006fe0: c8 04 e0 24 ld [ %l3 + 0x24 ], %g4
40006fe4: 07 10 00 ca sethi %hi(0x40032800), %g3 <== NOT EXECUTED
40006fe8: 10 80 00 04 b 40006ff8 <rtems_fdisk_ioctl+0x82c> <== NOT EXECUTED
40006fec: 86 10 e1 f0 or %g3, 0x1f0, %g3 ! 400329f0 <Callbacks.6428+0x1d8><== NOT EXECUTED
40006ff0: 07 10 00 ca sethi %hi(0x40032800), %g3
40006ff4: 86 10 e1 f8 or %g3, 0x1f8, %g3 ! 400329f8 <Callbacks.6428+0x1e0>
40006ff8: 85 28 a0 10 sll %g2, 0x10, %g2
40006ffc: 83 28 60 10 sll %g1, 0x10, %g1
40007000: 85 30 a0 10 srl %g2, 0x10, %g2
40007004: 83 30 60 10 srl %g1, 0x10, %g1
40007008: 94 10 00 19 mov %i1, %o2
4000700c: da 23 a0 60 st %o5, [ %sp + 0x60 ]
40007010: de 23 a0 64 st %o7, [ %sp + 0x64 ]
40007014: c8 23 a0 68 st %g4, [ %sp + 0x68 ]
40007018: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
4000701c: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
40007020: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40007024: f2 23 a0 78 st %i1, [ %sp + 0x78 ]
40007028: 9a 10 00 1c mov %i4, %o5
4000702c: ee 23 a0 5c st %l7, [ %sp + 0x5c ]
40007030: 90 10 00 1d mov %i5, %o0
40007034: 13 10 00 cc sethi %hi(0x40033000), %o1
40007038: 7f ff f9 ee call 400057f0 <rtems_fdisk_info>
4000703c: 92 12 61 68 or %o1, 0x168, %o1 ! 40033168 <Callbacks.6428+0x950>
/*
* 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);
40007040: d4 04 e0 18 ld [ %l3 + 0x18 ], %o2
40007044: 90 10 00 1d mov %i5, %o0
40007048: 92 10 00 13 mov %l3, %o1
4000704c: 94 07 00 0a add %i4, %o2, %o2
40007050: 7f ff fc 55 call 400061a4 <rtems_fdisk_seg_write_page>
40007054: 96 10 00 11 mov %l1, %o3
if (ret)
40007058: b2 92 20 00 orcc %o0, 0, %i1
4000705c: 22 80 00 0d be,a 40007090 <rtems_fdisk_ioctl+0x8c4> <== ALWAYS TAKEN
40007060: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
40007064: e8 04 e0 08 ld [ %l3 + 8 ], %l4 <== NOT EXECUTED
40007068: 40 00 72 1a call 400238d0 <strerror> <== NOT EXECUTED
4000706c: f0 04 e0 0c ld [ %l3 + 0xc ], %i0 <== NOT EXECUTED
40007070: 13 10 00 cc sethi %hi(0x40033000), %o1 <== NOT EXECUTED
40007074: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40007078: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
4000707c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007080: 92 12 61 b8 or %o1, 0x1b8, %o1 <== NOT EXECUTED
40007084: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
40007088: 10 80 00 14 b 400070d8 <rtems_fdisk_ioctl+0x90c> <== NOT EXECUTED
4000708c: 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);
40007090: 92 10 00 13 mov %l3, %o1
40007094: 94 10 00 1c mov %i4, %o2
40007098: 7f ff fb 59 call 40005dfc <rtems_fdisk_seg_write_page_desc>
4000709c: 96 10 00 14 mov %l4, %o3
if (ret)
400070a0: b2 92 20 00 orcc %o0, 0, %i1
400070a4: 22 80 00 11 be,a 400070e8 <rtems_fdisk_ioctl+0x91c> <== ALWAYS TAKEN
400070a8: c2 04 e0 1c ld [ %l3 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
400070ac: ea 04 e0 08 ld [ %l3 + 8 ], %l5 <== NOT EXECUTED
400070b0: e8 04 e0 0c ld [ %l3 + 0xc ], %l4 <== NOT EXECUTED
400070b4: 40 00 72 07 call 400238d0 <strerror> <== NOT EXECUTED
400070b8: f8 06 20 04 ld [ %i0 + 4 ], %i4 <== NOT EXECUTED
400070bc: 13 10 00 cc sethi %hi(0x40033000), %o1 <== NOT EXECUTED
400070c0: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
400070c4: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
400070c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400070cc: 92 12 61 f0 or %o1, 0x1f0, %o1 <== NOT EXECUTED
400070d0: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
400070d4: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
400070d8: 7f ff f9 c6 call 400057f0 <rtems_fdisk_info> <== NOT EXECUTED
400070dc: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
400070e0: 10 80 00 05 b 400070f4 <rtems_fdisk_ioctl+0x928> <== NOT EXECUTED
400070e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
400070e8: 82 00 60 01 inc %g1
400070ec: c2 24 e0 1c st %g1, [ %l3 + 0x1c ]
}
}
rtems_fdisk_queue_segment (fd, sc);
400070f0: 90 10 00 1d mov %i5, %o0
400070f4: 7f ff fa 7c call 40005ae4 <rtems_fdisk_queue_segment>
400070f8: 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)
400070fc: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
40007100: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40007104: 80 a0 80 01 cmp %g2, %g1
40007108: 1a 80 00 19 bcc 4000716c <rtems_fdisk_ioctl+0x9a0>
4000710c: 90 10 00 1d mov %i5, %o0
fd->starvations++;
40007110: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
40007114: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
40007118: 7f ff fd 1f call 40006594 <rtems_fdisk_compact>
4000711c: 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)
40007120: 10 80 00 14 b 40007170 <rtems_fdisk_ioctl+0x9a4>
40007124: 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++)
40007128: 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)
4000712c: 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++)
40007130: 80 a7 00 17 cmp %i4, %l7
40007134: 12 bf ff 89 bne 40006f58 <rtems_fdisk_ioctl+0x78c> <== ALWAYS TAKEN
40007138: a8 00 40 14 add %g1, %l4, %l4
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
4000713c: d2 04 e0 08 ld [ %l3 + 8 ], %o1 <== NOT EXECUTED
40007140: d4 04 e0 0c ld [ %l3 + 0xc ], %o2 <== NOT EXECUTED
40007144: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED
40007148: 7f ff fa 0a call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
4000714c: 90 12 22 30 or %o0, 0x230, %o0 ! 40033230 <Callbacks.6428+0xa18><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
40007150: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
40007154: 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;
40007158: c2 24 e0 28 st %g1, [ %l3 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
4000715c: 7f ff fa 62 call 40005ae4 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40007160: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
return EIO;
40007164: 10 80 00 0d b 40007198 <rtems_fdisk_ioctl+0x9cc> <== NOT EXECUTED
40007168: 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)
4000716c: 80 a6 60 00 cmp %i1, 0
40007170: 12 80 00 0b bne 4000719c <rtems_fdisk_ioctl+0x9d0> <== NEVER TAKEN
40007174: 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)
40007178: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000717c: a4 04 a0 01 inc %l2
40007180: a2 04 40 01 add %l1, %g1, %l1
40007184: c2 07 bf e4 ld [ %fp + -28 ], %g1
40007188: 80 a4 80 01 cmp %l2, %g1
4000718c: 32 bf fe 97 bne,a 40006be8 <rtems_fdisk_ioctl+0x41c>
40007190: f2 04 00 00 ld [ %l0 ], %i1
40007194: 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++)
40007198: c4 07 bf ec ld [ %fp + -20 ], %g2
4000719c: a0 04 20 10 add %l0, 0x10, %l0
400071a0: 84 00 a0 01 inc %g2
400071a4: 80 a6 60 00 cmp %i1, 0
400071a8: 12 80 00 09 bne 400071cc <rtems_fdisk_ioctl+0xa00> <== NEVER TAKEN
400071ac: c4 27 bf ec st %g2, [ %fp + -20 ]
400071b0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
400071b4: c4 07 bf ec ld [ %fp + -20 ], %g2
400071b8: 80 a0 80 01 cmp %g2, %g1
400071bc: 2a bf fe 85 bcs,a 40006bd0 <rtems_fdisk_ioctl+0x404>
400071c0: d0 04 20 04 ld [ %l0 + 4 ], %o0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
400071c4: 10 80 00 03 b 400071d0 <rtems_fdisk_ioctl+0xa04>
400071c8: 92 10 20 00 clr %o1
400071cc: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
400071d0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400071d4: 9f c0 40 00 call %g1
400071d8: 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);
400071dc: c2 07 bf e8 ld [ %fp + -24 ], %g1
break;
400071e0: 10 80 01 c5 b 400078f4 <rtems_fdisk_ioctl+0x1128>
400071e4: c0 20 40 00 clr [ %g1 ]
default:
errno = EINVAL;
400071e8: 40 00 67 f5 call 400211bc <__errno> <== NOT EXECUTED
400071ec: 01 00 00 00 nop <== NOT EXECUTED
400071f0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
400071f4: 10 80 01 c0 b 400078f4 <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
400071f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
400071fc: 40 00 67 f0 call 400211bc <__errno> <== NOT EXECUTED
40007200: 21 10 00 cc sethi %hi(0x40033000), %l0 <== NOT EXECUTED
40007204: fa 07 61 c0 ld [ %i5 + 0x1c0 ], %i5 <== NOT EXECUTED
40007208: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
4000720c: 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");
40007210: 13 10 00 cc sethi %hi(0x40033000), %o1 <== NOT EXECUTED
40007214: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007218: 92 12 62 68 or %o1, 0x268, %o1 <== NOT EXECUTED
4000721c: 7f ff f9 75 call 400057f0 <rtems_fdisk_info> <== NOT EXECUTED
40007220: 31 10 00 cc sethi %hi(0x40033000), %i0 <== NOT EXECUTED
40007224: 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++)
40007228: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
4000722c: a0 14 22 78 or %l0, 0x278, %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);
40007230: 10 80 00 17 b 4000728c <rtems_fdisk_ioctl+0xac0> <== NOT EXECUTED
40007234: b0 16 22 90 or %i0, 0x290, %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);
40007238: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4000723c: 7f ff f9 6d call 400057f0 <rtems_fdisk_info> <== NOT EXECUTED
40007240: 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;
40007244: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
40007248: 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;
4000724c: 82 00 40 1a add %g1, %i2, %g1 <== NOT EXECUTED
40007250: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
40007254: 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;
40007258: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
4000725c: 7f ff f9 85 call 40005870 <rtems_fdisk_printf> <== NOT EXECUTED
40007260: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
40007264: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
40007268: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
4000726c: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
40007270: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
40007274: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40007278: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000727c: 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)
40007280: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40007284: 12 80 00 18 bne 400072e4 <rtems_fdisk_ioctl+0xb18> <== NOT EXECUTED
40007288: 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++)
4000728c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40007290: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40007294: 0a bf ff e9 bcs 40007238 <rtems_fdisk_ioctl+0xa6c> <== NOT EXECUTED
40007298: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000729c: b4 10 20 00 clr %i2 <== NOT EXECUTED
400072a0: 10 80 00 0d b 400072d4 <rtems_fdisk_ioctl+0xb08> <== NOT EXECUTED
400072a4: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
400072a8: c2 00 40 1a ld [ %g1 + %i2 ], %g1 <== NOT EXECUTED
400072ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400072b0: 02 80 00 0d be 400072e4 <rtems_fdisk_ioctl+0xb18> <== NOT EXECUTED
400072b4: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
400072b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400072bc: 7f ff fa e1 call 40005e40 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
400072c0: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
if (ret)
400072c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400072c8: 12 80 00 07 bne 400072e4 <rtems_fdisk_ioctl+0xb18> <== NOT EXECUTED
400072cc: 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++)
400072d0: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
400072d4: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
400072d8: 2a bf ff f4 bcs,a 400072a8 <rtems_fdisk_ioctl+0xadc> <== NOT EXECUTED
400072dc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
400072e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
400072e4: 10 80 01 84 b 400078f4 <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
400072e8: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
400072ec: 40 00 67 b4 call 400211bc <__errno> <== NOT EXECUTED
400072f0: 01 00 00 00 nop <== NOT EXECUTED
400072f4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
400072f8: d0 07 61 c0 ld [ %i5 + 0x1c0 ], %o0 <== NOT EXECUTED
400072fc: 7f ff fc a6 call 40006594 <rtems_fdisk_compact> <== NOT EXECUTED
40007300: 90 02 00 1b add %o0, %i3, %o0 <== NOT EXECUTED
break;
40007304: 10 80 01 7c b 400078f4 <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
40007308: d0 27 00 00 st %o0, [ %i4 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
4000730c: 40 00 67 ac call 400211bc <__errno> <== NOT EXECUTED
40007310: 01 00 00 00 nop <== NOT EXECUTED
40007314: f8 07 61 c0 ld [ %i5 + 0x1c0 ], %i4 <== NOT EXECUTED
40007318: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
4000731c: 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;
40007320: ba 10 20 00 clr %i5 <== NOT EXECUTED
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
40007324: 10 80 00 09 b 40007348 <rtems_fdisk_ioctl+0xb7c> <== NOT EXECUTED
40007328: 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);
4000732c: 7f ff f9 ae call 400059e4 <rtems_fdisk_erase_segment> <== NOT EXECUTED
40007330: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret && !latched_ret)
40007334: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40007338: 02 80 00 04 be 40007348 <rtems_fdisk_ioctl+0xb7c> <== NOT EXECUTED
4000733c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
40007340: 22 80 00 02 be,a 40007348 <rtems_fdisk_ioctl+0xb7c> <== NOT EXECUTED
40007344: 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)))
40007348: 7f ff f8 76 call 40005520 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
4000734c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40007350: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
40007354: 12 bf ff f6 bne 4000732c <rtems_fdisk_ioctl+0xb60> <== NOT EXECUTED
40007358: 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;
4000735c: 10 80 01 66 b 400078f4 <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
40007360: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
40007364: 40 00 67 96 call 400211bc <__errno> <== NOT EXECUTED
40007368: 01 00 00 00 nop <== NOT EXECUTED
4000736c: fa 07 61 c0 ld [ %i5 + 0x1c0 ], %i5 <== NOT EXECUTED
40007370: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
40007374: 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;
40007378: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
data->block_count = fd->block_count;
4000737c: c4 07 60 1c ld [ %i5 + 0x1c ], %g2 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
40007380: 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;
40007384: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
40007388: 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;
4000738c: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
40007390: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
40007394: f2 26 a0 0c st %i1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
40007398: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
4000739c: 10 80 00 0a b 400073c4 <rtems_fdisk_ioctl+0xbf8> <== NOT EXECUTED
400073a0: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (fd->blocks[i].segment)
400073a4: 87 28 60 03 sll %g1, 3, %g3 <== NOT EXECUTED
400073a8: c6 01 00 03 ld [ %g4 + %g3 ], %g3 <== NOT EXECUTED
400073ac: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
400073b0: 02 80 00 05 be 400073c4 <rtems_fdisk_ioctl+0xbf8> <== NOT EXECUTED
400073b4: 82 00 60 01 inc %g1 <== NOT EXECUTED
data->blocks_used++;
400073b8: c6 06 a0 18 ld [ %i2 + 0x18 ], %g3 <== NOT EXECUTED
400073bc: 86 00 e0 01 inc %g3 <== NOT EXECUTED
400073c0: 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++)
400073c4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400073c8: 32 bf ff f7 bne,a 400073a4 <rtems_fdisk_ioctl+0xbd8> <== NOT EXECUTED
400073cc: 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);
400073d0: 7f ff f8 a8 call 40005670 <rtems_fdisk_segment_count_queue><== NOT EXECUTED
400073d4: 90 07 60 34 add %i5, 0x34, %o0 <== NOT EXECUTED
400073d8: d0 26 a0 1c st %o0, [ %i2 + 0x1c ] <== NOT EXECUTED
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
400073dc: 7f ff f8 a5 call 40005670 <rtems_fdisk_segment_count_queue><== NOT EXECUTED
400073e0: 90 07 60 40 add %i5, 0x40, %o0 <== NOT EXECUTED
400073e4: d0 26 a0 20 st %o0, [ %i2 + 0x20 ] <== NOT EXECUTED
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
400073e8: 7f ff f8 a2 call 40005670 <rtems_fdisk_segment_count_queue><== NOT EXECUTED
400073ec: 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;
400073f0: 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);
400073f4: d0 26 a0 24 st %o0, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
400073f8: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
400073fc: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
40007400: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
40007404: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
40007408: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
4000740c: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
40007410: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
40007414: 10 80 00 2a b 400074bc <rtems_fdisk_ioctl+0xcf0> <== NOT EXECUTED
40007418: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
4000741c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
40007420: 9e 03 c0 03 add %o7, %g3, %o7 <== NOT EXECUTED
40007424: f0 03 e0 04 ld [ %o7 + 4 ], %i0 <== NOT EXECUTED
40007428: b8 10 20 00 clr %i4 <== NOT EXECUTED
4000742c: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
40007430: 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;
40007434: 10 80 00 1d b 400074a8 <rtems_fdisk_ioctl+0xcdc> <== NOT EXECUTED
40007438: 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;
4000743c: 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];
40007440: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
data->page_count += sc->pages;
40007444: 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++)
40007448: 88 01 20 01 inc %g4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
4000744c: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40007450: 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;
40007454: da 26 a0 14 st %o5, [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40007458: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
4000745c: b8 07 20 30 add %i4, 0x30, %i4 <== NOT EXECUTED
40007460: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_active += sc->pages_active;
40007464: 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;
40007468: da 26 a0 2c st %o5, [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active += sc->pages_active;
4000746c: da 00 60 1c ld [ %g1 + 0x1c ], %o5 <== NOT EXECUTED
40007470: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_used += sc->pages_used;
40007474: 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;
40007478: da 26 a0 30 st %o5, [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used += sc->pages_used;
4000747c: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
40007480: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
40007484: 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;
40007488: da 26 a0 34 st %o5, [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
4000748c: da 00 60 24 ld [ %g1 + 0x24 ], %o5 <== NOT EXECUTED
data->seg_erases += sc->erased;
40007490: 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;
40007494: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
40007498: da 26 a0 38 st %o5, [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases += sc->erased;
4000749c: da 06 a0 28 ld [ %i2 + 0x28 ], %o5 <== NOT EXECUTED
400074a0: 82 03 40 01 add %o5, %g1, %g1 <== NOT EXECUTED
400074a4: 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++)
400074a8: 80 a1 00 18 cmp %g4, %i0 <== NOT EXECUTED
400074ac: 32 bf ff e4 bne,a 4000743c <rtems_fdisk_ioctl+0xc70> <== NOT EXECUTED
400074b0: 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++)
400074b4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
400074b8: 86 00 e0 0c add %g3, 0xc, %g3 <== NOT EXECUTED
400074bc: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
400074c0: 32 bf ff d7 bne,a 4000741c <rtems_fdisk_ioctl+0xc50> <== NOT EXECUTED
400074c4: 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;
400074c8: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
400074cc: 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;
400074d0: 10 80 01 09 b 400078f4 <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
400074d4: c0 24 00 00 clr [ %l0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
400074d8: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
break;
400074dc: 10 80 01 06 b 400078f4 <rtems_fdisk_ioctl+0x1128> <== NOT EXECUTED
400074e0: f4 20 60 6c st %i2, [ %g1 + 0x6c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
400074e4: 40 00 67 36 call 400211bc <__errno>
400074e8: 01 00 00 00 nop
400074ec: c2 07 61 c0 ld [ %i5 + 0x1c0 ], %g1
400074f0: d0 27 bf ec st %o0, [ %fp + -20 ]
400074f4: 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;
400074f8: c4 07 60 6c ld [ %i5 + 0x6c ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
400074fc: d4 00 40 1b ld [ %g1 + %i3 ], %o2
40007500: 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;
40007504: c4 27 bf e8 st %g2, [ %fp + -24 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
40007508: 84 10 20 03 mov 3, %g2
rtems_fdisk_printf (fd,
4000750c: 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;
40007510: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
rtems_fdisk_printf (fd,
40007514: 13 10 00 cc sethi %hi(0x40033000), %o1
40007518: 7f ff f8 d6 call 40005870 <rtems_fdisk_printf>
4000751c: 92 12 62 a8 or %o1, 0x2a8, %o1 ! 400332a8 <Callbacks.6428+0xa90>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
40007520: d4 07 60 1c ld [ %i5 + 0x1c ], %o2
40007524: 90 10 00 1d mov %i5, %o0
40007528: 13 10 00 cc sethi %hi(0x40033000), %o1
4000752c: 7f ff f8 d1 call 40005870 <rtems_fdisk_printf>
40007530: 92 12 62 d0 or %o1, 0x2d0, %o1 ! 400332d0 <Callbacks.6428+0xab8>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
40007534: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
40007538: 90 10 00 1d mov %i5, %o0
4000753c: 13 10 00 cc sethi %hi(0x40033000), %o1
40007540: 7f ff f8 cc call 40005870 <rtems_fdisk_printf>
40007544: 92 12 62 e0 or %o1, 0x2e0, %o1 ! 400332e0 <Callbacks.6428+0xac8>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
40007548: d4 07 60 24 ld [ %i5 + 0x24 ], %o2
4000754c: 90 10 00 1d mov %i5, %o0
40007550: 13 10 00 cc sethi %hi(0x40033000), %o1
40007554: 7f ff f8 c7 call 40005870 <rtems_fdisk_printf>
40007558: 92 12 62 f8 or %o1, 0x2f8, %o1 ! 400332f8 <Callbacks.6428+0xae0>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
4000755c: d4 07 60 70 ld [ %i5 + 0x70 ], %o2
40007560: 90 10 00 1d mov %i5, %o0
40007564: 13 10 00 cc sethi %hi(0x40033000), %o1
40007568: 7f ff f8 c2 call 40005870 <rtems_fdisk_printf>
4000756c: 92 12 63 10 or %o1, 0x310, %o1 ! 40033310 <Callbacks.6428+0xaf8>
count = rtems_fdisk_segment_count_queue (&fd->available);
40007570: 7f ff f8 40 call 40005670 <rtems_fdisk_segment_count_queue>
40007574: 90 07 60 34 add %i5, 0x34, %o0
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
40007578: 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);
4000757c: b8 10 00 08 mov %o0, %i4
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
40007580: 13 10 00 cc sethi %hi(0x40033000), %o1
40007584: 94 10 00 1c mov %i4, %o2
40007588: 92 12 63 20 or %o1, 0x320, %o1
4000758c: 7f ff f8 b9 call 40005870 <rtems_fdisk_printf>
40007590: 90 10 00 1d mov %i5, %o0
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
40007594: 7f ff f8 37 call 40005670 <rtems_fdisk_segment_count_queue>
40007598: 90 07 60 40 add %i5, 0x40, %o0
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
4000759c: 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);
400075a0: 94 10 00 08 mov %o0, %o2
total += count;
400075a4: b8 02 00 1c add %o0, %i4, %i4
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
400075a8: 13 10 00 cc sethi %hi(0x40033000), %o1
400075ac: 90 10 00 1d mov %i5, %o0
400075b0: 7f ff f8 b0 call 40005870 <rtems_fdisk_printf>
400075b4: 92 12 63 40 or %o1, 0x340, %o1
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
400075b8: 7f ff f8 2e call 40005670 <rtems_fdisk_segment_count_queue>
400075bc: 90 07 60 4c add %i5, 0x4c, %o0
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
400075c0: 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);
400075c4: 94 10 00 08 mov %o0, %o2
total += count;
400075c8: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
400075cc: 13 10 00 cc sethi %hi(0x40033000), %o1
400075d0: 90 10 00 1d mov %i5, %o0
400075d4: 7f ff f8 a7 call 40005870 <rtems_fdisk_printf>
400075d8: 92 12 63 58 or %o1, 0x358, %o1
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
400075dc: 7f ff f8 25 call 40005670 <rtems_fdisk_segment_count_queue>
400075e0: 90 07 60 58 add %i5, 0x58, %o0
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
400075e4: 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);
400075e8: 94 10 00 08 mov %o0, %o2
total += count;
400075ec: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
400075f0: 13 10 00 cc sethi %hi(0x40033000), %o1
400075f4: 90 10 00 1d mov %i5, %o0
400075f8: 7f ff f8 9e call 40005870 <rtems_fdisk_printf>
400075fc: 92 12 63 70 or %o1, 0x370, %o1
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
40007600: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
40007604: 84 10 20 00 clr %g2
40007608: 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;
4000760c: 10 80 00 07 b 40007628 <rtems_fdisk_ioctl+0xe5c>
40007610: 96 10 20 00 clr %o3
for (device = 0; device < fd->device_count; device++)
40007614: 82 00 60 01 inc %g1
count += fd->devices[device].segment_count;
40007618: 88 01 00 02 add %g4, %g2, %g4
4000761c: c8 01 20 04 ld [ %g4 + 4 ], %g4
40007620: 84 00 a0 0c add %g2, 0xc, %g2
40007624: 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++)
40007628: 80 a0 40 03 cmp %g1, %g3
4000762c: 32 bf ff fa bne,a 40007614 <rtems_fdisk_ioctl+0xe48>
40007630: 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,
40007634: 19 10 00 cb sethi %hi(0x40032c00), %o4
40007638: 80 a7 00 0b cmp %i4, %o3
4000763c: 12 80 00 04 bne 4000764c <rtems_fdisk_ioctl+0xe80> <== NEVER TAKEN
40007640: 98 13 22 50 or %o4, 0x250, %o4
40007644: 19 10 00 cb sethi %hi(0x40032c00), %o4
40007648: 98 13 22 48 or %o4, 0x248, %o4 ! 40032e48 <Callbacks.6428+0x630>
4000764c: 94 10 00 1c mov %i4, %o2
40007650: 90 10 00 1d mov %i5, %o0
40007654: 13 10 00 cc sethi %hi(0x40033000), %o1
40007658: 7f ff f8 86 call 40005870 <rtems_fdisk_printf>
4000765c: 92 12 63 88 or %o1, 0x388, %o1 ! 40033388 <Callbacks.6428+0xb70>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
40007660: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
40007664: 90 10 00 1d mov %i5, %o0
40007668: 13 10 00 cc sethi %hi(0x40033000), %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,
4000766c: 2d 10 00 cc sethi %hi(0x40033000), %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);
40007670: 92 12 63 a8 or %o1, 0x3a8, %o1
40007674: 7f ff f8 7f call 40005870 <rtems_fdisk_printf>
40007678: 2f 10 00 cd sethi %hi(0x40033400), %l7
4000767c: b4 10 20 00 clr %i2
for (device = 0; device < fd->device_count; device++)
40007680: 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,
40007684: ac 15 a3 e0 or %l6, 0x3e0, %l6
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
40007688: 10 80 00 7b b 40007874 <rtems_fdisk_ioctl+0x10a8>
4000768c: ae 15 e0 10 or %l7, 0x10, %l7
for (device = 0; device < fd->device_count; device++)
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
40007690: 90 10 00 1d mov %i5, %o0
40007694: 13 10 00 cc sethi %hi(0x40033000), %o1
40007698: 7f ff f8 76 call 40005870 <rtems_fdisk_printf>
4000769c: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 400333b8 <Callbacks.6428+0xba0>
rtems_fdisk_printf (fd, " Segment count\t%ld",
400076a0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
400076a4: 90 10 00 1d mov %i5, %o0
400076a8: 82 00 40 1a add %g1, %i2, %g1
400076ac: d4 00 60 04 ld [ %g1 + 4 ], %o2
400076b0: 13 10 00 cc sethi %hi(0x40033000), %o1
400076b4: a0 10 20 00 clr %l0
400076b8: 92 12 63 c8 or %o1, 0x3c8, %o1
400076bc: 7f ff f8 6d call 40005870 <rtems_fdisk_printf>
400076c0: b0 10 20 00 clr %i0
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
400076c4: 10 80 00 65 b 40007858 <rtems_fdisk_ioctl+0x108c>
400076c8: 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);
400076cc: 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];
400076d0: 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);
400076d4: 94 07 bf f8 add %fp, -8, %o2
400076d8: 92 10 00 1c mov %i4, %o1
400076dc: 7f ff f7 f9 call 400056c0 <rtems_fdisk_queue_status>
400076e0: 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;
400076e4: 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;
400076e8: 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;
400076ec: 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++)
400076f0: 10 80 00 35 b 400077c4 <rtems_fdisk_ioctl+0xff8>
400076f4: 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)
400076f8: 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]))
400076fc: 84 03 c0 02 add %o7, %g2, %g2
40007700: 90 10 00 02 mov %g2, %o0
40007704: 7f ff f8 17 call 40005760 <rtems_fdisk_page_desc_erased>
40007708: c4 27 bf d0 st %g2, [ %fp + -48 ]
4000770c: 80 8a 20 ff btst 0xff, %o0
40007710: 02 80 00 04 be 40007720 <rtems_fdisk_ioctl+0xf54>
40007714: c4 07 bf d0 ld [ %fp + -48 ], %g2
erased++;
40007718: 10 80 00 0c b 40007748 <rtems_fdisk_ioctl+0xf7c>
4000771c: 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;
40007720: 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],
40007724: 80 88 a0 01 btst 1, %g2
40007728: 32 80 00 09 bne,a 4000774c <rtems_fdisk_ioctl+0xf80> <== NEVER TAKEN
4000772c: 84 10 20 00 clr %g2 <== NOT EXECUTED
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
40007730: 80 88 a0 02 btst 2, %g2
40007734: 32 80 00 04 bne,a 40007744 <rtems_fdisk_ioctl+0xf78>
40007738: a8 05 20 01 inc %l4
RTEMS_FDISK_PAGE_USED))
used++;
4000773c: 10 80 00 03 b 40007748 <rtems_fdisk_ioctl+0xf7c>
40007740: a6 04 e0 01 inc %l3
else
{
active++;
is_active = true;
40007744: a2 10 20 01 mov 1, %l1
}
}
for (block = 0; block < fd->block_count; block++)
40007748: 84 10 20 00 clr %g2
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
4000774c: 10 80 00 19 b 400077b0 <rtems_fdisk_ioctl+0xfe4>
40007750: 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)
40007754: 9f 28 a0 03 sll %g2, 3, %o7
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
40007758: 96 03 00 0f add %o4, %o7, %o3
4000775c: de 03 00 0f ld [ %o4 + %o7 ], %o7
40007760: 80 a3 c0 1c cmp %o7, %i4
40007764: 32 80 00 13 bne,a 400077b0 <rtems_fdisk_ioctl+0xfe4>
40007768: 84 00 a0 01 inc %g2
4000776c: de 02 e0 04 ld [ %o3 + 4 ], %o7
40007770: 80 a3 c0 15 cmp %o7, %l5
40007774: 32 80 00 0f bne,a 400077b0 <rtems_fdisk_ioctl+0xfe4>
40007778: 84 00 a0 01 inc %g2
(fd->blocks[block].page == page) && !is_active)
4000777c: 80 a3 60 00 cmp %o5, 0
40007780: 32 80 00 0c bne,a 400077b0 <rtems_fdisk_ioctl+0xfe4> <== ALWAYS TAKEN
40007784: 84 00 a0 01 inc %g2
rtems_fdisk_printf (fd,
40007788: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED
4000778c: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
40007790: da 27 bf c4 st %o5, [ %fp + -60 ] <== NOT EXECUTED
40007794: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007798: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000779c: 7f ff f8 35 call 40005870 <rtems_fdisk_printf> <== NOT EXECUTED
400077a0: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
400077a4: da 07 bf c4 ld [ %fp + -60 ], %o5 <== NOT EXECUTED
400077a8: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
400077ac: 84 00 a0 01 inc %g2 <== NOT EXECUTED
400077b0: de 07 60 1c ld [ %i5 + 0x1c ], %o7
400077b4: 80 a0 80 0f cmp %g2, %o7
400077b8: 2a bf ff e7 bcs,a 40007754 <rtems_fdisk_ioctl+0xf88>
400077bc: 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++)
400077c0: aa 05 60 01 inc %l5
400077c4: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
400077c8: 80 a5 40 0c cmp %l5, %o4
400077cc: 2a bf ff cb bcs,a 400076f8 <rtems_fdisk_ioctl+0xf2c>
400077d0: de 07 20 10 ld [ %i4 + 0x10 ], %o7
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400077d4: de 07 60 1c ld [ %i5 + 0x1c ], %o7
400077d8: 82 10 20 00 clr %g1
400077dc: 10 80 00 08 b 400077fc <rtems_fdisk_ioctl+0x1030>
400077e0: 84 10 20 00 clr %g2
{
if (fd->blocks[block].segment == sc)
400077e4: 9b 28 60 03 sll %g1, 3, %o5
400077e8: da 02 c0 0d ld [ %o3 + %o5 ], %o5
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400077ec: 82 00 60 01 inc %g1
{
if (fd->blocks[block].segment == sc)
count++;
400077f0: 9a 1b 40 1c xor %o5, %i4, %o5
400077f4: 80 a0 00 0d cmp %g0, %o5
400077f8: 84 60 bf ff subx %g2, -1, %g2
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400077fc: 80 a0 40 0f cmp %g1, %o7
40007800: 32 bf ff f9 bne,a 400077e4 <rtems_fdisk_ioctl+0x1018>
40007804: 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),
40007808: 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 +
4000780c: 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" \
40007810: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40007814: e8 23 a0 5c st %l4, [ %sp + 0x5c ]
40007818: e6 23 a0 64 st %l3, [ %sp + 0x64 ]
4000781c: 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)
40007820: c6 07 20 24 ld [ %i4 + 0x24 ], %g3
40007824: 82 03 40 01 add %o5, %g1, %g1
40007828: 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" \
4000782c: 82 23 00 01 sub %o4, %g1, %g1
40007830: 94 10 00 18 mov %i0, %o2
40007834: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
40007838: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
4000783c: 90 10 00 1d mov %i5, %o0
40007840: 92 10 00 17 mov %l7, %o1
40007844: 96 07 bf f8 add %fp, -8, %o3
40007848: 7f ff f8 0a call 40005870 <rtems_fdisk_printf>
4000784c: b0 06 20 01 inc %i0
40007850: 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++)
40007854: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40007858: 84 00 40 1a add %g1, %i2, %g2
4000785c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40007860: 80 a6 00 02 cmp %i0, %g2
40007864: 2a bf ff 9a bcs,a 400076cc <rtems_fdisk_ioctl+0xf00>
40007868: 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++)
4000786c: b2 06 60 01 inc %i1
40007870: b4 06 a0 0c add %i2, 0xc, %i2
40007874: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40007878: 80 a6 40 01 cmp %i1, %g1
4000787c: 0a bf ff 85 bcs 40007690 <rtems_fdisk_ioctl+0xec4>
40007880: 94 10 00 19 mov %i1, %o2
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
40007884: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
40007888: 90 10 00 1d mov %i5, %o0
4000788c: 13 10 00 cd sethi %hi(0x40033400), %o1
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40007890: 33 10 00 cd sethi %hi(0x40033400), %i1
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
40007894: 92 12 60 50 or %o1, 0x50, %o1
40007898: 7f ff f7 f6 call 40005870 <rtems_fdisk_printf>
4000789c: b4 10 20 00 clr %i2
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
400078a0: 10 80 00 0a b 400078c8 <rtems_fdisk_ioctl+0x10fc>
400078a4: b2 16 60 60 or %i1, 0x60, %i1
400078a8: d8 07 20 0c ld [ %i4 + 0xc ], %o4
400078ac: da 07 20 20 ld [ %i4 + 0x20 ], %o5
400078b0: 94 10 00 1a mov %i2, %o2
400078b4: 90 10 00 1d mov %i5, %o0
400078b8: 7f ff f7 ee call 40005870 <rtems_fdisk_printf>
400078bc: 92 10 00 19 mov %i1, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
400078c0: f8 07 00 00 ld [ %i4 ], %i4
count++;
400078c4: 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)
400078c8: 80 a7 20 00 cmp %i4, 0
400078cc: 32 bf ff f7 bne,a 400078a8 <rtems_fdisk_ioctl+0x10dc>
400078d0: 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;
400078d4: 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]);
400078d8: 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;
400078dc: 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;
400078e0: 10 80 00 05 b 400078f4 <rtems_fdisk_ioctl+0x1128>
400078e4: c0 20 80 00 clr [ %g2 ]
default:
rtems_blkdev_ioctl (dd, req, argp);
400078e8: 92 10 00 19 mov %i1, %o1
400078ec: 40 00 3b 00 call 400164ec <rtems_blkdev_ioctl>
400078f0: 94 10 00 1a mov %i2, %o2
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
400078f4: 03 10 01 20 sethi %hi(0x40048000), %g1
400078f8: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 400481c0 <rtems_flashdisks>
400078fc: b6 00 40 1b add %g1, %i3, %i3
40007900: 40 00 16 57 call 4000d25c <rtems_semaphore_release>
40007904: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40007908: 80 a2 20 00 cmp %o0, 0
4000790c: 02 80 00 06 be 40007924 <rtems_fdisk_ioctl+0x1158> <== ALWAYS TAKEN
40007910: 01 00 00 00 nop
errno = EIO;
40007914: 40 00 66 2a call 400211bc <__errno> <== NOT EXECUTED
40007918: 01 00 00 00 nop <== NOT EXECUTED
4000791c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40007920: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
40007924: 40 00 66 26 call 400211bc <__errno>
40007928: 01 00 00 00 nop
4000792c: c2 02 00 00 ld [ %o0 ], %g1
40007930: 80 a0 00 01 cmp %g0, %g1
40007934: b0 60 20 00 subx %g0, 0, %i0
40007938: 81 c7 e0 08 ret
4000793c: 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)
40007940: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40007944: a2 04 60 01 inc %l1
40007948: 10 bf fc 85 b 40006b5c <rtems_fdisk_ioctl+0x390>
4000794c: 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++)
40007950: 10 bf fc 89 b 40006b74 <rtems_fdisk_ioctl+0x3a8> <== NOT EXECUTED
40007954: a4 04 a0 01 inc %l2 <== NOT EXECUTED
40005ae4 <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)
{
40005ae4: 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",
40005ae8: 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)
{
40005aec: ba 10 00 18 mov %i0, %i5
40005af0: 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",
40005af4: d4 06 60 08 ld [ %i1 + 8 ], %o2
40005af8: d6 06 60 0c ld [ %i1 + 0xc ], %o3
40005afc: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
40005b00: da 06 60 1c ld [ %i1 + 0x1c ], %o5
40005b04: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
40005b08: 80 a0 60 00 cmp %g1, 0
40005b0c: 02 80 00 05 be 40005b20 <rtems_fdisk_queue_segment+0x3c> <== ALWAYS TAKEN
40005b10: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
40005b14: 05 10 00 ca sethi %hi(0x40032800), %g2 <== NOT EXECUTED
40005b18: 10 80 00 04 b 40005b28 <rtems_fdisk_queue_segment+0x44> <== NOT EXECUTED
40005b1c: 84 10 a1 e0 or %g2, 0x1e0, %g2 ! 400329e0 <Callbacks.6428+0x1c8><== NOT EXECUTED
40005b20: 05 10 00 ca sethi %hi(0x40032800), %g2
40005b24: 84 10 a1 e8 or %g2, 0x1e8, %g2 ! 400329e8 <Callbacks.6428+0x1d0>
40005b28: c2 06 80 00 ld [ %i2 ], %g1
40005b2c: 80 a0 60 00 cmp %g1, 0
40005b30: 02 80 00 04 be 40005b40 <rtems_fdisk_queue_segment+0x5c>
40005b34: 03 10 00 ca sethi %hi(0x40032800), %g1
40005b38: 10 80 00 04 b 40005b48 <rtems_fdisk_queue_segment+0x64>
40005b3c: 82 10 61 f0 or %g1, 0x1f0, %g1 ! 400329f0 <Callbacks.6428+0x1d8>
40005b40: 03 10 00 ca sethi %hi(0x40032800), %g1
40005b44: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 400329f8 <Callbacks.6428+0x1e0>
40005b48: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
40005b4c: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
40005b50: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40005b54: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
40005b58: 90 10 00 1d mov %i5, %o0
40005b5c: 13 10 00 ca sethi %hi(0x40032800), %o1
40005b60: 7f ff ff 24 call 400057f0 <rtems_fdisk_info>
40005b64: 92 12 62 00 or %o1, 0x200, %o1 ! 40032a00 <Callbacks.6428+0x1e8>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
40005b68: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
40005b6c: 80 a0 60 00 cmp %g1, 0
40005b70: 02 80 00 09 be 40005b94 <rtems_fdisk_queue_segment+0xb0> <== ALWAYS TAKEN
40005b74: 92 10 00 1a mov %i2, %o1
{
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
40005b78: b0 07 60 58 add %i5, 0x58, %i0 <== NOT EXECUTED
40005b7c: 7f ff fe c6 call 40005694 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
40005b80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005b84: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40005b88: 12 80 00 32 bne 40005c50 <rtems_fdisk_queue_segment+0x16c><== NOT EXECUTED
40005b8c: 01 00 00 00 nop <== NOT EXECUTED
40005b90: 30 80 00 2e b,a 40005c48 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
40005b94: b8 07 60 34 add %i5, 0x34, %i4
40005b98: 7f ff fe 84 call 400055a8 <rtems_fdisk_segment_queue_remove>
40005b9c: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
40005ba0: 92 10 00 1a mov %i2, %o1
40005ba4: b0 07 60 40 add %i5, 0x40, %i0
40005ba8: 7f ff fe 80 call 400055a8 <rtems_fdisk_segment_queue_remove>
40005bac: 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)
40005bb0: 7f ff fe f6 call 40005788 <rtems_fdisk_seg_pages_available>
40005bb4: 90 10 00 1a mov %i2, %o0
40005bb8: b6 92 20 00 orcc %o0, 0, %i3
40005bbc: 32 80 00 1d bne,a 40005c30 <rtems_fdisk_queue_segment+0x14c>
40005bc0: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
{
if (sc->pages_active)
40005bc4: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
40005bc8: 80 a0 60 00 cmp %g1, 0
40005bcc: 22 80 00 0d be,a 40005c00 <rtems_fdisk_queue_segment+0x11c><== NEVER TAKEN
40005bd0: 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)
40005bd4: 10 80 00 07 b 40005bf0 <rtems_fdisk_queue_segment+0x10c>
40005bd8: f2 07 60 40 ld [ %i5 + 0x40 ], %i1
{
if (sc->pages_used > seg->pages_used)
40005bdc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40005be0: 80 a0 80 01 cmp %g2, %g1
40005be4: 18 80 00 17 bgu 40005c40 <rtems_fdisk_queue_segment+0x15c>
40005be8: 01 00 00 00 nop
break;
seg = seg->next;
40005bec: 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)
40005bf0: 80 a6 60 00 cmp %i1, 0
40005bf4: 32 bf ff fa bne,a 40005bdc <rtems_fdisk_queue_segment+0xf8>
40005bf8: c4 06 a0 20 ld [ %i2 + 0x20 ], %g2
40005bfc: 30 80 00 13 b,a 40005c48 <rtems_fdisk_queue_segment+0x164>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
40005c00: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40005c04: 12 80 00 11 bne 40005c48 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
40005c08: 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);
40005c0c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40005c10: 7f ff ff 75 call 400059e4 <rtems_fdisk_erase_segment> <== NOT EXECUTED
40005c14: 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))
40005c18: 7f ff fe dc call 40005788 <rtems_fdisk_seg_pages_available>
40005c1c: 90 10 00 19 mov %i1, %o0
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
40005c20: 80 a6 c0 08 cmp %i3, %o0
40005c24: 0a 80 00 07 bcs 40005c40 <rtems_fdisk_queue_segment+0x15c>
40005c28: b0 10 00 1c mov %i4, %i0
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
40005c2c: 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)
40005c30: 80 a6 60 00 cmp %i1, 0
40005c34: 12 bf ff f9 bne 40005c18 <rtems_fdisk_queue_segment+0x134>
40005c38: b0 10 00 1c mov %i4, %i0
40005c3c: 30 80 00 03 b,a 40005c48 <rtems_fdisk_queue_segment+0x164>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
40005c40: 7f ff fe 77 call 4000561c <rtems_fdisk_segment_queue_insert_before>
40005c44: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
40005c48: 7f ff fe 46 call 40005560 <rtems_fdisk_segment_queue_push_tail>
40005c4c: 93 e8 00 1a restore %g0, %i2, %o1
40005c50: 81 c7 e0 08 ret <== NOT EXECUTED
40005c54: 81 e8 00 00 restore <== NOT EXECUTED
40005e40 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
40005e40: 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));
40005e44: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
40005e48: 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;
40005e4c: c0 26 20 38 clr [ %i0 + 0x38 ]
40005e50: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
40005e54: 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;
40005e58: c0 26 20 44 clr [ %i0 + 0x44 ]
40005e5c: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
40005e60: 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;
40005e64: c0 26 20 50 clr [ %i0 + 0x50 ]
40005e68: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
40005e6c: 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;
40005e70: c0 26 20 5c clr [ %i0 + 0x5c ]
40005e74: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
40005e78: 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));
40005e7c: 92 10 20 00 clr %o1
40005e80: 95 2a a0 03 sll %o2, 3, %o2
40005e84: 40 00 71 a9 call 40022528 <memset>
40005e88: 27 10 00 ca sethi %hi(0x40032800), %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: " \
40005e8c: 29 10 00 ca sethi %hi(0x40032800), %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,
40005e90: 2b 10 00 ca sethi %hi(0x40032800), %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40005e94: 2d 10 00 ca sethi %hi(0x40032800), %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",
40005e98: 2f 10 00 ca sethi %hi(0x40032800), %l7
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
40005e9c: 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;
40005ea0: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
40005ea4: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
40005ea8: a2 10 20 00 clr %l1
40005eac: 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);
40005eb0: a6 14 e2 b0 or %l3, 0x2b0, %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: " \
40005eb4: a8 15 23 98 or %l4, 0x398, %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,
40005eb8: aa 15 63 68 or %l5, 0x368, %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40005ebc: ac 15 a3 20 or %l6, 0x320, %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++)
40005ec0: 10 80 00 b3 b 4000618c <rtems_fdisk_recover_block_mappings+0x34c>
40005ec4: ae 15 e3 40 or %l7, 0x340, %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);
40005ec8: 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];
40005ecc: b8 07 00 12 add %i4, %l2, %i4
const rtems_fdisk_segment_desc* sd = sc->descriptor;
40005ed0: 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);
40005ed4: 96 10 00 10 mov %l0, %o3
40005ed8: 92 10 00 13 mov %l3, %o1
40005edc: 7f ff fe 45 call 400057f0 <rtems_fdisk_info>
40005ee0: 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;
40005ee4: 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);
40005ee8: 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;
40005eec: 7f ff f1 e4 call 4000267c <.udiv>
40005ef0: 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;
40005ef4: 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;
40005ef8: 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);
40005efc: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
40005f00: 7f ff f1 df call 4000267c <.udiv>
40005f04: 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)
40005f08: 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;
40005f0c: 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;
40005f10: 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);
40005f14: 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)
40005f18: 80 a2 00 01 cmp %o0, %g1
40005f1c: 08 80 00 03 bleu 40005f28 <rtems_fdisk_recover_block_mappings+0xe8>
40005f20: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
fd->starvation_threshold = sc->pages;
40005f24: d0 27 60 24 st %o0, [ %i5 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
40005f28: 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;
40005f2c: c0 27 20 1c clr [ %i4 + 0x1c ]
sc->pages_used = 0;
40005f30: c0 27 20 20 clr [ %i4 + 0x20 ]
sc->pages_bad = 0;
40005f34: c0 27 20 24 clr [ %i4 + 0x24 ]
sc->failed = false;
if (!sc->page_descriptors)
40005f38: 80 a0 60 00 cmp %g1, 0
40005f3c: 12 80 00 08 bne 40005f5c <rtems_fdisk_recover_block_mappings+0x11c><== NEVER TAKEN
40005f40: c0 27 20 28 clr [ %i4 + 0x28 ]
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
40005f44: 92 10 00 1a mov %i2, %o1
40005f48: 7f ff f1 93 call 40002594 <.umul>
40005f4c: 90 10 00 18 mov %i0, %o0
40005f50: 40 00 0b a4 call 40008de0 <malloc>
40005f54: 01 00 00 00 nop
40005f58: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
if (!sc->page_descriptors)
40005f5c: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
40005f60: 80 a6 e0 00 cmp %i3, 0
40005f64: 32 80 00 05 bne,a 40005f78 <rtems_fdisk_recover_block_mappings+0x138><== ALWAYS TAKEN
40005f68: 90 10 00 18 mov %i0, %o0
rtems_fdisk_abort ("no memory for page descriptors");
40005f6c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40005f70: 40 00 07 bb call 40007e5c <rtems_fdisk_abort.constprop.0> <== NOT EXECUTED
40005f74: 90 12 21 88 or %o0, 0x188, %o0 ! 40032988 <Callbacks.6428+0x170><== 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,
40005f78: 7f ff f1 87 call 40002594 <.umul>
40005f7c: 92 10 00 1a mov %i2, %o1
40005f80: 92 10 00 1c mov %i4, %o1
40005f84: 98 10 00 08 mov %o0, %o4
40005f88: 94 10 20 00 clr %o2
40005f8c: 90 10 00 1d mov %i5, %o0
40005f90: 7f ff ff 32 call 40005c58 <rtems_fdisk_seg_read>
40005f94: 96 10 00 1b mov %i3, %o3
sc->pages_desc * fd->block_size);
if (ret)
40005f98: b0 92 20 00 orcc %o0, 0, %i0
40005f9c: 22 80 00 6a be,a 40006144 <rtems_fdisk_recover_block_mappings+0x304><== ALWAYS TAKEN
40005fa0: b4 10 20 00 clr %i2
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
40005fa4: 40 00 76 4b call 400238d0 <strerror> <== NOT EXECUTED
40005fa8: 01 00 00 00 nop <== NOT EXECUTED
40005fac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005fb0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40005fb4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40005fb8: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40005fbc: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40005fc0: 7f ff fe 6c call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40005fc4: 90 12 22 d8 or %o0, 0x2d8, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
40005fc8: 81 c7 e0 08 ret <== NOT EXECUTED
40005fcc: 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))
40005fd0: 7f ff fd e4 call 40005760 <rtems_fdisk_page_desc_erased>
40005fd4: 90 10 00 1b mov %i3, %o0
40005fd8: 80 8a 20 ff btst 0xff, %o0
40005fdc: 22 80 00 2b be,a 40006088 <rtems_fdisk_recover_block_mappings+0x248><== NEVER TAKEN
40005fe0: 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);
40005fe4: 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,
40005fe8: 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,
40005fec: 92 10 00 18 mov %i0, %o1
40005ff0: 7f ff f1 69 call 40002594 <.umul>
40005ff4: 90 06 80 08 add %i2, %o0, %o0
40005ff8: 92 10 00 1c mov %i4, %o1
40005ffc: 94 10 00 08 mov %o0, %o2
40006000: 96 10 00 18 mov %i0, %o3
40006004: 7f ff ff 37 call 40005ce0 <rtems_fdisk_seg_blank_check>
40006008: 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)
4000600c: 80 a2 20 00 cmp %o0, 0
40006010: 32 80 00 06 bne,a 40006028 <rtems_fdisk_recover_block_mappings+0x1e8><== NEVER TAKEN
40006014: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
40006018: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
4000601c: 82 00 60 01 inc %g1
40006020: 10 80 00 47 b 4000613c <rtems_fdisk_recover_block_mappings+0x2fc>
40006024: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40006028: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000602c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40006030: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
40006034: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
40006038: 7f ff fe 2e call 400058f0 <rtems_fdisk_warning> <== NOT EXECUTED
4000603c: 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;
40006040: 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,
40006044: 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;
40006048: 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,
4000604c: 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;
40006050: 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,
40006054: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40006058: 7f ff ff 69 call 40005dfc <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
4000605c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
page, pd);
if (ret)
40006060: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006064: 22 80 00 0d be,a 40006098 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
40006068: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
4000606c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
40006070: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006074: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40006078: 7f ff fe 3e call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
4000607c: 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++;
40006080: 10 80 00 06 b 40006098 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
40006084: 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))
40006088: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
4000608c: 12 80 00 06 bne 400060a4 <rtems_fdisk_recover_block_mappings+0x264><== NOT EXECUTED
40006090: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
{
sc->pages_used++;
40006094: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
40006098: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000609c: 10 80 00 28 b 4000613c <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
400060a0: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
400060a4: 32 80 00 24 bne,a 40006134 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
400060a8: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
400060ac: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
400060b0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
400060b4: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
400060b8: 2a 80 00 0a bcs,a 400060e0 <rtems_fdisk_recover_block_mappings+0x2a0><== NOT EXECUTED
400060bc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
400060c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400060c4: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
400060c8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
400060cc: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
400060d0: 7f ff fe 08 call 400058f0 <rtems_fdisk_warning> <== NOT EXECUTED
400060d4: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
400060d8: 10 80 00 17 b 40006134 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
400060dc: 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)
400060e0: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
400060e4: c4 00 40 0d ld [ %g1 + %o5 ], %g2 <== NOT EXECUTED
400060e8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
400060ec: 02 80 00 0c be 4000611c <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
400060f0: 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: " \
400060f4: d2 00 a0 08 ld [ %g2 + 8 ], %o1 <== NOT EXECUTED
400060f8: d4 00 a0 0c ld [ %g2 + 0xc ], %o2 <== NOT EXECUTED
400060fc: d6 00 e0 04 ld [ %g3 + 4 ], %o3 <== NOT EXECUTED
40006100: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
40006104: f4 23 a0 5c st %i2, [ %sp + 0x5c ] <== NOT EXECUTED
40006108: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
4000610c: 7f ff fe 19 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006110: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
40006114: 10 80 00 08 b 40006134 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
40006118: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
4000611c: f8 20 40 0d st %i4, [ %g1 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
40006120: 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;
40006124: f4 20 e0 04 st %i2, [ %g3 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
40006128: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000612c: 10 80 00 04 b 4000613c <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
40006130: c2 27 20 1c st %g1, [ %i4 + 0x1c ] <== NOT EXECUTED
}
}
else
sc->pages_bad++;
40006134: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006138: 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++)
4000613c: b4 06 a0 01 inc %i2
40006140: b6 06 e0 08 add %i3, 8, %i3
40006144: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40006148: 80 a6 80 01 cmp %i2, %g1
4000614c: 0a bf ff a1 bcs 40005fd0 <rtems_fdisk_recover_block_mappings+0x190>
40006150: 90 10 00 1d mov %i5, %o0
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
40006154: 92 10 00 1c mov %i4, %o1
40006158: 7f ff fe 63 call 40005ae4 <rtems_fdisk_queue_segment>
4000615c: a0 04 20 01 inc %l0
40006160: 10 80 00 03 b 4000616c <rtems_fdisk_recover_block_mappings+0x32c>
40006164: 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++)
40006168: a0 10 20 00 clr %l0
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
4000616c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40006170: 84 00 40 11 add %g1, %l1, %g2
40006174: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40006178: 80 a4 00 02 cmp %l0, %g2
4000617c: 2a bf ff 53 bcs,a 40005ec8 <rtems_fdisk_recover_block_mappings+0x88>
40006180: 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++)
40006184: b2 06 60 01 inc %i1
40006188: a2 04 60 0c add %l1, 0xc, %l1
4000618c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40006190: 80 a6 40 01 cmp %i1, %g1
40006194: 0a bf ff f5 bcs 40006168 <rtems_fdisk_recover_block_mappings+0x328>
40006198: a4 10 20 00 clr %l2
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
}
4000619c: 81 c7 e0 08 ret
400061a0: 91 e8 20 00 restore %g0, 0, %o0
40006210 <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)
{
40006210: 9d e3 bf 80 save %sp, -128, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
40006214: 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);
40006218: 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)
{
4000621c: aa 10 00 19 mov %i1, %l5
40006220: a2 10 00 1a mov %i2, %l1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
40006224: c0 27 bf fc clr [ %fp + -4 ]
for (spage = 0; spage < ssc->pages; spage++)
40006228: b8 10 20 00 clr %i4
4000622c: 10 80 00 c2 b 40006534 <rtems_fdisk_recycle_segment+0x324>
40006230: 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,
40006234: 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)
40006238: 80 a4 60 00 cmp %l1, 0
4000623c: 12 80 00 0b bne 40006268 <rtems_fdisk_recycle_segment+0x58>
40006240: a0 05 c0 16 add %l7, %l6, %l0
40006244: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
40006248: 80 a0 e0 00 cmp %g3, 0
4000624c: 22 80 00 08 be,a 4000626c <rtems_fdisk_recycle_segment+0x5c><== ALWAYS TAKEN
40006250: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
40006254: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40006258: 7f ff fd c6 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
4000625c: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40032bc8 <Callbacks.6428+0x3b0><== 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;
40006260: 10 80 00 ca b 40006588 <rtems_fdisk_recycle_segment+0x378><== NOT EXECUTED
40006264: 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;
40006268: 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) &&
4000626c: 80 88 e0 01 btst 1, %g3
40006270: 12 80 00 a8 bne 40006510 <rtems_fdisk_recycle_segment+0x300><== NEVER TAKEN
40006274: 80 88 e0 02 btst 2, %g3
40006278: 02 80 00 a6 be 40006510 <rtems_fdisk_recycle_segment+0x300>
4000627c: 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];
40006280: e6 04 60 10 ld [ %l1 + 0x10 ], %l3
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
40006284: 10 80 00 08 b 400062a4 <rtems_fdisk_recycle_segment+0x94>
40006288: e8 04 60 14 ld [ %l1 + 0x14 ], %l4
if (rtems_fdisk_page_desc_erased (pd))
4000628c: 7f ff fd 35 call 40005760 <rtems_fdisk_page_desc_erased>
40006290: 01 00 00 00 nop
40006294: 80 8a 20 ff btst 0xff, %o0
40006298: 12 80 00 08 bne 400062b8 <rtems_fdisk_recycle_segment+0xa8>
4000629c: 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++)
400062a0: ba 07 60 01 inc %i5
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
400062a4: 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++)
400062a8: 80 a7 40 14 cmp %i5, %l4
400062ac: 12 bf ff f8 bne 4000628c <rtems_fdisk_recycle_segment+0x7c><== ALWAYS TAKEN
400062b0: 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++;
400062b4: 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];
400062b8: b3 2f 60 03 sll %i5, 3, %i1
active++;
400062bc: 82 00 60 01 inc %g1
400062c0: c2 27 bf fc st %g1, [ %fp + -4 ]
if (dpage >= dsc->pages)
400062c4: 80 a7 40 14 cmp %i5, %l4
400062c8: 0a 80 00 14 bcs 40006318 <rtems_fdisk_recycle_segment+0x108><== ALWAYS TAKEN
400062cc: b4 04 c0 19 add %l3, %i1, %i2
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
400062d0: 7f ff fd 2e call 40005788 <rtems_fdisk_seg_pages_available><== NOT EXECUTED
400062d4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
400062d8: d2 04 60 08 ld [ %l1 + 8 ], %o1 <== NOT EXECUTED
400062dc: d4 04 60 0c ld [ %l1 + 0xc ], %o2 <== NOT EXECUTED
400062e0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400062e4: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
400062e8: 7f ff fd a2 call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
400062ec: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 40032bf0 <Callbacks.6428+0x3d8><== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
400062f0: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
400062f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400062f8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
400062fc: 7f ff fd fa call 40005ae4 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40006300: c6 24 60 28 st %g3, [ %l1 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
40006304: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
40006308: 7f ff fc 77 call 400054e4 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
4000630c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return EIO;
40006310: 10 80 00 9e b 40006588 <rtems_fdisk_recycle_segment+0x378><== NOT EXECUTED
40006314: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
40006318: da 04 60 08 ld [ %l1 + 8 ], %o5
4000631c: c6 04 60 0c ld [ %l1 + 0xc ], %g3
40006320: d4 05 60 08 ld [ %l5 + 8 ], %o2
40006324: d6 05 60 0c ld [ %l5 + 0xc ], %o3
40006328: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
4000632c: 98 10 00 1c mov %i4, %o4
40006330: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40006334: 90 10 00 18 mov %i0, %o0
40006338: 13 10 00 cb sethi %hi(0x40032c00), %o1
4000633c: 7f ff fd 2d call 400057f0 <rtems_fdisk_info>
40006340: 92 12 60 20 or %o1, 0x20, %o1 ! 40032c20 <Callbacks.6428+0x408>
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
40006344: c8 04 60 18 ld [ %l1 + 0x18 ], %g4
40006348: 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",
4000634c: da 04 60 08 ld [ %l1 + 8 ], %o5
40006350: de 04 60 0c ld [ %l1 + 0xc ], %o7
40006354: d4 05 60 08 ld [ %l5 + 8 ], %o2
40006358: 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,
4000635c: 88 07 40 04 add %i5, %g4, %g4
40006360: 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",
40006364: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
40006368: 98 10 00 03 mov %g3, %o4
4000636c: c8 27 bf f0 st %g4, [ %fp + -16 ]
40006370: de 23 a0 5c st %o7, [ %sp + 0x5c ]
40006374: c6 27 bf f4 st %g3, [ %fp + -12 ]
40006378: 90 10 00 18 mov %i0, %o0
4000637c: 13 10 00 cb sethi %hi(0x40032c00), %o1
40006380: 7f ff fd 3c call 40005870 <rtems_fdisk_printf>
40006384: 92 12 60 48 or %o1, 0x48, %o1 ! 40032c48 <Callbacks.6428+0x430>
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,
40006388: c6 07 bf f4 ld [ %fp + -12 ], %g3
page * fd->block_size, buffer, fd->block_size);
4000638c: 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,
40006390: 90 10 00 03 mov %g3, %o0
40006394: 7f ff f0 80 call 40002594 <.umul>
40006398: 92 10 00 14 mov %l4, %o1
4000639c: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
400063a0: 94 10 00 08 mov %o0, %o2
400063a4: 98 10 00 14 mov %l4, %o4
400063a8: 90 10 00 18 mov %i0, %o0
400063ac: 7f ff fe 2b call 40005c58 <rtems_fdisk_seg_read>
400063b0: 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)
400063b4: a8 92 20 00 orcc %o0, 0, %l4
400063b8: 12 80 00 0a bne 400063e0 <rtems_fdisk_recycle_segment+0x1d0><== NEVER TAKEN
400063bc: c8 07 bf f0 ld [ %fp + -16 ], %g4
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
400063c0: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
400063c4: 90 10 00 18 mov %i0, %o0
400063c8: 92 10 00 11 mov %l1, %o1
400063cc: 7f ff ff 76 call 400061a4 <rtems_fdisk_seg_write_page>
400063d0: 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)
400063d4: a8 92 20 00 orcc %o0, 0, %l4
400063d8: 22 80 00 0e be,a 40006410 <rtems_fdisk_recycle_segment+0x200><== ALWAYS TAKEN
400063dc: c6 05 c0 16 ld [ %l7 + %l6 ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
400063e0: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
400063e4: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
400063e8: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
400063ec: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
400063f0: 40 00 75 38 call 400238d0 <strerror> <== NOT EXECUTED
400063f4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
400063f8: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
400063fc: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
40006400: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
40006404: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006408: 10 80 00 17 b 40006464 <rtems_fdisk_recycle_segment+0x254><== NOT EXECUTED
4000640c: 90 12 20 78 or %o0, 0x78, %o0 ! 40032c78 <Callbacks.6428+0x460><== NOT EXECUTED
return ret;
}
*dpd = *spd;
ret = rtems_fdisk_seg_write_page_desc (fd,
40006410: 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;
40006414: c6 24 c0 19 st %g3, [ %l3 + %i1 ]
40006418: c6 04 20 04 ld [ %l0 + 4 ], %g3
ret = rtems_fdisk_seg_write_page_desc (fd,
4000641c: 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;
40006420: c6 26 a0 04 st %g3, [ %i2 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
40006424: 94 10 00 1d mov %i5, %o2
40006428: 7f ff fe 75 call 40005dfc <rtems_fdisk_seg_write_page_desc>
4000642c: 96 10 00 1a mov %i2, %o3
dsc,
dpage, dpd);
if (ret)
40006430: a8 92 20 00 orcc %o0, 0, %l4
40006434: 22 80 00 1a be,a 4000649c <rtems_fdisk_recycle_segment+0x28c><== ALWAYS TAKEN
40006438: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
4000643c: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
40006440: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
40006444: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
40006448: 40 00 75 22 call 400238d0 <strerror> <== NOT EXECUTED
4000644c: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
40006450: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
40006454: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
40006458: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
4000645c: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED
40006460: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40032cc0 <Callbacks.6428+0x4a8><== NOT EXECUTED
40006464: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40006468: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000646c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
40006470: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
40006474: 7f ff fd 3f call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
40006478: 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);
4000647c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006480: 7f ff fd 99 call 40005ae4 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40006484: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
40006488: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
4000648c: 7f ff fc 16 call 400054e4 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
40006490: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return ret;
40006494: 81 c7 e0 08 ret <== NOT EXECUTED
40006498: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
4000649c: 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++;
400064a0: 86 00 e0 01 inc %g3
400064a4: 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--;
400064a8: 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);
400064ac: 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--;
400064b0: 86 00 ff ff add %g3, -1, %g3
400064b4: c6 25 60 1c st %g3, [ %l5 + 0x1c ]
ssc->pages_used++;
400064b8: c6 05 60 20 ld [ %l5 + 0x20 ], %g3
400064bc: 86 00 e0 01 inc %g3
400064c0: c6 25 60 20 st %g3, [ %l5 + 0x20 ]
fd->blocks[spd->block].segment = dsc;
400064c4: c6 04 20 04 ld [ %l0 + 4 ], %g3
400064c8: 87 28 e0 03 sll %g3, 3, %g3
400064cc: 9e 01 00 03 add %g4, %g3, %o7
400064d0: e2 21 00 03 st %l1, [ %g4 + %g3 ]
fd->blocks[spd->block].page = dpage;
400064d4: fa 23 e0 04 st %i5, [ %o7 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
400064d8: 7f ff fd 83 call 40005ae4 <rtems_fdisk_queue_segment>
400064dc: 92 10 00 11 mov %l1, %o1
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
400064e0: 7f ff fc aa call 40005788 <rtems_fdisk_seg_pages_available>
400064e4: 90 10 00 11 mov %l1, %o0
if (dst_pages == 0)
400064e8: 80 a2 20 00 cmp %o0, 0
400064ec: 32 80 00 06 bne,a 40006504 <rtems_fdisk_recycle_segment+0x2f4>
400064f0: c6 06 c0 00 ld [ %i3 ], %g3
dsc = rtems_fdisk_seg_most_available (&fd->available);
400064f4: 7f ff fc ad call 400057a8 <rtems_fdisk_seg_most_available>
400064f8: d0 07 bf f8 ld [ %fp + -8 ], %o0
400064fc: a2 10 00 08 mov %o0, %l1
(*pages)--;
40006500: c6 06 c0 00 ld [ %i3 ], %g3
40006504: 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))
{
40006508: 10 80 00 0a b 40006530 <rtems_fdisk_recycle_segment+0x320>
4000650c: 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))
40006510: 7f ff fc 94 call 40005760 <rtems_fdisk_page_desc_erased>
40006514: 90 10 00 10 mov %l0, %o0
40006518: 80 8a 20 ff btst 0xff, %o0
4000651c: 22 80 00 05 be,a 40006530 <rtems_fdisk_recycle_segment+0x320><== ALWAYS TAKEN
40006520: a4 04 a0 01 inc %l2
{
--fd->erased_blocks;
40006524: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 <== NOT EXECUTED
40006528: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
4000652c: 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++)
40006530: b8 07 20 01 inc %i4
40006534: c6 05 60 14 ld [ %l5 + 0x14 ], %g3
40006538: 80 a7 00 03 cmp %i4, %g3
4000653c: 2a bf ff 3e bcs,a 40006234 <rtems_fdisk_recycle_segment+0x24>
40006540: 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",
40006544: d4 05 60 08 ld [ %l5 + 8 ], %o2
40006548: d6 05 60 0c ld [ %l5 + 0xc ], %o3
4000654c: da 07 bf fc ld [ %fp + -4 ], %o5
40006550: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
40006554: 90 10 00 18 mov %i0, %o0
40006558: 13 10 00 cb sethi %hi(0x40032c00), %o1
4000655c: 98 10 00 1b mov %i3, %o4
40006560: 7f ff fc c4 call 40005870 <rtems_fdisk_printf>
40006564: 92 12 61 08 or %o1, 0x108, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
40006568: d2 05 60 1c ld [ %l5 + 0x1c ], %o1
4000656c: 80 a2 60 00 cmp %o1, 0
40006570: 02 80 00 04 be 40006580 <rtems_fdisk_recycle_segment+0x370><== ALWAYS TAKEN
40006574: 11 10 00 cb sethi %hi(0x40032c00), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
40006578: 7f ff fc fe call 40005970 <rtems_fdisk_error> <== NOT EXECUTED
4000657c: 90 12 21 30 or %o0, 0x130, %o0 ! 40032d30 <Callbacks.6428+0x518><== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
40006580: 7f ff fd 19 call 400059e4 <rtems_fdisk_erase_segment>
40006584: 93 e8 00 15 restore %g0, %l5, %o1
return ret;
}
40006588: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
4000658c: 81 c7 e0 08 ret <== NOT EXECUTED
40006590: 81 e8 00 00 restore <== NOT EXECUTED
40005d64 <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)
{
40005d64: 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;
40005d68: e0 06 60 08 ld [ %i1 + 8 ], %l0
segment = sc->segment;
40005d6c: 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;
40005d70: 85 2c 20 04 sll %l0, 4, %g2
40005d74: 83 2c 20 02 sll %l0, 2, %g1
40005d78: 82 20 80 01 sub %g2, %g1, %g1
40005d7c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40005d80: 89 2f 60 06 sll %i5, 6, %g4
40005d84: 86 00 80 01 add %g2, %g1, %g3
40005d88: c4 00 80 01 ld [ %g2 + %g1 ], %g2
40005d8c: 83 2f 60 04 sll %i5, 4, %g1
40005d90: 82 21 00 01 sub %g4, %g1, %g1
40005d94: 82 00 80 01 add %g2, %g1, %g1
40005d98: 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;
40005d9c: c2 00 e0 08 ld [ %g3 + 8 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
40005da0: 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;
40005da4: e4 00 60 08 ld [ %g1 + 8 ], %l2
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
40005da8: 94 10 00 10 mov %l0, %o2
40005dac: 96 10 00 1d mov %i5, %o3
40005db0: 98 10 00 1a mov %i2, %o4
40005db4: 9a 10 00 1c mov %i4, %o5
40005db8: 13 10 00 ca sethi %hi(0x40032800), %o1
40005dbc: 7f ff fe ad call 40005870 <rtems_fdisk_printf>
40005dc0: 92 12 62 88 or %o1, 0x288, %o1 ! 40032a88 <Callbacks.6428+0x270>
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
40005dc4: c2 04 a0 04 ld [ %l2 + 4 ], %g1
40005dc8: 90 10 00 11 mov %l1, %o0
40005dcc: 92 10 00 10 mov %l0, %o1
40005dd0: 94 10 00 1d mov %i5, %o2
40005dd4: 96 10 00 1a mov %i2, %o3
40005dd8: 98 10 00 1b mov %i3, %o4
40005ddc: 9f c0 40 00 call %g1
40005de0: 9a 10 00 1c mov %i4, %o5
if (ret)
40005de4: b0 92 20 00 orcc %o0, 0, %i0
40005de8: 02 80 00 03 be 40005df4 <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
40005dec: 82 10 20 01 mov 1, %g1
sc->failed = true;
40005df0: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
40005df4: 81 c7 e0 08 ret
40005df8: 81 e8 00 00 restore
400061a4 <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)
{
400061a4: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
400061a8: c2 06 20 08 ld [ %i0 + 8 ], %g1
400061ac: 80 88 60 08 btst 8, %g1
400061b0: 32 80 00 0b bne,a 400061dc <rtems_fdisk_seg_write_page+0x38><== ALWAYS TAKEN
400061b4: 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;
400061b8: 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);
400061bc: 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;
400061c0: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
400061c4: 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;
400061c8: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
400061cc: 7f ff f0 f2 call 40002594 <.umul>
400061d0: 92 10 00 1c mov %i4, %o1
400061d4: 7f ff fe e4 call 40005d64 <rtems_fdisk_seg_write>
400061d8: 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,
400061dc: 90 10 00 1a mov %i2, %o0
400061e0: 7f ff f0 ed call 40002594 <.umul>
400061e4: 92 10 00 1d mov %i5, %o1
400061e8: 92 10 00 19 mov %i1, %o1
400061ec: 94 10 00 08 mov %o0, %o2
400061f0: 96 10 00 1d mov %i5, %o3
400061f4: 7f ff fe bb call 40005ce0 <rtems_fdisk_seg_blank_check>
400061f8: 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)
400061fc: 80 a2 20 00 cmp %o0, 0
40006200: 22 bf ff ef be,a 400061bc <rtems_fdisk_seg_write_page+0x18><== ALWAYS TAKEN
40006204: 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);
}
40006208: 81 c7 e0 08 ret <== NOT EXECUTED
4000620c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40005dfc <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)
{
40005dfc: 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))
40005e00: c2 06 20 08 ld [ %i0 + 8 ], %g1
40005e04: 80 88 60 08 btst 8, %g1
40005e08: 12 80 00 04 bne 40005e18 <rtems_fdisk_seg_write_page_desc+0x1c><== ALWAYS TAKEN
40005e0c: 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,
40005e10: 7f ff ff d5 call 40005d64 <rtems_fdisk_seg_write>
40005e14: 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,
40005e18: 90 10 00 18 mov %i0, %o0
40005e1c: 92 10 00 19 mov %i1, %o1
40005e20: 94 10 00 1a mov %i2, %o2
40005e24: 7f ff ff af call 40005ce0 <rtems_fdisk_seg_blank_check>
40005e28: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
40005e2c: 80 a2 20 00 cmp %o0, 0
40005e30: 02 bf ff f8 be 40005e10 <rtems_fdisk_seg_write_page_desc+0x14><== ALWAYS TAKEN
40005e34: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
page_desc, sizeof (rtems_fdisk_page_desc));
}
40005e38: 81 c7 e0 08 ret <== NOT EXECUTED
40005e3c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000561c <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)
4000561c: 80 a2 60 00 cmp %o1, 0
40005620: 02 80 00 10 be 40005660 <rtems_fdisk_segment_queue_insert_before+0x44><== NEVER TAKEN
40005624: 84 10 00 08 mov %o0, %g2
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
40005628: 10 80 00 0b b 40005654 <rtems_fdisk_segment_queue_insert_before+0x38>
4000562c: c2 02 00 00 ld [ %o0 ], %g1
{
if (item == it)
40005630: 32 80 00 08 bne,a 40005650 <rtems_fdisk_segment_queue_insert_before+0x34>
40005634: 84 10 00 01 mov %g1, %g2
{
sc->next = item;
40005638: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
queue->count++;
4000563c: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
*prev = sc;
40005640: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
40005644: 82 00 60 01 inc %g1
return;
40005648: 81 c3 e0 08 retl
4000564c: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = &it->next;
it = it->next;
40005650: 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)
40005654: 80 a0 60 00 cmp %g1, 0
40005658: 12 bf ff f6 bne 40005630 <rtems_fdisk_segment_queue_insert_before+0x14><== ALWAYS TAKEN
4000565c: 80 a2 40 01 cmp %o1, %g1
prev = &it->next;
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
40005660: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40005664: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40005668: 7f ff ff be call 40005560 <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
4000566c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40005520 <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)
{
40005520: 82 10 00 08 mov %o0, %g1
if (queue->head)
40005524: d0 02 00 00 ld [ %o0 ], %o0
40005528: 80 a2 20 00 cmp %o0, 0
4000552c: 02 80 00 0b be 40005558 <rtems_fdisk_segment_queue_pop_head+0x38><== NEVER TAKEN
40005530: 01 00 00 00 nop
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
40005534: c4 02 00 00 ld [ %o0 ], %g2
if (!queue->head)
40005538: 80 a0 a0 00 cmp %g2, 0
4000553c: 12 80 00 03 bne 40005548 <rtems_fdisk_segment_queue_pop_head+0x28>
40005540: c4 20 40 00 st %g2, [ %g1 ]
queue->tail = 0;
40005544: c0 20 60 04 clr [ %g1 + 4 ]
queue->count--;
40005548: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000554c: 84 00 bf ff add %g2, -1, %g2
40005550: c4 20 60 08 st %g2, [ %g1 + 8 ]
sc->next = 0;
40005554: c0 22 00 00 clr [ %o0 ]
return sc;
}
return 0;
}
40005558: 81 c3 e0 08 retl
400054e4 <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)
400054e4: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
400054e8: 02 80 00 0c be 40005518 <rtems_fdisk_segment_queue_push_head+0x34><== NOT EXECUTED
400054ec: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = queue->head;
400054f0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
400054f4: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
400054f8: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
400054fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005500: 12 80 00 03 bne 4000550c <rtems_fdisk_segment_queue_push_head+0x28><== NOT EXECUTED
40005504: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED
queue->tail = sc;
40005508: d2 22 20 04 st %o1, [ %o0 + 4 ] <== NOT EXECUTED
queue->count++;
4000550c: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
40005510: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005514: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
40005518: 81 c3 e0 08 retl <== NOT EXECUTED
40005560 <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)
40005560: 80 a2 60 00 cmp %o1, 0
40005564: 02 80 00 0f be 400055a0 <rtems_fdisk_segment_queue_push_tail+0x40><== NEVER TAKEN
40005568: 01 00 00 00 nop
{
sc->next = 0;
if (queue->head)
4000556c: c2 02 00 00 ld [ %o0 ], %g1
40005570: 80 a0 60 00 cmp %g1, 0
40005574: 02 80 00 06 be 4000558c <rtems_fdisk_segment_queue_push_tail+0x2c>
40005578: c0 22 40 00 clr [ %o1 ]
{
queue->tail->next = sc;
4000557c: c2 02 20 04 ld [ %o0 + 4 ], %g1
40005580: d2 20 40 00 st %o1, [ %g1 ]
queue->tail = sc;
40005584: 10 80 00 04 b 40005594 <rtems_fdisk_segment_queue_push_tail+0x34>
40005588: d2 22 20 04 st %o1, [ %o0 + 4 ]
}
else
{
queue->head = queue->tail = sc;
4000558c: d2 22 20 04 st %o1, [ %o0 + 4 ]
40005590: d2 22 00 00 st %o1, [ %o0 ]
}
queue->count++;
40005594: c2 02 20 08 ld [ %o0 + 8 ], %g1
40005598: 82 00 60 01 inc %g1
4000559c: c2 22 20 08 st %g1, [ %o0 + 8 ]
400055a0: 81 c3 e0 08 retl
400055a8 <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;
400055a8: c2 02 00 00 ld [ %o0 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
400055ac: 10 80 00 17 b 40005608 <rtems_fdisk_segment_queue_remove+0x60>
400055b0: 84 10 20 00 clr %g2
{
if (sc == it)
400055b4: 32 80 00 14 bne,a 40005604 <rtems_fdisk_segment_queue_remove+0x5c>
400055b8: 84 10 00 01 mov %g1, %g2
{
if (prev == 0)
400055bc: 80 a0 a0 00 cmp %g2, 0
400055c0: 12 80 00 07 bne 400055dc <rtems_fdisk_segment_queue_remove+0x34>
400055c4: c2 02 40 00 ld [ %o1 ], %g1
{
queue->head = sc->next;
if (queue->head == 0)
400055c8: 80 a0 60 00 cmp %g1, 0
400055cc: 12 80 00 09 bne 400055f0 <rtems_fdisk_segment_queue_remove+0x48>
400055d0: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
400055d4: 10 80 00 07 b 400055f0 <rtems_fdisk_segment_queue_remove+0x48>
400055d8: c0 22 20 04 clr [ %o0 + 4 ]
}
else
{
prev->next = sc->next;
400055dc: c2 20 80 00 st %g1, [ %g2 ]
if (queue->tail == sc)
400055e0: c2 02 20 04 ld [ %o0 + 4 ], %g1
400055e4: 80 a0 40 09 cmp %g1, %o1
400055e8: 22 80 00 02 be,a 400055f0 <rtems_fdisk_segment_queue_remove+0x48><== ALWAYS TAKEN
400055ec: c4 22 20 04 st %g2, [ %o0 + 4 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
400055f0: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
400055f4: c0 22 40 00 clr [ %o1 ]
queue->count--;
400055f8: 82 00 7f ff add %g1, -1, %g1
break;
400055fc: 81 c3 e0 08 retl
40005600: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = it;
it = it->next;
40005604: c2 00 40 00 ld [ %g1 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
40005608: 80 a0 60 00 cmp %g1, 0
4000560c: 12 bf ff ea bne 400055b4 <rtems_fdisk_segment_queue_remove+0xc>
40005610: 80 a2 40 01 cmp %o1, %g1
40005614: 81 c3 e0 08 retl
400058f0 <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, ...)
{
400058f0: 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);
400058f4: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
400058f8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
400058fc: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40005900: 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)
40005904: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
40005908: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000590c: 02 80 00 17 be 40005968 <rtems_fdisk_warning+0x78> <== NOT EXECUTED
40005910: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
40005914: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
40005918: 3b 10 00 de sethi %hi(0x40037800), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
4000591c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
40005920: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40005924: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED
40005928: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
4000592c: 40 00 70 73 call 40021af8 <fputs> <== NOT EXECUTED
40005930: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
40005934: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40005938: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4000593c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005940: 40 00 93 6a call 4002a6e8 <vfprintf> <== NOT EXECUTED
40005944: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
40005948: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
4000594c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
40005950: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40005954: 40 00 70 35 call 40021a28 <fputc> <== NOT EXECUTED
40005958: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
4000595c: c2 07 63 c8 ld [ %i5 + 0x3c8 ], %g1 <== NOT EXECUTED
40005960: 40 00 6f 1a call 400215c8 <fflush> <== NOT EXECUTED
40005964: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40005968: 81 c7 e0 08 ret <== NOT EXECUTED
4000596c: 81 e8 00 00 restore <== NOT EXECUTED
4000ca7c <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
4000ca7c: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
4000ca80: 7f ff ff 05 call 4000c694 <geteuid>
4000ca84: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
4000ca88: 91 2a 20 10 sll %o0, 0x10, %o0
4000ca8c: 91 32 20 10 srl %o0, 0x10, %o0
4000ca90: 80 a2 00 1a cmp %o0, %i2
4000ca94: 22 80 00 12 be,a 4000cadc <rtems_filesystem_check_access+0x60>
4000ca98: b1 2e 20 06 sll %i0, 6, %i0
4000ca9c: 80 a2 20 00 cmp %o0, 0
4000caa0: 12 80 00 04 bne 4000cab0 <rtems_filesystem_check_access+0x34>
4000caa4: 01 00 00 00 nop
perm_flags <<= RTEMS_FS_USR_SHIFT;
4000caa8: 10 80 00 0d b 4000cadc <rtems_filesystem_check_access+0x60>
4000caac: b1 2e 20 06 sll %i0, 6, %i0
} else {
gid_t task_gid = getegid();
4000cab0: 7f ff fe f5 call 4000c684 <getegid>
4000cab4: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
4000cab8: 91 2a 20 10 sll %o0, 0x10, %o0
4000cabc: 91 32 20 10 srl %o0, 0x10, %o0
4000cac0: 80 a2 00 1b cmp %o0, %i3
4000cac4: 22 80 00 06 be,a 4000cadc <rtems_filesystem_check_access+0x60>
4000cac8: b1 2e 20 03 sll %i0, 3, %i0
4000cacc: 80 a2 20 00 cmp %o0, 0
4000cad0: 32 80 00 04 bne,a 4000cae0 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
4000cad4: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
4000cad8: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
4000cadc: b0 2e 00 19 andn %i0, %i1, %i0
}
4000cae0: 80 a0 00 18 cmp %g0, %i0
4000cae4: b0 60 3f ff subx %g0, -1, %i0
4000cae8: 81 c7 e0 08 ret
4000caec: 81 e8 00 00 restore
400054a8 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
400054a8: 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 );
400054ac: 3b 10 00 7c sethi %hi(0x4001f000), %i5
400054b0: d0 07 62 fc ld [ %i5 + 0x2fc ], %o0 ! 4001f2fc <rtems_libio_semaphore>
400054b4: 92 10 20 00 clr %o1
400054b8: 40 00 0a cc call 40007fe8 <rtems_semaphore_obtain>
400054bc: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400054c0: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
400054c4: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
400054c8: d0 07 62 fc ld [ %i5 + 0x2fc ], %o0
next->previous = previous;
400054cc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
400054d0: 40 00 0b 0f call 4000810c <rtems_semaphore_release>
400054d4: 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);
400054d8: 40 00 00 4d call 4000560c <rtems_filesystem_global_location_release>
400054dc: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
400054e0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400054e4: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
400054e8: 9f c0 40 00 call %g1
400054ec: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
400054f0: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
400054f4: 80 a2 20 00 cmp %o0, 0
400054f8: 02 80 00 09 be 4000551c <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
400054fc: 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 );
40005500: 40 00 0b 30 call 400081c0 <rtems_event_system_send>
40005504: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
40005508: 80 a2 20 00 cmp %o0, 0
4000550c: 02 80 00 04 be 4000551c <rtems_filesystem_do_unmount+0x74><== ALWAYS TAKEN
40005510: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
40005514: 40 00 0c 92 call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
40005518: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
}
}
free(mt_entry);
4000551c: 7f ff fa c2 call 40004024 <free>
40005520: 81 e8 00 00 restore
4000cb28 <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
)
{
4000cb28: 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);
4000cb2c: 23 10 00 75 sethi %hi(0x4001d400), %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);
4000cb30: 3b 10 00 74 sethi %hi(0x4001d000), %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 =
4000cb34: 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);
4000cb38: a2 14 63 98 or %l1, 0x398, %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);
4000cb3c: ba 17 61 60 or %i5, 0x160, %i5
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
4000cb40: 40 00 00 99 call 4000cda4 <rtems_filesystem_eval_path_next_token>
4000cb44: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
4000cb48: 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) {
4000cb4c: 80 a7 20 00 cmp %i4, 0
4000cb50: 02 80 00 54 be 4000cca0 <rtems_filesystem_eval_path_generic+0x178>
4000cb54: f6 06 20 08 ld [ %i0 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
4000cb58: c2 06 80 00 ld [ %i2 ], %g1
4000cb5c: 90 10 00 18 mov %i0, %o0
4000cb60: 9f c0 40 00 call %g1
4000cb64: 92 10 00 19 mov %i1, %o1
4000cb68: 80 8a 20 ff btst 0xff, %o0
4000cb6c: 02 80 00 75 be 4000cd40 <rtems_filesystem_eval_path_generic+0x218>
4000cb70: 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] == '.';
4000cb74: 12 80 00 06 bne 4000cb8c <rtems_filesystem_eval_path_generic+0x64>
4000cb78: 82 10 20 00 clr %g1
4000cb7c: c2 4e c0 00 ldsb [ %i3 ], %g1
4000cb80: 82 18 60 2e xor %g1, 0x2e, %g1
4000cb84: 80 a0 00 01 cmp %g0, %g1
4000cb88: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
4000cb8c: 80 a0 60 00 cmp %g1, 0
4000cb90: 02 80 00 0f be 4000cbcc <rtems_filesystem_eval_path_generic+0xa4>
4000cb94: 80 a7 20 02 cmp %i4, 2
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000cb98: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000cb9c: 80 a0 60 00 cmp %g1, 0
4000cba0: 22 80 00 04 be,a 4000cbb0 <rtems_filesystem_eval_path_generic+0x88>
4000cba4: 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);
4000cba8: 10 80 00 40 b 4000cca8 <rtems_filesystem_eval_path_generic+0x180>
4000cbac: 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) {
4000cbb0: 80 88 61 00 btst 0x100, %g1
4000cbb4: 32 80 00 04 bne,a 4000cbc4 <rtems_filesystem_eval_path_generic+0x9c>
4000cbb8: 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);
4000cbbc: 10 80 00 3b b 4000cca8 <rtems_filesystem_eval_path_generic+0x180>
4000cbc0: 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);
4000cbc4: 10 80 00 5b b 4000cd30 <rtems_filesystem_eval_path_generic+0x208>
4000cbc8: 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] == '.';
4000cbcc: 12 80 00 0a bne 4000cbf4 <rtems_filesystem_eval_path_generic+0xcc>
4000cbd0: 82 10 20 00 clr %g1
4000cbd4: c4 4e c0 00 ldsb [ %i3 ], %g2
4000cbd8: 80 a0 a0 2e cmp %g2, 0x2e
4000cbdc: 12 80 00 07 bne 4000cbf8 <rtems_filesystem_eval_path_generic+0xd0>
4000cbe0: 80 a0 60 00 cmp %g1, 0
4000cbe4: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
4000cbe8: 82 18 60 2e xor %g1, 0x2e, %g1
4000cbec: 80 a0 00 01 cmp %g0, %g1
4000cbf0: 82 60 3f ff subx %g0, -1, %g1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
4000cbf4: 80 a0 60 00 cmp %g1, 0
4000cbf8: 22 80 00 36 be,a 4000ccd0 <rtems_filesystem_eval_path_generic+0x1a8>
4000cbfc: 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;
4000cc00: 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;
4000cc04: 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 );
4000cc08: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
4000cc0c: 80 a0 40 02 cmp %g1, %g2
4000cc10: 12 80 00 07 bne 4000cc2c <rtems_filesystem_eval_path_generic+0x104>
4000cc14: 90 10 20 00 clr %o0
4000cc18: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000cc1c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000cc20: 9f c0 40 00 call %g1
4000cc24: 90 10 00 10 mov %l0, %o0
4000cc28: 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)) {
4000cc2c: 80 8a 20 01 btst 1, %o0
4000cc30: 22 80 00 04 be,a 4000cc40 <rtems_filesystem_eval_path_generic+0x118>
4000cc34: 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);
4000cc38: 10 80 00 1c b 4000cca8 <rtems_filesystem_eval_path_generic+0x180>
4000cc3c: 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 );
4000cc40: 90 10 00 10 mov %l0, %o0
4000cc44: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000cc48: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
4000cc4c: 9f c0 80 00 call %g2
4000cc50: 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)) {
4000cc54: 80 8a 20 ff btst 0xff, %o0
4000cc58: 22 80 00 19 be,a 4000ccbc <rtems_filesystem_eval_path_generic+0x194>
4000cc5c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
4000cc60: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
4000cc64: c2 02 60 20 ld [ %o1 + 0x20 ], %g1
4000cc68: 80 a0 60 00 cmp %g1, 0
4000cc6c: 22 80 00 0f be,a 4000cca8 <rtems_filesystem_eval_path_generic+0x180><== NEVER TAKEN
4000cc70: 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;
4000cc74: c2 06 20 0c ld [ %i0 + 0xc ], %g1
ctx->path -= tokenlen;
4000cc78: c4 06 00 00 ld [ %i0 ], %g2
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
4000cc7c: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
4000cc80: 84 20 80 01 sub %g2, %g1, %g2
4000cc84: c4 26 00 00 st %g2, [ %i0 ]
ctx->pathlen += tokenlen;
4000cc88: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
4000cc8c: 90 10 00 18 mov %i0, %o0
4000cc90: 82 00 80 01 add %g2, %g1, %g1
4000cc94: 92 02 60 20 add %o1, 0x20, %o1
4000cc98: 7f ff e1 8d call 400052cc <rtems_filesystem_eval_path_restart>
4000cc9c: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000cca0: 81 c7 e0 08 ret
4000cca4: 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);
4000cca8: 90 10 00 18 mov %i0, %o0
4000ccac: 92 10 00 19 mov %i1, %o1
4000ccb0: 94 10 00 1d mov %i5, %o2
4000ccb4: 10 80 00 0b b 4000cce0 <rtems_filesystem_eval_path_generic+0x1b8>
4000ccb8: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
4000ccbc: 90 10 00 18 mov %i0, %o0
4000ccc0: 92 10 00 19 mov %i1, %o1
4000ccc4: 94 10 00 11 mov %l1, %o2
4000ccc8: 10 80 00 06 b 4000cce0 <rtems_filesystem_eval_path_generic+0x1b8>
4000cccc: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
4000ccd0: 90 10 00 18 mov %i0, %o0
4000ccd4: 92 10 00 19 mov %i1, %o1
4000ccd8: 94 10 00 1b mov %i3, %o2
4000ccdc: 96 10 00 1c mov %i4, %o3
4000cce0: 9f c0 40 00 call %g1
4000cce4: 01 00 00 00 nop
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000cce8: 80 a2 20 02 cmp %o0, 2
4000ccec: 12 80 00 18 bne 4000cd4c <rtems_filesystem_eval_path_generic+0x224>
4000ccf0: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000ccf4: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000ccf8: 80 a0 60 00 cmp %g1, 0
4000ccfc: 02 80 00 16 be 4000cd54 <rtems_filesystem_eval_path_generic+0x22c>
4000cd00: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
4000cd04: 40 00 00 16 call 4000cd5c <rtems_filesystem_eval_path_eat_delimiter>
4000cd08: 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
4000cd0c: 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 (
4000cd10: 80 88 60 80 btst 0x80, %g1
4000cd14: 02 80 00 06 be 4000cd2c <rtems_filesystem_eval_path_generic+0x204>
4000cd18: 90 10 00 18 mov %i0, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
4000cd1c: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000cd20: 80 a0 60 00 cmp %g1, 0
4000cd24: 02 80 00 0c be 4000cd54 <rtems_filesystem_eval_path_generic+0x22c>
4000cd28: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000cd2c: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
4000cd30: 7f ff e0 82 call 40004f38 <rtems_filesystem_eval_path_error>
4000cd34: 01 00 00 00 nop
4000cd38: 81 c7 e0 08 ret
4000cd3c: 81 e8 00 00 restore
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
4000cd40: 90 10 00 18 mov %i0, %o0
4000cd44: 10 bf ff fb b 4000cd30 <rtems_filesystem_eval_path_generic+0x208>
4000cd48: 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) {
4000cd4c: 02 bf ff 7d be 4000cb40 <rtems_filesystem_eval_path_generic+0x18>
4000cd50: 01 00 00 00 nop
4000cd54: 81 c7 e0 08 ret
4000cd58: 81 e8 00 00 restore
40005330 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
40005330: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
40005334: 80 a6 a0 00 cmp %i2, 0
40005338: 02 80 00 26 be 400053d0 <rtems_filesystem_eval_path_recursive+0xa0><== NEVER TAKEN
4000533c: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
40005340: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005344: 80 a0 60 1f cmp %g1, 0x1f
40005348: 34 80 00 23 bg,a 400053d4 <rtems_filesystem_eval_path_recursive+0xa4>
4000534c: b2 10 20 5c mov 0x5c, %i1
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
40005350: c2 4e 40 00 ldsb [ %i1 ], %g1
const char *saved_path = ctx->path;
40005354: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
40005358: 80 a0 60 5c cmp %g1, 0x5c
4000535c: 02 80 00 05 be 40005370 <rtems_filesystem_eval_path_recursive+0x40><== NEVER TAKEN
40005360: f8 06 20 04 ld [ %i0 + 4 ], %i4
40005364: 80 a0 60 2f cmp %g1, 0x2f
40005368: 32 80 00 06 bne,a 40005380 <rtems_filesystem_eval_path_recursive+0x50>
4000536c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
40005370: 90 10 00 1d mov %i5, %o0
40005374: 7f ff ff d6 call 400052cc <rtems_filesystem_eval_path_restart>
40005378: 92 07 60 30 add %i5, 0x30, %o1
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
4000537c: 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;
40005380: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
++ctx->recursionlevel;
40005384: 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;
40005388: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
4000538c: 10 80 00 06 b 400053a4 <rtems_filesystem_eval_path_recursive+0x74>
40005390: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40005394: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005398: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000539c: 9f c0 40 00 call %g1
400053a0: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
400053a4: c2 07 60 04 ld [ %i5 + 4 ], %g1
400053a8: 80 a0 60 00 cmp %g1, 0
400053ac: 32 bf ff fa bne,a 40005394 <rtems_filesystem_eval_path_recursive+0x64>
400053b0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
400053b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
400053b8: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
400053bc: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
400053c0: 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;
400053c4: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
400053c8: 81 c7 e0 08 ret
400053cc: 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);
400053d0: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
400053d4: 7f ff fe d9 call 40004f38 <rtems_filesystem_eval_path_error>
400053d8: 81 e8 00 00 restore
400051a8 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
400051a8: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
400051ac: 40 00 2f d5 call 40011100 <strlen>
400051b0: 90 10 00 19 mov %i1, %o0
400051b4: 10 80 00 09 b 400051d8 <rtems_filesystem_eval_path_start_with_parent+0x30>
400051b8: 94 10 00 08 mov %o0, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
400051bc: 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])) {
400051c0: 80 a0 a0 5c cmp %g2, 0x5c
400051c4: 02 80 00 28 be 40005264 <rtems_filesystem_eval_path_start_with_parent+0xbc><== NEVER TAKEN
400051c8: 80 a0 a0 2f cmp %g2, 0x2f
400051cc: 02 80 00 27 be 40005268 <rtems_filesystem_eval_path_start_with_parent+0xc0>
400051d0: 80 a2 20 00 cmp %o0, 0
return pathlen;
}
pathlen = i;
400051d4: 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) {
400051d8: 80 a2 a0 00 cmp %o2, 0
400051dc: 12 bf ff f8 bne 400051bc <rtems_filesystem_eval_path_start_with_parent+0x14>
400051e0: 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) {
400051e4: 80 a2 20 00 cmp %o0, 0
400051e8: 02 80 00 0a be 40005210 <rtems_filesystem_eval_path_start_with_parent+0x68>
400051ec: ba 10 00 19 mov %i1, %i5
400051f0: a0 10 00 08 mov %o0, %l0
if (parentpathlen == 0) {
parentpath = ".";
400051f4: 33 10 00 74 sethi %hi(0x4001d000), %i1
parentpathlen = 1;
400051f8: 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 = ".";
400051fc: 10 80 00 09 b 40005220 <rtems_filesystem_eval_path_start_with_parent+0x78>
40005200: 92 16 61 60 or %i1, 0x160, %o1
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
40005204: 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;
40005208: 10 80 00 06 b 40005220 <rtems_filesystem_eval_path_start_with_parent+0x78>
4000520c: 92 10 00 19 mov %i1, %o1
40005210: 92 10 00 19 mov %i1, %o1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
40005214: 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;
40005218: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
4000521c: 94 10 20 00 clr %o2
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
40005220: 03 10 00 79 sethi %hi(0x4001e400), %g1
40005224: da 00 63 c0 ld [ %g1 + 0x3c0 ], %o5 ! 4001e7c0 <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
40005228: 96 10 00 1c mov %i4, %o3
4000522c: 98 03 60 04 add %o5, 4, %o4
40005230: 7f ff ff 94 call 40005080 <eval_path_start>
40005234: 90 10 00 18 mov %i0, %o0
40005238: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
4000523c: 40 00 1c c9 call 4000c560 <rtems_filesystem_location_clone>
40005240: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
40005244: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
40005248: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
4000524c: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
40005250: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
40005254: 7f ff ff 71 call 40005018 <rtems_filesystem_eval_path_continue>
40005258: b0 06 20 18 add %i0, 0x18, %i0
4000525c: 81 c7 e0 08 ret
40005260: 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) {
40005264: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005268: 32 bf ff e7 bne,a 40005204 <rtems_filesystem_eval_path_start_with_parent+0x5c><== ALWAYS TAKEN
4000526c: 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;
40005270: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
40005274: 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;
40005278: 10 bf ff ea b 40005220 <rtems_filesystem_eval_path_start_with_parent+0x78><== NOT EXECUTED
4000527c: ba 10 20 00 clr %i5 <== NOT EXECUTED
4000c8e4 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000c8e4: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
4000c8e8: f0 27 bf f8 st %i0, [ %fp + -8 ]
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000c8ec: 80 a6 20 00 cmp %i0, 0
4000c8f0: 02 80 00 06 be 4000c908 <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
4000c8f4: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_iterate( find_handler, &fa );
4000c8f8: 11 10 00 31 sethi %hi(0x4000c400), %o0
4000c8fc: 92 07 bf f8 add %fp, -8, %o1
4000c900: 7f ff ff ce call 4000c838 <rtems_filesystem_iterate>
4000c904: 90 12 23 d4 or %o0, 0x3d4, %o0
}
return fa.mount_h;
}
4000c908: f0 07 bf fc ld [ %fp + -4 ], %i0
4000c90c: 81 c7 e0 08 ret
4000c910: 81 e8 00 00 restore
40003cf0 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40003cf0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40003cf4: 05 10 00 72 sethi %hi(0x4001c800), %g2
40003cf8: 82 10 a0 24 or %g2, 0x24, %g1 ! 4001c824 <rtems_filesystem_root_configuration>
40003cfc: d0 00 a0 24 ld [ %g2 + 0x24 ], %o0
40003d00: d2 00 60 04 ld [ %g1 + 4 ], %o1
40003d04: d4 00 60 08 ld [ %g1 + 8 ], %o2
40003d08: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40003d0c: 40 00 02 21 call 40004590 <mount>
40003d10: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40003d14: 80 a2 20 00 cmp %o0, 0
40003d18: 22 80 00 05 be,a 40003d2c <rtems_filesystem_initialize+0x3c><== ALWAYS TAKEN
40003d1c: 11 10 00 72 sethi %hi(0x4001c800), %o0
rtems_fatal_error_occurred( 0xABCD0002 );
40003d20: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
40003d24: 10 80 00 09 b 40003d48 <rtems_filesystem_initialize+0x58> <== NOT EXECUTED
40003d28: 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);
40003d2c: 92 10 21 ff mov 0x1ff, %o1
40003d30: 40 00 01 d0 call 40004470 <mkdir>
40003d34: 90 12 23 f0 or %o0, 0x3f0, %o0
if ( rv != 0 )
40003d38: 80 a2 20 00 cmp %o0, 0
40003d3c: 02 80 00 05 be 40003d50 <rtems_filesystem_initialize+0x60><== ALWAYS TAKEN
40003d40: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
rtems_fatal_error_occurred( 0xABCD0003 );
40003d44: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <LEON_REG+0x2bcd0003><== NOT EXECUTED
40003d48: 40 00 12 85 call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
40003d4c: 01 00 00 00 nop <== NOT EXECUTED
40003d50: 81 c7 e0 08 ret
40003d54: 81 e8 00 00 restore
4000c838 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
4000c838: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
4000c83c: 39 10 00 72 sethi %hi(0x4001c800), %i4
rtems_chain_node *node = NULL;
bool stop = false;
4000c840: ba 10 20 00 clr %i5
while ( table_entry->type && !stop ) {
4000c844: 10 80 00 06 b 4000c85c <rtems_filesystem_iterate+0x24>
4000c848: b8 17 20 38 or %i4, 0x38, %i4
stop = (*routine)( table_entry, routine_arg );
4000c84c: 92 10 00 19 mov %i1, %o1
4000c850: 9f c6 00 00 call %i0
4000c854: b8 07 20 08 add %i4, 8, %i4
4000c858: 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 ) {
4000c85c: c2 07 00 00 ld [ %i4 ], %g1
4000c860: 80 a0 60 00 cmp %g1, 0
4000c864: 02 80 00 08 be 4000c884 <rtems_filesystem_iterate+0x4c>
4000c868: 82 0f 60 ff and %i5, 0xff, %g1
4000c86c: 80 a0 60 00 cmp %g1, 0
4000c870: 02 bf ff f7 be 4000c84c <rtems_filesystem_iterate+0x14>
4000c874: 90 10 00 1c mov %i4, %o0
4000c878: b0 0f 60 ff and %i5, 0xff, %i0
4000c87c: 81 c7 e0 08 ret
4000c880: 81 e8 00 00 restore
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
4000c884: 80 a0 60 00 cmp %g1, 0
4000c888: 32 80 00 15 bne,a 4000c8dc <rtems_filesystem_iterate+0xa4>
4000c88c: b0 0f 60 ff and %i5, 0xff, %i0
rtems_libio_lock();
4000c890: 7f ff ff de call 4000c808 <rtems_libio_lock>
4000c894: 37 10 00 7a sethi %hi(0x4001e800), %i3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000c898: 03 10 00 7a sethi %hi(0x4001e800), %g1
4000c89c: f8 00 60 70 ld [ %g1 + 0x70 ], %i4 ! 4001e870 <filesystem_chain>
for (
4000c8a0: 10 80 00 06 b 4000c8b8 <rtems_filesystem_iterate+0x80>
4000c8a4: b6 16 e0 74 or %i3, 0x74, %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 );
4000c8a8: 9f c6 00 00 call %i0
4000c8ac: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000c8b0: f8 07 00 00 ld [ %i4 ], %i4
4000c8b4: ba 10 00 08 mov %o0, %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
4000c8b8: 80 a7 00 1b cmp %i4, %i3
4000c8bc: 12 80 00 05 bne 4000c8d0 <rtems_filesystem_iterate+0x98>
4000c8c0: 80 8f 60 ff btst 0xff, %i5
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
4000c8c4: 7f ff ff d8 call 4000c824 <rtems_libio_unlock>
4000c8c8: b0 0f 60 ff and %i5, 0xff, %i0
4000c8cc: 30 80 00 04 b,a 4000c8dc <rtems_filesystem_iterate+0xa4>
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
4000c8d0: 02 bf ff f6 be 4000c8a8 <rtems_filesystem_iterate+0x70> <== ALWAYS TAKEN
4000c8d4: 90 07 20 08 add %i4, 8, %o0
4000c8d8: 30 bf ff fb b,a 4000c8c4 <rtems_filesystem_iterate+0x8c> <== NOT EXECUTED
}
rtems_libio_unlock();
}
return stop;
}
4000c8dc: 81 c7 e0 08 ret
4000c8e0: 81 e8 00 00 restore
4000c560 <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000c560: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000c564: 90 10 00 18 mov %i0, %o0
4000c568: 7f ff e3 b4 call 40005438 <rtems_filesystem_location_copy>
4000c56c: 92 10 00 19 mov %i1, %o1
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000c570: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000c574: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000c578: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
4000c57c: 9f c0 40 00 call %g1
4000c580: b0 10 00 08 mov %o0, %i0
if ( rv != 0 ) {
4000c584: 80 a2 20 00 cmp %o0, 0
4000c588: 02 80 00 06 be 4000c5a0 <rtems_filesystem_location_clone+0x40><== ALWAYS TAKEN
4000c58c: 90 10 00 18 mov %i0, %o0
rtems_filesystem_location_remove_from_mt_entry( clone );
4000c590: 7f ff e3 e5 call 40005524 <rtems_filesystem_location_remove_from_mt_entry><== NOT EXECUTED
4000c594: 33 10 00 79 sethi %hi(0x4001e400), %i1 <== NOT EXECUTED
static inline rtems_filesystem_location_info_t *
rtems_filesystem_location_initialize_to_null(
rtems_filesystem_location_info_t *loc
)
{
return rtems_filesystem_location_copy(
4000c598: 7f ff e3 a8 call 40005438 <rtems_filesystem_location_copy><== NOT EXECUTED
4000c59c: 93 ee 63 f0 restore %i1, 0x3f0, %o1 <== NOT EXECUTED
4000c5a0: 81 c7 e0 08 ret
4000c5a4: 81 e8 00 00 restore
40005524 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
40005524: 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);
40005528: 7f ff f3 c8 call 40002448 <sparc_disable_interrupts>
4000552c: 01 00 00 00 nop
40005530: b8 10 00 08 mov %o0, %i4
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40005534: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
40005538: 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);
4000553c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
next->previous = previous;
40005540: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40005544: 7f ff ff a6 call 400053dc <rtems_filesystem_is_ready_for_unmount>
40005548: c4 20 40 00 st %g2, [ %g1 ]
4000554c: ba 10 00 08 mov %o0, %i5
rtems_filesystem_mt_entry_unlock(lock_context);
40005550: 7f ff f3 c2 call 40002458 <sparc_enable_interrupts>
40005554: 90 10 00 1c mov %i4, %o0
if (do_unmount) {
40005558: 80 8f 60 ff btst 0xff, %i5
4000555c: 02 80 00 05 be 40005570 <rtems_filesystem_location_remove_from_mt_entry+0x4c><== ALWAYS TAKEN
40005560: 01 00 00 00 nop
rtems_filesystem_do_unmount(loc->mt_entry);
40005564: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
40005568: 7f ff ff d0 call 400054a8 <rtems_filesystem_do_unmount> <== NOT EXECUTED
4000556c: 81 e8 00 00 restore <== NOT EXECUTED
40005570: 81 c7 e0 08 ret
40005574: 81 e8 00 00 restore
40005758 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
40005758: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
4000575c: 7f ff fb 06 call 40004374 <malloc>
40005760: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
40005764: ba 92 20 00 orcc %o0, 0, %i5
40005768: 02 80 00 0b be 40005794 <rtems_filesystem_location_transform_to_global+0x3c><== NEVER TAKEN
4000576c: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
40005770: 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;
40005774: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
40005778: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_copy(&global_loc->location, loc);
4000577c: 7f ff ff 2f call 40005438 <rtems_filesystem_location_copy>
40005780: 92 10 00 18 mov %i0, %o1
rtems_filesystem_location_remove_from_mt_entry(loc);
40005784: 7f ff ff 68 call 40005524 <rtems_filesystem_location_remove_from_mt_entry>
40005788: 90 10 00 18 mov %i0, %o0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
4000578c: 81 c7 e0 08 ret
40005790: 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);
40005794: 40 00 1b 85 call 4000c5a8 <rtems_filesystem_location_free><== NOT EXECUTED
40005798: 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 );
4000579c: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
400057a0: 7f ff ff bc call 40005690 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
400057a4: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
400057a8: 40 00 28 cf call 4000fae4 <__errno> <== NOT EXECUTED
400057ac: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
400057b0: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
400057b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
400057b8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
400057bc: 81 c7 e0 08 ret <== NOT EXECUTED
400057c0: 81 e8 00 00 restore <== NOT EXECUTED
40004598 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
40004598: 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 ) );
4000459c: 40 00 01 05 call 400049b0 <malloc>
400045a0: 90 10 20 08 mov 8, %o0
*key = new_key;
400045a4: 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 ) );
400045a8: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
400045ac: c0 22 00 00 clr [ %o0 ]
new_key->dtor = dtor;
400045b0: 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 );
400045b4: 92 10 00 1d mov %i5, %o1
400045b8: 90 10 20 00 clr %o0
400045bc: 94 10 00 19 mov %i1, %o2
400045c0: 40 00 11 87 call 40008bdc <rtems_task_variable_add>
400045c4: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
400045c8: 80 a2 20 00 cmp %o0, 0
400045cc: 02 80 00 04 be 400045dc <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
400045d0: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
400045d4: 7f ff ff 85 call 400043e8 <free> <== NOT EXECUTED
400045d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
400045dc: 81 c7 e0 08 ret
400045e0: 81 e8 00 00 restore
400045f0 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
400045f0: 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 );
400045f4: 90 10 20 00 clr %o0
400045f8: 40 00 11 a4 call 40008c88 <rtems_task_variable_delete>
400045fc: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
40004600: 80 a2 20 00 cmp %o0, 0
40004604: 12 80 00 06 bne 4000461c <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
40004608: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
4000460c: 02 80 00 04 be 4000461c <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
40004610: 01 00 00 00 nop
40004614: 7f ff ff 75 call 400043e8 <free>
40004618: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
4000461c: 81 c7 e0 08 ret
40004620: 91 e8 20 00 restore %g0, 0, %o0
40004534 <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))
{
40004534: 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 ) {
40004538: c2 06 00 00 ld [ %i0 ], %g1
4000453c: 80 a0 60 00 cmp %g1, 0
40004540: 12 80 00 14 bne 40004590 <rtems_gxx_once+0x5c>
40004544: 90 10 21 00 mov 0x100, %o0
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
40004548: 92 10 21 00 mov 0x100, %o1
4000454c: 40 00 11 2a call 400089f4 <rtems_task_mode>
40004550: 94 07 bf fc add %fp, -4, %o2
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
40004554: fa 06 00 00 ld [ %i0 ], %i5
40004558: 80 a7 60 00 cmp %i5, 0
4000455c: 12 80 00 05 bne 40004570 <rtems_gxx_once+0x3c> <== NEVER TAKEN
40004560: d0 07 bf fc ld [ %fp + -4 ], %o0
*(volatile __gthread_once_t *)once = 1;
40004564: 82 10 20 01 mov 1, %g1
40004568: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
4000456c: d0 07 bf fc ld [ %fp + -4 ], %o0
40004570: 92 10 21 00 mov 0x100, %o1
40004574: 40 00 11 20 call 400089f4 <rtems_task_mode>
40004578: 94 07 bf fc add %fp, -4, %o2
if ( o == 0 )
4000457c: 80 a7 60 00 cmp %i5, 0
40004580: 12 80 00 04 bne 40004590 <rtems_gxx_once+0x5c> <== NEVER TAKEN
40004584: 01 00 00 00 nop
(*func)();
40004588: 9f c6 40 00 call %i1
4000458c: 01 00 00 00 nop
}
return 0;
}
40004590: 81 c7 e0 08 ret
40004594: 91 e8 20 00 restore %g0, 0, %o0
40004688 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
40004688: 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 );
4000468c: d4 06 20 04 ld [ %i0 + 4 ], %o2
40004690: 90 10 20 00 clr %o0
40004694: 40 00 11 52 call 40008bdc <rtems_task_variable_add>
40004698: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
4000469c: 80 a2 20 00 cmp %o0, 0
400046a0: 12 80 00 05 bne 400046b4 <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
400046a4: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
400046a8: f2 26 00 00 st %i1, [ %i0 ]
return 0;
400046ac: 81 c7 e0 08 ret
400046b0: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
400046b4: 81 c7 e0 08 ret <== NOT EXECUTED
400046b8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40009430 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40009430: 9d e3 bf a0 save %sp, -96, %sp
if (
40009434: 03 10 00 9a sethi %hi(0x40026800), %g1
40009438: c2 00 61 88 ld [ %g1 + 0x188 ], %g1 ! 40026988 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
4000943c: ba 10 00 18 mov %i0, %i5
40009440: b8 10 00 19 mov %i1, %i4
if (
40009444: 80 a0 60 03 cmp %g1, 3
40009448: 02 80 00 08 be 40009468 <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
4000944c: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
40009450: 7f ff fb ef call 4000840c <malloc_deferred_frees_process>
40009454: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
40009458: 03 10 00 93 sethi %hi(0x40024c00), %g1
4000945c: f0 00 62 44 ld [ %g1 + 0x244 ], %i0 ! 40024e44 <RTEMS_Malloc_Heap>
40009460: 40 00 17 b2 call 4000f328 <_Protected_heap_Allocate_aligned_with_boundary>
40009464: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
40009468: 7f ff fb dd call 400083dc <malloc_is_system_state_OK>
4000946c: 01 00 00 00 nop
40009470: 80 8a 20 ff btst 0xff, %o0
40009474: 12 bf ff f7 bne 40009450 <rtems_heap_allocate_aligned_with_boundary+0x20>
40009478: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
4000947c: 81 c7 e0 08 ret
40009480: 81 e8 00 00 restore
40004b30 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
40004b30: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
40004b34: 03 10 00 5c sethi %hi(0x40017000), %g1
40004b38: f8 00 62 50 ld [ %g1 + 0x250 ], %i4 ! 40017250 <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_size % sbrk_amount;
40004b3c: 90 10 00 19 mov %i1, %o0
40004b40: 92 10 00 1c mov %i4, %o1
40004b44: 40 00 3a 15 call 40013398 <.rem>
40004b48: ba 10 00 19 mov %i1, %i5
void *return_this = NULL;
if ( misaligned != 0 ) {
40004b4c: 80 a2 20 00 cmp %o0, 0
40004b50: 02 80 00 05 be 40004b64 <rtems_heap_extend_via_sbrk+0x34>
40004b54: 80 a7 60 00 cmp %i5, 0
sbrk_size += sbrk_amount - misaligned;
40004b58: ba 27 00 08 sub %i4, %o0, %i5
40004b5c: ba 06 40 1d add %i1, %i5, %i5
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
40004b60: 80 a7 60 00 cmp %i5, 0
40004b64: 04 80 00 17 ble 40004bc0 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40004b68: 80 a7 20 00 cmp %i4, 0
40004b6c: 04 80 00 15 ble 40004bc0 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40004b70: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
40004b74: 7f ff f2 58 call 400014d4 <sbrk>
40004b78: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
40004b7c: 80 a2 3f ff cmp %o0, -1
40004b80: 02 80 00 10 be 40004bc0 <rtems_heap_extend_via_sbrk+0x90>
40004b84: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
40004b88: 90 10 00 18 mov %i0, %o0
40004b8c: 40 00 13 5b call 400098f8 <_Protected_heap_Extend>
40004b90: 94 10 00 1d mov %i5, %o2
if ( ok ) {
40004b94: 80 8a 20 ff btst 0xff, %o0
40004b98: 02 80 00 08 be 40004bb8 <rtems_heap_extend_via_sbrk+0x88>
40004b9c: 03 10 00 5c sethi %hi(0x40017000), %g1
MSBUMP( space_available, sbrk_size );
40004ba0: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 40017220 <rtems_malloc_statistics>
40004ba4: b4 10 20 00 clr %i2
40004ba8: ba 07 40 02 add %i5, %g2, %i5
40004bac: fa 20 62 20 st %i5, [ %g1 + 0x220 ]
40004bb0: 40 00 13 44 call 400098c0 <_Protected_heap_Allocate_aligned_with_boundary>
40004bb4: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( heap, alloc_size );
} else {
sbrk( -sbrk_size );
40004bb8: 7f ff f2 47 call 400014d4 <sbrk>
40004bbc: 90 20 00 1d neg %i5, %o0
}
}
}
return return_this;
}
40004bc0: 81 c7 e0 08 ret
40004bc4: 91 e8 20 00 restore %g0, 0, %o0
40004e8c <rtems_heap_null_extend>:
Heap_Control *heap __attribute__((unused)),
size_t alloc_size __attribute__((unused))
)
{
return NULL;
}
40004e8c: 81 c3 e0 08 retl
40004e90: 90 10 20 00 clr %o0
40005764 <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
40005764: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40005768: 7f ff fe d1 call 400052ac <partition_table_free> <== NOT EXECUTED
4000576c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40005770 <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 );
40005770: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40005774: 7f ff ff 87 call 40005590 <partition_table_get> <== NOT EXECUTED
40005778: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4000577c <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)
{
4000577c: 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));
40005780: 90 10 20 01 mov 1, %o0
40005784: 92 10 21 28 mov 0x128, %o1
40005788: 40 00 02 09 call 40005fac <calloc>
4000578c: b6 10 20 1a mov 0x1a, %i3
if (disk_desc == NULL)
40005790: 80 a2 20 00 cmp %o0, 0
40005794: 02 80 00 34 be 40005864 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
40005798: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
4000579c: 90 10 00 18 mov %i0, %o0
400057a0: 7f ff ff 7c call 40005590 <partition_table_get>
400057a4: 92 10 00 1d mov %i5, %o1
if (rc != RTEMS_SUCCESSFUL)
400057a8: b6 92 20 00 orcc %o0, 0, %i3
400057ac: 02 80 00 06 be 400057c4 <rtems_ide_part_table_initialize+0x48><== ALWAYS TAKEN
400057b0: 23 10 00 94 sethi %hi(0x40025000), %l1
{
free(disk_desc);
400057b4: 40 00 02 36 call 4000608c <free> <== NOT EXECUTED
400057b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
400057bc: 81 c7 e0 08 ret <== NOT EXECUTED
400057c0: 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);
400057c4: 27 10 00 94 sethi %hi(0x40025000), %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);
400057c8: f2 07 40 00 ld [ %i5 ], %i1
400057cc: 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++)
400057d0: b8 10 20 00 clr %i4
{
sprintf(name, "%s%d", dev_name, part_num + 1);
400057d4: b4 07 bf f0 add %fp, -16, %i2
400057d8: a2 14 62 50 or %l1, 0x250, %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);
400057dc: 25 10 00 99 sethi %hi(0x40026400), %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++)
400057e0: 10 80 00 1b b 4000584c <rtems_ide_part_table_initialize+0xd0>
400057e4: a6 14 e2 58 or %l3, 0x258, %l3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
400057e8: 92 10 00 11 mov %l1, %o1
400057ec: 90 10 00 1a mov %i2, %o0
400057f0: 94 10 00 18 mov %i0, %o2
400057f4: 40 00 41 e8 call 40015f94 <sprintf>
400057f8: 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)
400057fc: 83 2f 20 02 sll %i4, 2, %g1
40005800: 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];
40005804: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
if (part_desc == NULL)
40005808: 80 a0 60 00 cmp %g1, 0
4000580c: 02 80 00 10 be 4000584c <rtems_ide_part_table_initialize+0xd0>
40005810: 92 07 00 10 add %i4, %l0, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40005814: d4 1f 40 00 ldd [ %i5 ], %o2
40005818: d8 00 60 04 ld [ %g1 + 4 ], %o4
4000581c: da 00 60 08 ld [ %g1 + 8 ], %o5
40005820: 90 10 00 19 mov %i1, %o0
40005824: 7f ff fd 63 call 40004db0 <rtems_disk_create_log>
40005828: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
4000582c: 96 92 20 00 orcc %o0, 0, %o3
40005830: 22 80 00 08 be,a 40005850 <rtems_ide_part_table_initialize+0xd4><== ALWAYS TAKEN
40005834: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40005838: c2 04 a1 78 ld [ %l2 + 0x178 ], %g1 <== NOT EXECUTED
4000583c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40005840: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005844: 40 00 3f c5 call 40015758 <fprintf> <== NOT EXECUTED
40005848: 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++)
4000584c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40005850: 80 a7 00 01 cmp %i4, %g1
40005854: 26 bf ff e5 bl,a 400057e8 <rtems_ide_part_table_initialize+0x6c>
40005858: b8 07 20 01 inc %i4
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
continue;
}
}
partition_table_free(disk_desc);
4000585c: 7f ff fe 94 call 400052ac <partition_table_free>
40005860: 90 10 00 1d mov %i5, %o0
return RTEMS_SUCCESSFUL;
}
40005864: b0 10 00 1b mov %i3, %i0
40005868: 81 c7 e0 08 ret
4000586c: 81 e8 00 00 restore
4000acdc <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)
{
4000acdc: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
4000ace0: ba 10 20 01 mov 1, %i5
4000ace4: 80 a6 20 00 cmp %i0, 0
4000ace8: 02 80 00 0d be 4000ad1c <rtems_iterate_over_all_threads+0x40><== NEVER TAKEN
4000acec: 35 10 00 88 sethi %hi(0x40022000), %i2
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
4000acf0: 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 ];
4000acf4: 84 16 a0 34 or %i2, 0x34, %g2
4000acf8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000acfc: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( !information )
4000ad00: 80 a6 e0 00 cmp %i3, 0
4000ad04: 12 80 00 0f bne 4000ad40 <rtems_iterate_over_all_threads+0x64>
4000ad08: b8 10 20 01 mov 1, %i4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
4000ad0c: ba 07 60 01 inc %i5
4000ad10: 80 a7 60 04 cmp %i5, 4
4000ad14: 12 bf ff f8 bne 4000acf4 <rtems_iterate_over_all_threads+0x18>
4000ad18: 83 2f 60 02 sll %i5, 2, %g1
4000ad1c: 81 c7 e0 08 ret
4000ad20: 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 ];
4000ad24: 83 2f 20 02 sll %i4, 2, %g1
4000ad28: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
4000ad2c: 80 a2 20 00 cmp %o0, 0
4000ad30: 02 80 00 04 be 4000ad40 <rtems_iterate_over_all_threads+0x64><== NEVER TAKEN
4000ad34: b8 07 20 01 inc %i4
continue;
(*routine)(the_thread);
4000ad38: 9f c6 00 00 call %i0
4000ad3c: 01 00 00 00 nop
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
4000ad40: c2 16 e0 10 lduh [ %i3 + 0x10 ], %g1
4000ad44: 80 a7 00 01 cmp %i4, %g1
4000ad48: 28 bf ff f7 bleu,a 4000ad24 <rtems_iterate_over_all_threads+0x48>
4000ad4c: 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++ ) {
4000ad50: 10 bf ff f0 b 4000ad10 <rtems_iterate_over_all_threads+0x34>
4000ad54: ba 07 60 01 inc %i5
40004170 <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 )
{
40004170: 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)
40004174: 03 10 00 79 sethi %hi(0x4001e400), %g1
40004178: fa 00 63 74 ld [ %g1 + 0x374 ], %i5 ! 4001e774 <rtems_libio_number_iops>
4000417c: 80 a7 60 00 cmp %i5, 0
40004180: 02 80 00 1b be 400041ec <rtems_libio_init+0x7c> <== NEVER TAKEN
40004184: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
40004188: 90 10 00 1d mov %i5, %o0
4000418c: 7f ff fe f3 call 40003d58 <calloc>
40004190: 92 10 20 38 mov 0x38, %o1
40004194: 03 10 00 7c sethi %hi(0x4001f000), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
40004198: 80 a2 20 00 cmp %o0, 0
4000419c: 12 80 00 04 bne 400041ac <rtems_libio_init+0x3c>
400041a0: d0 20 62 f4 st %o0, [ %g1 + 0x2f4 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
400041a4: 10 80 00 1c b 40004214 <rtems_libio_init+0xa4>
400041a8: 90 10 20 1a mov 0x1a, %o0
iop = rtems_libio_iop_freelist = rtems_libio_iops;
400041ac: 03 10 00 7c sethi %hi(0x4001f000), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
400041b0: 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;
400041b4: d0 20 62 f8 st %o0, [ %g1 + 0x2f8 ]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
400041b8: 10 80 00 03 b 400041c4 <rtems_libio_init+0x54>
400041bc: 82 10 20 00 clr %g1
iop->data1 = iop + 1;
400041c0: 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++)
400041c4: 82 00 60 01 inc %g1
400041c8: 80 a0 40 1d cmp %g1, %i5
400041cc: 12 bf ff fd bne 400041c0 <rtems_libio_init+0x50>
400041d0: 84 00 a0 38 add %g2, 0x38, %g2
iop->data1 = iop + 1;
iop->data1 = NULL;
400041d4: 85 28 60 03 sll %g1, 3, %g2
400041d8: 83 28 60 06 sll %g1, 6, %g1
400041dc: 82 20 40 02 sub %g1, %g2, %g1
400041e0: 90 02 00 01 add %o0, %g1, %o0
400041e4: c0 22 3f f8 clr [ %o0 + -8 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
400041e8: 11 13 10 92 sethi %hi(0x4c424800), %o0
400041ec: 92 10 20 01 mov 1, %o1
400041f0: 90 12 21 4f or %o0, 0x14f, %o0
400041f4: 94 10 20 54 mov 0x54, %o2
400041f8: 96 10 20 00 clr %o3
400041fc: 19 10 00 7c sethi %hi(0x4001f000), %o4
40004200: 40 00 0e dd call 40007d74 <rtems_semaphore_create>
40004204: 98 13 22 fc or %o4, 0x2fc, %o4 ! 4001f2fc <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
40004208: 80 a2 20 00 cmp %o0, 0
4000420c: 02 80 00 04 be 4000421c <rtems_libio_init+0xac> <== ALWAYS TAKEN
40004210: 03 10 00 79 sethi %hi(0x4001e400), %g1
rtems_fatal_error_occurred( rc );
40004214: 40 00 11 52 call 4000875c <rtems_fatal_error_occurred>
40004218: 01 00 00 00 nop
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
4000421c: c2 00 63 78 ld [ %g1 + 0x378 ], %g1
40004220: 80 a0 60 00 cmp %g1, 0
40004224: 02 80 00 04 be 40004234 <rtems_libio_init+0xc4>
40004228: 01 00 00 00 nop
(* rtems_fs_init_helper)();
4000422c: 9f c0 40 00 call %g1
40004230: 01 00 00 00 nop
40004234: 81 c7 e0 08 ret
40004238: 81 e8 00 00 restore
400054bc <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
400054bc: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
400054c0: 40 00 05 d9 call 40006c24 <rtems_task_self>
400054c4: 01 00 00 00 nop
rtems_user_env_t *old_env = rtems_current_user_env;
400054c8: 03 10 00 4a sethi %hi(0x40012800), %g1
400054cc: f8 00 63 98 ld [ %g1 + 0x398 ], %i4 ! 40012b98 <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;
400054d0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
400054d4: 80 a0 40 08 cmp %g1, %o0
400054d8: 12 80 00 07 bne 400054f4 <rtems_libio_set_private_env+0x38>
400054dc: b6 10 00 08 mov %o0, %i3
400054e0: 03 10 00 4a sethi %hi(0x40012800), %g1
400054e4: 82 10 63 9c or %g1, 0x39c, %g1 ! 40012b9c <rtems_global_user_env>
400054e8: 80 a7 00 01 cmp %i4, %g1
400054ec: 12 80 00 2b bne 40005598 <rtems_libio_set_private_env+0xdc><== ALWAYS TAKEN
400054f0: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
400054f4: 90 10 20 01 mov 1, %o0
400054f8: 92 10 20 2c mov 0x2c, %o1
400054fc: 40 00 13 15 call 4000a150 <calloc>
40005500: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
40005504: 80 a2 20 00 cmp %o0, 0
40005508: 02 80 00 24 be 40005598 <rtems_libio_set_private_env+0xdc>
4000550c: ba 10 00 08 mov %o0, %i5
*new_env = *old_env;
40005510: 92 10 00 1c mov %i4, %o1
40005514: 40 00 1e 80 call 4000cf14 <memcpy>
40005518: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
4000551c: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
40005520: 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;
40005524: 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);
40005528: 40 00 02 d4 call 40006078 <rtems_filesystem_global_location_obtain>
4000552c: 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 =
40005530: 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);
40005534: 40 00 02 d1 call 40006078 <rtems_filesystem_global_location_obtain>
40005538: 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;
4000553c: 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 =
40005540: d0 27 40 00 st %o0, [ %i5 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
40005544: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40005548: 03 10 00 49 sethi %hi(0x40012400), %g1
4000554c: 82 10 60 64 or %g1, 0x64, %g1 ! 40012464 <rtems_filesystem_null_handlers>
40005550: 80 a0 80 01 cmp %g2, %g1
40005554: 22 80 00 14 be,a 400055a4 <rtems_libio_set_private_env+0xe8>
40005558: 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)
4000555c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40005560: 80 a0 80 01 cmp %g2, %g1
40005564: 02 80 00 0f be 400055a0 <rtems_libio_set_private_env+0xe4><== NEVER TAKEN
40005568: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
4000556c: 37 10 00 4a sethi %hi(0x40012800), %i3
40005570: 15 10 00 15 sethi %hi(0x40005400), %o2
40005574: 92 16 e3 98 or %i3, 0x398, %o1
40005578: 40 00 05 cb call 40006ca4 <rtems_task_variable_add>
4000557c: 94 12 a0 4c or %o2, 0x4c, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
40005580: b0 92 20 00 orcc %o0, 0, %i0
40005584: 32 80 00 08 bne,a 400055a4 <rtems_libio_set_private_env+0xe8>
40005588: b0 10 20 05 mov 5, %i0
free_user_env_protected(old_env);
4000558c: 7f ff ff c3 call 40005498 <free_user_env_protected>
40005590: 90 10 00 1c mov %i4, %o0
rtems_current_user_env = new_env;
40005594: fa 26 e3 98 st %i5, [ %i3 + 0x398 ]
40005598: 81 c7 e0 08 ret
4000559c: 81 e8 00 00 restore
400055a0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
400055a4: 7f ff ff aa call 4000544c <free_user_env>
400055a8: 90 10 00 1d mov %i5, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
400055ac: 81 c7 e0 08 ret
400055b0: 81 e8 00 00 restore
400055b4 <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
400055b4: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
400055b8: 40 00 05 9b call 40006c24 <rtems_task_self>
400055bc: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
400055c0: 80 a2 00 18 cmp %o0, %i0
400055c4: 22 80 00 26 be,a 4000565c <rtems_libio_share_private_env+0xa8>
400055c8: b0 10 20 00 clr %i0
400055cc: 80 a6 20 00 cmp %i0, 0
400055d0: 22 80 00 23 be,a 4000565c <rtems_libio_share_private_env+0xa8>
400055d4: 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;
400055d8: 03 10 00 4d sethi %hi(0x40013400), %g1
400055dc: c4 00 62 80 ld [ %g1 + 0x280 ], %g2 ! 40013680 <_Thread_Dispatch_disable_level>
++level;
400055e0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400055e4: c4 20 62 80 st %g2, [ %g1 + 0x280 ]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
400055e8: 13 10 00 4a sethi %hi(0x40012800), %o1
400055ec: 90 10 00 18 mov %i0, %o0
400055f0: 92 12 63 98 or %o1, 0x398, %o1
400055f4: 40 00 05 fc call 40006de4 <rtems_task_variable_get>
400055f8: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
400055fc: b0 92 20 00 orcc %o0, 0, %i0
40005600: 32 80 00 06 bne,a 40005618 <rtems_libio_share_private_env+0x64>
40005604: b0 10 20 0d mov 0xd, %i0
++env->reference_count;
40005608: c2 07 bf fc ld [ %fp + -4 ], %g1
4000560c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
40005610: 84 00 a0 01 inc %g2
40005614: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
40005618: 40 00 0d ea call 40008dc0 <_Thread_Enable_dispatch>
4000561c: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
40005620: 80 a6 20 00 cmp %i0, 0
40005624: 12 80 00 0e bne 4000565c <rtems_libio_share_private_env+0xa8>
40005628: 90 10 20 00 clr %o0
sc = rtems_task_variable_add(
4000562c: 3b 10 00 4a sethi %hi(0x40012800), %i5
40005630: 15 10 00 15 sethi %hi(0x40005400), %o2
40005634: 92 17 63 98 or %i5, 0x398, %o1
40005638: 40 00 05 9b call 40006ca4 <rtems_task_variable_add>
4000563c: 94 12 a0 4c or %o2, 0x4c, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
40005640: b0 92 20 00 orcc %o0, 0, %i0
40005644: 12 80 00 08 bne 40005664 <rtems_libio_share_private_env+0xb0><== NEVER TAKEN
40005648: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
4000564c: 7f ff ff 93 call 40005498 <free_user_env_protected>
40005650: d0 07 63 98 ld [ %i5 + 0x398 ], %o0
rtems_current_user_env = env;
40005654: c2 07 bf fc ld [ %fp + -4 ], %g1
40005658: c2 27 63 98 st %g1, [ %i5 + 0x398 ]
4000565c: 81 c7 e0 08 ret
40005660: 81 e8 00 00 restore
} else {
free_user_env_protected(env);
40005664: 7f ff ff 8d call 40005498 <free_user_env_protected> <== NOT EXECUTED
40005668: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4000566c: 81 c7 e0 08 ret <== NOT EXECUTED
40005670: 81 e8 00 00 restore <== NOT EXECUTED
4000c6d8 <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 ) {
4000c6d8: 84 0a 20 06 and %o0, 6, %g2
return flags;
}
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
4000c6dc: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000c6e0: 80 a0 a0 06 cmp %g2, 6
4000c6e4: 02 80 00 07 be 4000c700 <rtems_libio_to_fcntl_flags+0x28>
4000c6e8: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
4000c6ec: 80 88 60 02 btst 2, %g1
4000c6f0: 12 80 00 04 bne 4000c700 <rtems_libio_to_fcntl_flags+0x28><== ALWAYS TAKEN
4000c6f4: 90 10 20 00 clr %o0
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
4000c6f8: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
4000c6fc: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
4000c700: 80 88 60 01 btst 1, %g1
4000c704: 02 80 00 04 be 4000c714 <rtems_libio_to_fcntl_flags+0x3c>
4000c708: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
4000c70c: 05 00 00 10 sethi %hi(0x4000), %g2
4000c710: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
4000c714: 32 80 00 02 bne,a 4000c71c <rtems_libio_to_fcntl_flags+0x44>
4000c718: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
4000c71c: 80 88 64 00 btst 0x400, %g1
4000c720: 32 80 00 02 bne,a 4000c728 <rtems_libio_to_fcntl_flags+0x50>
4000c724: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
4000c728: 81 c3 e0 08 retl
40005674 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
40005674: 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) {
40005678: 3b 10 00 4a sethi %hi(0x40012800), %i5
4000567c: c2 07 63 98 ld [ %i5 + 0x398 ], %g1 ! 40012b98 <rtems_current_user_env>
40005680: 39 10 00 4a sethi %hi(0x40012800), %i4
40005684: b8 17 23 9c or %i4, 0x39c, %i4 ! 40012b9c <rtems_global_user_env>
40005688: 80 a0 40 1c cmp %g1, %i4
4000568c: 02 80 00 0a be 400056b4 <rtems_libio_use_global_env+0x40>
40005690: 92 17 63 98 or %i5, 0x398, %o1
sc = rtems_task_variable_delete(
40005694: 40 00 05 af call 40006d50 <rtems_task_variable_delete>
40005698: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
4000569c: 80 a2 20 00 cmp %o0, 0
400056a0: 22 80 00 05 be,a 400056b4 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
400056a4: f8 27 63 98 st %i4, [ %i5 + 0x398 ]
rtems_fatal_error_occurred(0xdeadbeef);
400056a8: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
400056ac: 40 00 06 5d call 40007020 <rtems_fatal_error_occurred> <== NOT EXECUTED
400056b0: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
400056b4: 81 c7 e0 08 ret
400056b8: 81 e8 00 00 restore
40008774 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
40008774: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
40008778: 03 10 00 93 sethi %hi(0x40024c00), %g1
4000877c: d0 00 62 44 ld [ %g1 + 0x244 ], %o0 ! 40024e44 <RTEMS_Malloc_Heap>
40008780: 92 10 00 18 mov %i0, %o1
40008784: 40 00 1b 14 call 4000f3d4 <_Protected_heap_Get_block_size>
40008788: 94 07 bf fc add %fp, -4, %o2
4000878c: 80 8a 20 ff btst 0xff, %o0
40008790: 02 80 00 08 be 400087b0 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
40008794: 03 10 00 98 sethi %hi(0x40026000), %g1
MSBUMP(lifetime_freed, size);
40008798: c8 07 bf fc ld [ %fp + -4 ], %g4
4000879c: 82 10 62 f8 or %g1, 0x2f8, %g1
400087a0: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
400087a4: 86 80 c0 04 addcc %g3, %g4, %g3
400087a8: 84 40 a0 00 addx %g2, 0, %g2
400087ac: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
400087b0: 81 c7 e0 08 ret
400087b4: 81 e8 00 00 restore
400087b8 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
400087b8: 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 )
400087bc: 80 a6 20 00 cmp %i0, 0
400087c0: 02 80 00 14 be 40008810 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
400087c4: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
400087c8: 03 10 00 93 sethi %hi(0x40024c00), %g1
400087cc: d0 00 62 44 ld [ %g1 + 0x244 ], %o0 ! 40024e44 <RTEMS_Malloc_Heap>
400087d0: 92 10 00 18 mov %i0, %o1
400087d4: 40 00 1b 00 call 4000f3d4 <_Protected_heap_Get_block_size>
400087d8: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
400087dc: 03 10 00 98 sethi %hi(0x40026000), %g1
400087e0: c8 07 bf fc ld [ %fp + -4 ], %g4
400087e4: 82 10 62 f8 or %g1, 0x2f8, %g1
400087e8: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
400087ec: 86 80 c0 04 addcc %g3, %g4, %g3
400087f0: 84 40 a0 00 addx %g2, 0, %g2
400087f4: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
400087f8: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
400087fc: 84 20 c0 02 sub %g3, %g2, %g2
if (current_depth > s->max_depth)
40008800: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
40008804: 80 a0 80 03 cmp %g2, %g3
40008808: 38 80 00 02 bgu,a 40008810 <rtems_malloc_statistics_at_malloc+0x58>
4000880c: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
40008810: 81 c7 e0 08 ret
40008814: 81 e8 00 00 restore
40010c28 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
40010c28: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
40010c2c: ba 96 20 00 orcc %i0, 0, %i5
40010c30: 12 80 00 04 bne 40010c40 <rtems_memalign+0x18>
40010c34: 03 10 00 6f sethi %hi(0x4001bc00), %g1
return EINVAL;
40010c38: 81 c7 e0 08 ret
40010c3c: 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()) &&
40010c40: c2 00 62 48 ld [ %g1 + 0x248 ], %g1
40010c44: 80 a0 60 03 cmp %g1, 3
40010c48: 02 80 00 0f be 40010c84 <rtems_memalign+0x5c>
40010c4c: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
40010c50: 7f ff d2 55 call 400055a4 <malloc_deferred_frees_process>
40010c54: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
40010c58: 03 10 00 6a sethi %hi(0x4001a800), %g1
40010c5c: d0 00 63 68 ld [ %g1 + 0x368 ], %o0 ! 4001ab68 <RTEMS_Malloc_Heap>
40010c60: 92 10 00 1a mov %i2, %o1
40010c64: 94 10 00 19 mov %i1, %o2
40010c68: 7f ff e9 60 call 4000b1e8 <_Protected_heap_Allocate_aligned_with_boundary>
40010c6c: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
40010c70: 80 a2 20 00 cmp %o0, 0
40010c74: 12 80 00 0a bne 40010c9c <rtems_memalign+0x74>
40010c78: b8 10 00 08 mov %o0, %i4
40010c7c: 81 c7 e0 08 ret
40010c80: 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() )
40010c84: 7f ff d2 3c call 40005574 <malloc_is_system_state_OK>
40010c88: 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()) &&
40010c8c: 80 8a 20 ff btst 0xff, %o0
40010c90: 02 bf ff ea be 40010c38 <rtems_memalign+0x10> <== NEVER TAKEN
40010c94: 01 00 00 00 nop
40010c98: 30 bf ff ee b,a 40010c50 <rtems_memalign+0x28>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
40010c9c: 03 10 00 6c sethi %hi(0x4001b000), %g1
40010ca0: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 4001b270 <rtems_malloc_statistics_helpers>
40010ca4: 80 a0 60 00 cmp %g1, 0
40010ca8: 22 80 00 06 be,a 40010cc0 <rtems_memalign+0x98>
40010cac: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
40010cb0: c2 00 60 04 ld [ %g1 + 4 ], %g1
40010cb4: 9f c0 40 00 call %g1
40010cb8: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
40010cbc: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
40010cc0: 81 c7 e0 08 ret
40010cc4: 91 e8 20 00 restore %g0, 0, %o0
40009b40 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
40009b40: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
40009b44: 40 00 65 cb call 40023270 <strdup>
40009b48: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
40009b4c: b6 92 20 00 orcc %o0, 0, %i3
40009b50: 32 80 00 04 bne,a 40009b60 <rtems_mkdir+0x20>
40009b54: c2 4e c0 00 ldsb [ %i3 ], %g1
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
40009b58: 81 c7 e0 08 ret
40009b5c: 91 e8 3f ff restore %g0, -1, %o0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
40009b60: b8 10 20 01 mov 1, %i4
++p;
40009b64: 82 18 60 2f xor %g1, 0x2f, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
40009b68: b0 10 20 00 clr %i0
++p;
40009b6c: 80 a0 00 01 cmp %g0, %g1
retval = 0;
break;
}
}
if (!last)
*p = '/';
40009b70: a0 10 20 2f mov 0x2f, %l0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
40009b74: b4 66 ff ff subx %i3, -1, %i2
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
40009b78: 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)) {
40009b7c: 23 00 00 3c sethi %hi(0xf000), %l1
40009b80: 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')
40009b84: c6 4e 80 00 ldsb [ %i2 ], %g3
40009b88: 80 a0 e0 00 cmp %g3, 0
40009b8c: 22 80 00 07 be,a 40009ba8 <rtems_mkdir+0x68>
40009b90: 84 10 20 01 mov 1, %g2
last = 1;
else if (p[0] != '/')
40009b94: 80 a0 e0 2f cmp %g3, 0x2f
40009b98: 12 80 00 4f bne 40009cd4 <rtems_mkdir+0x194>
40009b9c: 84 10 20 00 clr %g2
continue;
*p = '\0';
40009ba0: 10 80 00 03 b 40009bac <rtems_mkdir+0x6c>
40009ba4: c0 2e 80 00 clrb [ %i2 ]
40009ba8: c0 2e 80 00 clrb [ %i2 ]
if (!last && p[1] == '\0')
40009bac: 80 a0 a0 00 cmp %g2, 0
40009bb0: 12 80 00 05 bne 40009bc4 <rtems_mkdir+0x84>
40009bb4: ba 10 20 01 mov 1, %i5
40009bb8: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
40009bbc: 80 a0 00 02 cmp %g0, %g2
40009bc0: ba 60 3f ff subx %g0, -1, %i5
last = 1;
if (first) {
40009bc4: 80 a0 60 00 cmp %g1, 0
40009bc8: 02 80 00 08 be 40009be8 <rtems_mkdir+0xa8>
40009bcc: 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);
40009bd0: 40 00 0a 21 call 4000c454 <umask>
40009bd4: 90 10 20 00 clr %o0
40009bd8: b0 10 00 08 mov %o0, %i0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
40009bdc: 40 00 0a 1e call 4000c454 <umask>
40009be0: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
40009be4: 80 a7 60 00 cmp %i5, 0
40009be8: 02 80 00 05 be 40009bfc <rtems_mkdir+0xbc>
40009bec: 92 10 21 ff mov 0x1ff, %o1
(void)umask(oumask);
40009bf0: 40 00 0a 19 call 4000c454 <umask>
40009bf4: 90 10 00 18 mov %i0, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40009bf8: 92 10 00 19 mov %i1, %o1
40009bfc: 7f ff fc b8 call 40008edc <mkdir>
40009c00: 90 10 00 1b mov %i3, %o0
40009c04: 80 a2 20 00 cmp %o0, 0
40009c08: 16 80 00 2d bge 40009cbc <rtems_mkdir+0x17c>
40009c0c: 80 a7 60 00 cmp %i5, 0
if (errno == EEXIST || errno == EISDIR) {
40009c10: 40 00 5d 6b call 400211bc <__errno>
40009c14: 01 00 00 00 nop
40009c18: c2 02 00 00 ld [ %o0 ], %g1
40009c1c: 80 a0 60 11 cmp %g1, 0x11
40009c20: 12 80 00 09 bne 40009c44 <rtems_mkdir+0x104>
40009c24: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
40009c28: 40 00 00 3d call 40009d1c <stat>
40009c2c: 92 07 bf b8 add %fp, -72, %o1
40009c30: 80 a2 20 00 cmp %o0, 0
40009c34: 16 80 00 0c bge 40009c64 <rtems_mkdir+0x124> <== ALWAYS TAKEN
40009c38: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
40009c3c: 10 80 00 2b b 40009ce8 <rtems_mkdir+0x1a8> <== NOT EXECUTED
40009c40: 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) {
40009c44: 40 00 5d 5e call 400211bc <__errno>
40009c48: 01 00 00 00 nop
40009c4c: c2 02 00 00 ld [ %o0 ], %g1
40009c50: 80 a0 60 15 cmp %g1, 0x15
40009c54: 02 bf ff f5 be 40009c28 <rtems_mkdir+0xe8> <== NEVER TAKEN
40009c58: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
retval = 0;
40009c5c: 10 80 00 23 b 40009ce8 <rtems_mkdir+0x1a8>
40009c60: b8 10 20 00 clr %i4
break;
} else if (!S_ISDIR(sb.st_mode)) {
40009c64: 82 08 40 11 and %g1, %l1, %g1
40009c68: 80 a0 40 12 cmp %g1, %l2
40009c6c: 02 80 00 0f be 40009ca8 <rtems_mkdir+0x168>
40009c70: 80 a7 60 00 cmp %i5, 0
if (last)
40009c74: 02 80 00 08 be 40009c94 <rtems_mkdir+0x154>
40009c78: 01 00 00 00 nop
errno = EEXIST;
40009c7c: 40 00 5d 50 call 400211bc <__errno>
40009c80: b8 10 20 00 clr %i4 ! 0 <PROM_START>
40009c84: 82 10 20 11 mov 0x11, %g1
40009c88: c2 22 00 00 st %g1, [ %o0 ]
40009c8c: 10 80 00 17 b 40009ce8 <rtems_mkdir+0x1a8>
40009c90: ba 10 20 01 mov 1, %i5
else
errno = ENOTDIR;
40009c94: 40 00 5d 4a call 400211bc <__errno>
40009c98: b8 10 20 00 clr %i4
40009c9c: 82 10 20 14 mov 0x14, %g1
40009ca0: 10 80 00 12 b 40009ce8 <rtems_mkdir+0x1a8>
40009ca4: c2 22 00 00 st %g1, [ %o0 ]
retval = 0;
break;
}
if (last)
40009ca8: 32 80 00 09 bne,a 40009ccc <rtems_mkdir+0x18c>
40009cac: b8 10 20 02 mov 2, %i4
retval = 0;
break;
}
}
if (!last)
*p = '/';
40009cb0: e0 2e 80 00 stb %l0, [ %i2 ]
40009cb4: 10 80 00 07 b 40009cd0 <rtems_mkdir+0x190>
40009cb8: 84 10 20 00 clr %g2
} else {
retval = 0;
break;
}
}
if (!last)
40009cbc: 22 bf ff fe be,a 40009cb4 <rtems_mkdir+0x174>
40009cc0: e0 2e 80 00 stb %l0, [ %i2 ]
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
40009cc4: 10 80 00 03 b 40009cd0 <rtems_mkdir+0x190>
40009cc8: 84 10 20 01 mov 1, %g2
40009ccc: 84 10 20 01 mov 1, %g2
40009cd0: 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) {
40009cd4: 80 a0 a0 00 cmp %g2, 0
40009cd8: 02 bf ff ab be 40009b84 <rtems_mkdir+0x44>
40009cdc: b4 06 a0 01 inc %i2
40009ce0: 10 80 00 03 b 40009cec <rtems_mkdir+0x1ac>
40009ce4: 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) {
40009ce8: 82 10 20 00 clr %g1
}
}
if (!last)
*p = '/';
}
if (!first && !last)
40009cec: 80 97 40 01 orcc %i5, %g1, %g0
40009cf0: 12 80 00 04 bne 40009d00 <rtems_mkdir+0x1c0>
40009cf4: 01 00 00 00 nop
(void)umask(oumask);
40009cf8: 40 00 09 d7 call 4000c454 <umask>
40009cfc: 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);
40009d00: 7f ff fa a7 call 4000879c <free>
40009d04: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
40009d08: 80 a7 20 00 cmp %i4, 0
40009d0c: 02 bf ff 93 be 40009b58 <rtems_mkdir+0x18>
40009d10: 01 00 00 00 nop
}
40009d14: 81 c7 e0 08 ret
40009d18: 91 e8 20 00 restore %g0, 0, %o0
40003fd4 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
40003fd4: 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);
40003fd8: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
40003fdc: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40003fe0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
40003fe4: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
40003fe8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40003fec: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40003ff0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40003ff4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40003ff8: 7f ff ff 75 call 40003dcc <rtems_verror> <== NOT EXECUTED
40003ffc: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
40004000: 90 10 20 00 clr %o0 <== NOT EXECUTED
40004004: 13 10 00 73 sethi %hi(0x4001cc00), %o1 <== NOT EXECUTED
40004008: 7f ff ff d1 call 40003f4c <rtems_error> <== NOT EXECUTED
4000400c: 92 12 60 38 or %o1, 0x38, %o1 ! 4001cc38 <IMFS_node_control_default+0xa0><== NOT EXECUTED
_exit(errno);
40004010: 40 00 2e b5 call 4000fae4 <__errno> <== NOT EXECUTED
40004014: 01 00 00 00 nop <== NOT EXECUTED
40004018: 40 00 02 3f call 40004914 <_exit> <== NOT EXECUTED
4000401c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400094a8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
400094a8: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
400094ac: 80 a6 20 00 cmp %i0, 0
400094b0: 02 80 00 38 be 40009590 <rtems_partition_create+0xe8>
400094b4: 82 10 20 03 mov 3, %g1
return RTEMS_INVALID_NAME;
if ( !starting_address )
400094b8: 80 a6 60 00 cmp %i1, 0
400094bc: 02 80 00 35 be 40009590 <rtems_partition_create+0xe8>
400094c0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
400094c4: 80 a7 60 00 cmp %i5, 0
400094c8: 02 80 00 32 be 40009590 <rtems_partition_create+0xe8> <== NEVER TAKEN
400094cc: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
400094d0: 02 80 00 30 be 40009590 <rtems_partition_create+0xe8>
400094d4: 82 10 20 08 mov 8, %g1
400094d8: 80 a6 a0 00 cmp %i2, 0
400094dc: 02 80 00 2d be 40009590 <rtems_partition_create+0xe8>
400094e0: 80 a6 80 1b cmp %i2, %i3
400094e4: 0a 80 00 2b bcs 40009590 <rtems_partition_create+0xe8>
400094e8: 80 8e e0 07 btst 7, %i3
400094ec: 12 80 00 29 bne 40009590 <rtems_partition_create+0xe8>
400094f0: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
400094f4: 12 80 00 27 bne 40009590 <rtems_partition_create+0xe8>
400094f8: 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;
400094fc: 03 10 00 8f sethi %hi(0x40023c00), %g1
40009500: c4 00 62 80 ld [ %g1 + 0x280 ], %g2 ! 40023e80 <_Thread_Dispatch_disable_level>
++level;
40009504: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40009508: c4 20 62 80 st %g2, [ %g1 + 0x280 ]
* 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 );
4000950c: 23 10 00 8f sethi %hi(0x40023c00), %l1
40009510: 40 00 07 08 call 4000b130 <_Objects_Allocate>
40009514: 90 14 60 7c or %l1, 0x7c, %o0 ! 40023c7c <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
40009518: a0 92 20 00 orcc %o0, 0, %l0
4000951c: 32 80 00 06 bne,a 40009534 <rtems_partition_create+0x8c>
40009520: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
40009524: 40 00 0c 03 call 4000c530 <_Thread_Enable_dispatch>
40009528: 01 00 00 00 nop
return RTEMS_TOO_MANY;
4000952c: 10 80 00 19 b 40009590 <rtems_partition_create+0xe8>
40009530: 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 );
40009534: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
40009538: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
4000953c: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
40009540: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
40009544: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
40009548: 40 00 45 b3 call 4001ac14 <.udiv>
4000954c: 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,
40009550: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
40009554: 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,
40009558: 96 10 00 1b mov %i3, %o3
4000955c: b8 04 20 24 add %l0, 0x24, %i4
40009560: 40 00 04 74 call 4000a730 <_Chain_Initialize>
40009564: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
40009568: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000956c: a2 14 60 7c or %l1, 0x7c, %l1
40009570: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
40009574: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40009578: 85 28 a0 02 sll %g2, 2, %g2
4000957c: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
40009580: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
40009584: 40 00 0b eb call 4000c530 <_Thread_Enable_dispatch>
40009588: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
4000958c: 82 10 20 00 clr %g1
}
40009590: 81 c7 e0 08 ret
40009594: 91 e8 00 01 restore %g0, %g1, %o0
40016c88 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
40016c88: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
40016c8c: 11 10 00 f9 sethi %hi(0x4003e400), %o0
40016c90: 92 10 00 18 mov %i0, %o1
40016c94: 90 12 22 0c or %o0, 0x20c, %o0
40016c98: 40 00 14 2b call 4001bd44 <_Objects_Get>
40016c9c: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
40016ca0: c2 07 bf fc ld [ %fp + -4 ], %g1
40016ca4: 80 a0 60 00 cmp %g1, 0
40016ca8: 12 80 00 21 bne 40016d2c <rtems_partition_return_buffer+0xa4>
40016cac: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
40016cb0: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
40016cb4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40016cb8: 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 ) &&
40016cbc: 80 a6 40 01 cmp %i1, %g1
40016cc0: 18 80 00 0b bgu 40016cec <rtems_partition_return_buffer+0x64><== NEVER TAKEN
40016cc4: 82 10 20 00 clr %g1
40016cc8: 80 a6 40 08 cmp %i1, %o0
40016ccc: 0a 80 00 09 bcs 40016cf0 <rtems_partition_return_buffer+0x68>
40016cd0: 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);
40016cd4: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
40016cd8: 40 00 58 3d call 4002cdcc <.urem>
40016cdc: 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 ) &&
40016ce0: 80 a0 00 08 cmp %g0, %o0
40016ce4: 10 80 00 02 b 40016cec <rtems_partition_return_buffer+0x64>
40016ce8: 82 60 3f ff subx %g0, -1, %g1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
40016cec: 80 a0 60 00 cmp %g1, 0
40016cf0: 02 80 00 0b be 40016d1c <rtems_partition_return_buffer+0x94>
40016cf4: 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 );
40016cf8: 40 00 0c 98 call 40019f58 <_Chain_Append>
40016cfc: 92 10 00 19 mov %i1, %o1
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
40016d00: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
40016d04: 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;
40016d08: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
40016d0c: 40 00 17 b9 call 4001cbf0 <_Thread_Enable_dispatch>
40016d10: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
40016d14: 81 c7 e0 08 ret
40016d18: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
40016d1c: 40 00 17 b5 call 4001cbf0 <_Thread_Enable_dispatch>
40016d20: b0 10 20 09 mov 9, %i0
40016d24: 81 c7 e0 08 ret
40016d28: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40016d2c: 81 c7 e0 08 ret
40016d30: 91 e8 20 04 restore %g0, 4, %o0
400338bc <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
400338bc: 9d e3 bf 98 save %sp, -104, %sp
400338c0: 11 10 01 93 sethi %hi(0x40064c00), %o0
400338c4: 92 10 00 18 mov %i0, %o1
400338c8: 90 12 23 08 or %o0, 0x308, %o0
400338cc: 7f ff 56 c1 call 400093d0 <_Objects_Get>
400338d0: 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 ) {
400338d4: c2 07 bf fc ld [ %fp + -4 ], %g1
400338d8: 80 a0 60 00 cmp %g1, 0
400338dc: 12 80 00 6a bne 40033a84 <rtems_rate_monotonic_period+0x1c8>
400338e0: ba 10 00 08 mov %o0, %i5
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
400338e4: 37 10 01 92 sethi %hi(0x40064800), %i3
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
400338e8: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
400338ec: b6 16 e1 40 or %i3, 0x140, %i3
400338f0: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
400338f4: 80 a0 80 01 cmp %g2, %g1
400338f8: 02 80 00 06 be 40033910 <rtems_rate_monotonic_period+0x54>
400338fc: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
40033900: 7f ff 5a 35 call 4000a1d4 <_Thread_Enable_dispatch>
40033904: b0 10 20 17 mov 0x17, %i0
40033908: 81 c7 e0 08 ret
4003390c: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
40033910: 12 80 00 0d bne 40033944 <rtems_rate_monotonic_period+0x88>
40033914: 01 00 00 00 nop
switch ( the_period->state ) {
40033918: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4003391c: 80 a0 60 04 cmp %g1, 4
40033920: 18 80 00 05 bgu 40033934 <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
40033924: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40033928: 05 10 01 78 sethi %hi(0x4005e000), %g2
4003392c: 84 10 a0 f8 or %g2, 0xf8, %g2 ! 4005e0f8 <CSWTCH.24>
40033930: 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();
40033934: 7f ff 5a 28 call 4000a1d4 <_Thread_Enable_dispatch>
40033938: 01 00 00 00 nop
4003393c: 81 c7 e0 08 ret
40033940: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
40033944: 7f ff 3a 24 call 400021d4 <sparc_disable_interrupts>
40033948: 01 00 00 00 nop
4003394c: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
40033950: f8 07 60 38 ld [ %i5 + 0x38 ], %i4
40033954: 80 a7 20 00 cmp %i4, 0
40033958: 12 80 00 15 bne 400339ac <rtems_rate_monotonic_period+0xf0>
4003395c: 80 a7 20 02 cmp %i4, 2
_ISR_Enable( level );
40033960: 7f ff 3a 21 call 400021e4 <sparc_enable_interrupts>
40033964: 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 );
40033968: 90 10 00 1d mov %i5, %o0
4003396c: 7f ff ff b8 call 4003384c <_Rate_monotonic_Initiate_statistics>
40033970: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
40033974: 82 10 20 02 mov 2, %g1
40033978: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
4003397c: 03 10 00 ce sethi %hi(0x40033800), %g1
40033980: 82 10 62 90 or %g1, 0x290, %g1 ! 40033a90 <_Rate_monotonic_Timeout>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40033984: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
40033988: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
the_watchdog->id = id;
4003398c: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
40033990: c0 27 60 34 clr [ %i5 + 0x34 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40033994: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40033998: 11 10 01 91 sethi %hi(0x40064400), %o0
4003399c: 92 07 60 10 add %i5, 0x10, %o1
400339a0: 7f ff 5d 1c call 4000ae10 <_Watchdog_Insert>
400339a4: 90 12 20 c8 or %o0, 0xc8, %o0
400339a8: 30 80 00 1b b,a 40033a14 <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 ) {
400339ac: 12 80 00 1e bne 40033a24 <rtems_rate_monotonic_period+0x168>
400339b0: 80 a7 20 04 cmp %i4, 4
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
400339b4: 7f ff ff 5d call 40033728 <_Rate_monotonic_Update_statistics>
400339b8: 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;
400339bc: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
400339c0: 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;
400339c4: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
400339c8: 7f ff 3a 07 call 400021e4 <sparc_enable_interrupts>
400339cc: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
400339d0: d0 06 e0 10 ld [ %i3 + 0x10 ], %o0
400339d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
400339d8: 13 00 00 10 sethi %hi(0x4000), %o1
400339dc: 7f ff 5c 27 call 4000aa78 <_Thread_Set_state>
400339e0: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
400339e4: 7f ff 39 fc call 400021d4 <sparc_disable_interrupts>
400339e8: 01 00 00 00 nop
local_state = the_period->state;
400339ec: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
400339f0: f8 27 60 38 st %i4, [ %i5 + 0x38 ]
_ISR_Enable( level );
400339f4: 7f ff 39 fc call 400021e4 <sparc_enable_interrupts>
400339f8: 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 )
400339fc: 80 a6 a0 03 cmp %i2, 3
40033a00: 12 80 00 05 bne 40033a14 <rtems_rate_monotonic_period+0x158>
40033a04: 01 00 00 00 nop
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40033a08: d0 06 e0 10 ld [ %i3 + 0x10 ], %o0
40033a0c: 7f ff 59 1c call 40009e7c <_Thread_Clear_state>
40033a10: 13 00 00 10 sethi %hi(0x4000), %o1
_Thread_Enable_dispatch();
40033a14: 7f ff 59 f0 call 4000a1d4 <_Thread_Enable_dispatch>
40033a18: b0 10 20 00 clr %i0
40033a1c: 81 c7 e0 08 ret
40033a20: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
40033a24: 12 bf ff b9 bne 40033908 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
40033a28: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
40033a2c: 7f ff ff 3f call 40033728 <_Rate_monotonic_Update_statistics>
40033a30: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
40033a34: 7f ff 39 ec call 400021e4 <sparc_enable_interrupts>
40033a38: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
40033a3c: 82 10 20 02 mov 2, %g1
40033a40: 92 07 60 10 add %i5, 0x10, %o1
40033a44: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
40033a48: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40033a4c: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40033a50: 11 10 01 91 sethi %hi(0x40064400), %o0
40033a54: 7f ff 5c ef call 4000ae10 <_Watchdog_Insert>
40033a58: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400644c8 <_Watchdog_Ticks_chain>
40033a5c: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
40033a60: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
40033a64: 03 10 01 7f sethi %hi(0x4005fc00), %g1
40033a68: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 4005ffb4 <_Scheduler+0x34>
40033a6c: 9f c0 40 00 call %g1
40033a70: 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();
40033a74: 7f ff 59 d8 call 4000a1d4 <_Thread_Enable_dispatch>
40033a78: 01 00 00 00 nop
40033a7c: 81 c7 e0 08 ret
40033a80: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40033a84: b0 10 20 04 mov 4, %i0
}
40033a88: 81 c7 e0 08 ret
40033a8c: 81 e8 00 00 restore
40026954 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40026954: 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 )
40026958: 80 a6 60 00 cmp %i1, 0
4002695c: 02 80 00 75 be 40026b30 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
40026960: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
40026964: 13 10 01 6c sethi %hi(0x4005b000), %o1
40026968: 9f c6 40 00 call %i1
4002696c: 92 12 63 48 or %o1, 0x348, %o1 ! 4005b348 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
40026970: 90 10 00 18 mov %i0, %o0
40026974: 13 10 01 6c sethi %hi(0x4005b000), %o1
40026978: 9f c6 40 00 call %i1
4002697c: 92 12 63 68 or %o1, 0x368, %o1 ! 4005b368 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
40026980: 90 10 00 18 mov %i0, %o0
40026984: 13 10 01 6c sethi %hi(0x4005b000), %o1
40026988: 9f c6 40 00 call %i1
4002698c: 92 12 63 90 or %o1, 0x390, %o1 ! 4005b390 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
40026990: 90 10 00 18 mov %i0, %o0
40026994: 13 10 01 6c sethi %hi(0x4005b000), %o1
40026998: 9f c6 40 00 call %i1
4002699c: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4005b3b8 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
400269a0: 90 10 00 18 mov %i0, %o0
400269a4: 13 10 01 6d sethi %hi(0x4005b400), %o1
400269a8: 9f c6 40 00 call %i1
400269ac: 92 12 60 08 or %o1, 8, %o1 ! 4005b408 <_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 ;
400269b0: 03 10 01 93 sethi %hi(0x40064c00), %g1
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
400269b4: 39 10 01 6d sethi %hi(0x4005b400), %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,
400269b8: 37 10 01 6d sethi %hi(0x4005b400), %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,
400269bc: 35 10 01 6d sethi %hi(0x4005b400), %i2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
400269c0: 21 10 01 72 sethi %hi(0x4005c800), %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 ;
400269c4: fa 00 63 10 ld [ %g1 + 0x310 ], %i5
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
400269c8: b8 17 20 58 or %i4, 0x58, %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,
400269cc: b6 16 e0 70 or %i3, 0x70, %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,
400269d0: b4 16 a0 90 or %i2, 0x90, %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 ;
400269d4: 10 80 00 52 b 40026b1c <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
400269d8: a0 14 21 20 or %l0, 0x120, %l0
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
400269dc: 40 00 32 75 call 400333b0 <rtems_rate_monotonic_get_statistics>
400269e0: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
400269e4: 80 a2 20 00 cmp %o0, 0
400269e8: 32 80 00 4d bne,a 40026b1c <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
400269ec: 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 );
400269f0: 92 07 bf b0 add %fp, -80, %o1
400269f4: 40 00 32 e0 call 40033574 <rtems_rate_monotonic_get_status>
400269f8: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
400269fc: d0 07 bf b0 ld [ %fp + -80 ], %o0
40026a00: 92 10 20 05 mov 5, %o1
40026a04: 7f ff a2 76 call 4000f3dc <rtems_object_get_name>
40026a08: 94 07 bf a0 add %fp, -96, %o2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
40026a0c: d8 1f bf c8 ldd [ %fp + -56 ], %o4
40026a10: 92 10 00 1c mov %i4, %o1
40026a14: 90 10 00 18 mov %i0, %o0
40026a18: 94 10 00 1d mov %i5, %o2
40026a1c: 9f c6 40 00 call %i1
40026a20: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
40026a24: d2 07 bf c8 ld [ %fp + -56 ], %o1
40026a28: 80 a2 60 00 cmp %o1, 0
40026a2c: 12 80 00 07 bne 40026a48 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
40026a30: 94 07 bf a8 add %fp, -88, %o2
(*print)( context, "\n" );
40026a34: 90 10 00 18 mov %i0, %o0
40026a38: 9f c6 40 00 call %i1
40026a3c: 92 10 00 10 mov %l0, %o1
continue;
40026a40: 10 80 00 37 b 40026b1c <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
40026a44: 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 );
40026a48: 40 00 03 2b call 400276f4 <_Timespec_Divide_by_integer>
40026a4c: 90 07 bf e0 add %fp, -32, %o0
(*print)( context,
40026a50: d0 07 bf d4 ld [ %fp + -44 ], %o0
40026a54: 40 00 a8 c8 call 40050d74 <.div>
40026a58: 92 10 23 e8 mov 0x3e8, %o1
40026a5c: a6 10 00 08 mov %o0, %l3
40026a60: d0 07 bf dc ld [ %fp + -36 ], %o0
40026a64: 40 00 a8 c4 call 40050d74 <.div>
40026a68: 92 10 23 e8 mov 0x3e8, %o1
40026a6c: c2 07 bf a8 ld [ %fp + -88 ], %g1
40026a70: a2 10 00 08 mov %o0, %l1
40026a74: d0 07 bf ac ld [ %fp + -84 ], %o0
40026a78: e8 07 bf d0 ld [ %fp + -48 ], %l4
40026a7c: e4 07 bf d8 ld [ %fp + -40 ], %l2
40026a80: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40026a84: 40 00 a8 bc call 40050d74 <.div>
40026a88: 92 10 23 e8 mov 0x3e8, %o1
40026a8c: 96 10 00 13 mov %l3, %o3
40026a90: 98 10 00 12 mov %l2, %o4
40026a94: 9a 10 00 11 mov %l1, %o5
40026a98: 94 10 00 14 mov %l4, %o2
40026a9c: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40026aa0: 92 10 00 1b mov %i3, %o1
40026aa4: 9f c6 40 00 call %i1
40026aa8: 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);
40026aac: d2 07 bf c8 ld [ %fp + -56 ], %o1
40026ab0: 94 07 bf a8 add %fp, -88, %o2
40026ab4: 40 00 03 10 call 400276f4 <_Timespec_Divide_by_integer>
40026ab8: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
40026abc: d0 07 bf ec ld [ %fp + -20 ], %o0
40026ac0: 40 00 a8 ad call 40050d74 <.div>
40026ac4: 92 10 23 e8 mov 0x3e8, %o1
40026ac8: a6 10 00 08 mov %o0, %l3
40026acc: d0 07 bf f4 ld [ %fp + -12 ], %o0
40026ad0: 40 00 a8 a9 call 40050d74 <.div>
40026ad4: 92 10 23 e8 mov 0x3e8, %o1
40026ad8: c2 07 bf a8 ld [ %fp + -88 ], %g1
40026adc: a2 10 00 08 mov %o0, %l1
40026ae0: d0 07 bf ac ld [ %fp + -84 ], %o0
40026ae4: e8 07 bf e8 ld [ %fp + -24 ], %l4
40026ae8: e4 07 bf f0 ld [ %fp + -16 ], %l2
40026aec: 92 10 23 e8 mov 0x3e8, %o1
40026af0: 40 00 a8 a1 call 40050d74 <.div>
40026af4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40026af8: 92 10 00 1a mov %i2, %o1
40026afc: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40026b00: 94 10 00 14 mov %l4, %o2
40026b04: 90 10 00 18 mov %i0, %o0
40026b08: 96 10 00 13 mov %l3, %o3
40026b0c: 98 10 00 12 mov %l2, %o4
40026b10: 9f c6 40 00 call %i1
40026b14: 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++ ) {
40026b18: 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 ;
40026b1c: 03 10 01 93 sethi %hi(0x40064c00), %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 ;
40026b20: c2 00 63 14 ld [ %g1 + 0x314 ], %g1 ! 40064f14 <_Rate_monotonic_Information+0xc>
40026b24: 80 a7 40 01 cmp %i5, %g1
40026b28: 08 bf ff ad bleu 400269dc <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
40026b2c: 90 10 00 1d mov %i5, %o0
40026b30: 81 c7 e0 08 ret
40026b34: 81 e8 00 00 restore
40008e80 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
40008e80: 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;
40008e84: 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;
40008e88: 90 10 00 19 mov %i1, %o0
40008e8c: 92 10 00 1d mov %i5, %o1
40008e90: 40 00 2d 6b call 4001443c <.urem>
40008e94: b6 10 00 19 mov %i1, %i3
if (excess > 0) {
40008e98: 80 a2 20 00 cmp %o0, 0
40008e9c: 02 80 00 05 be 40008eb0 <rtems_rbheap_allocate+0x30> <== ALWAYS TAKEN
40008ea0: 80 a6 c0 19 cmp %i3, %i1
value += alignment - excess;
40008ea4: b6 06 40 1d add %i1, %i5, %i3 <== NOT EXECUTED
40008ea8: 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) {
40008eac: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
40008eb0: 0a 80 00 04 bcs 40008ec0 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
40008eb4: 80 a6 60 00 cmp %i1, 0
40008eb8: 32 80 00 04 bne,a 40008ec8 <rtems_rbheap_allocate+0x48>
40008ebc: c2 06 00 00 ld [ %i0 ], %g1
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
40008ec0: 81 c7 e0 08 ret
40008ec4: 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);
40008ec8: 84 06 20 04 add %i0, 4, %g2
rtems_rbheap_chunk *big_enough = NULL;
40008ecc: 10 80 00 06 b 40008ee4 <rtems_rbheap_allocate+0x64>
40008ed0: 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) {
40008ed4: 80 a0 c0 1b cmp %g3, %i3
40008ed8: ba 40 3f ff addx %g0, -1, %i5
40008edc: ba 08 40 1d and %g1, %i5, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
40008ee0: 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) {
40008ee4: 80 a7 60 00 cmp %i5, 0
40008ee8: 12 80 00 04 bne 40008ef8 <rtems_rbheap_allocate+0x78>
40008eec: 80 a0 40 02 cmp %g1, %g2
40008ef0: 32 bf ff f9 bne,a 40008ed4 <rtems_rbheap_allocate+0x54>
40008ef4: 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) {
40008ef8: 80 a7 60 00 cmp %i5, 0
40008efc: 02 bf ff f1 be 40008ec0 <rtems_rbheap_allocate+0x40>
40008f00: 01 00 00 00 nop
uintptr_t free_size = free_chunk->size;
40008f04: f4 07 60 1c ld [ %i5 + 0x1c ], %i2
if (free_size > aligned_size) {
40008f08: 80 a6 80 1b cmp %i2, %i3
40008f0c: 28 80 00 14 bleu,a 40008f5c <rtems_rbheap_allocate+0xdc>
40008f10: c4 07 40 00 ld [ %i5 ], %g2
rtems_rbheap_chunk *new_chunk = get_chunk(control);
40008f14: 7f ff ff 80 call 40008d14 <get_chunk>
40008f18: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
40008f1c: b8 92 20 00 orcc %o0, 0, %i4
40008f20: 02 bf ff e8 be 40008ec0 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
40008f24: 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;
40008f28: 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;
40008f2c: f4 27 60 1c st %i2, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
40008f30: 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;
40008f34: b4 06 80 01 add %i2, %g1, %i2
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
40008f38: c0 27 20 04 clr [ %i4 + 4 ]
40008f3c: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
40008f40: 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);
40008f44: 90 06 20 18 add %i0, 0x18, %o0
40008f48: 40 00 06 97 call 4000a9a4 <_RBTree_Insert_unprotected>
40008f4c: 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;
40008f50: f0 07 20 18 ld [ %i4 + 0x18 ], %i0
40008f54: 81 c7 e0 08 ret
40008f58: 81 e8 00 00 restore
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40008f5c: 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;
40008f60: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
40008f64: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40008f68: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
40008f6c: c0 27 60 04 clr [ %i5 + 4 ]
40008f70: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
40008f74: 81 c7 e0 08 ret
40008f78: 81 e8 00 00 restore
400090ac <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
400090ac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
400090b0: 7f ff ed e7 call 4000484c <malloc> <== NOT EXECUTED
400090b4: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
400090b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400090bc: 02 80 00 07 be 400090d8 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
400090c0: 82 06 20 0c add %i0, 0xc, %g1 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
400090c4: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
400090c8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
400090cc: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
the_node->next = before_node;
400090d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
400090d4: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
400090d8: 81 c7 e0 08 ret <== NOT EXECUTED
400090dc: 81 e8 00 00 restore <== NOT EXECUTED
40008f7c <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
40008f7c: 9d e3 bf 80 save %sp, -128, %sp
40008f80: b6 10 00 18 mov %i0, %i3
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
40008f84: 80 a6 60 00 cmp %i1, 0
40008f88: 02 80 00 45 be 4000909c <rtems_rbheap_free+0x120>
40008f8c: 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 };
40008f90: 90 07 bf e0 add %fp, -32, %o0
40008f94: 92 10 20 00 clr %o1
40008f98: 94 10 20 20 mov 0x20, %o2
40008f9c: 40 00 21 0b call 400113c8 <memset>
40008fa0: 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;
40008fa4: ba 10 20 00 clr %i5
40008fa8: 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;
40008fac: 10 80 00 12 b 40008ff4 <rtems_rbheap_free+0x78>
40008fb0: 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);
40008fb4: 90 07 bf e8 add %fp, -24, %o0
40008fb8: 9f c0 40 00 call %g1
40008fbc: 92 10 00 1c mov %i4, %o1
if ( _RBTree_Is_equal( compare_result ) ) {
40008fc0: 80 a2 20 00 cmp %o0, 0
40008fc4: 12 80 00 07 bne 40008fe0 <rtems_rbheap_free+0x64>
40008fc8: 83 3a 20 1f sra %o0, 0x1f, %g1
found = iter_node;
if ( the_rbtree->is_unique )
40008fcc: c2 0e a0 14 ldub [ %i2 + 0x14 ], %g1
40008fd0: 80 a0 60 00 cmp %g1, 0
40008fd4: 12 80 00 0c bne 40009004 <rtems_rbheap_free+0x88> <== ALWAYS TAKEN
40008fd8: ba 10 00 1c mov %i4, %i5
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
40008fdc: 83 3a 20 1f sra %o0, 0x1f, %g1 <== NOT EXECUTED
40008fe0: 90 20 40 08 sub %g1, %o0, %o0
40008fe4: 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];
40008fe8: 91 2a 20 02 sll %o0, 2, %o0
40008fec: b8 07 00 08 add %i4, %o0, %i4
40008ff0: 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) {
40008ff4: 80 a7 20 00 cmp %i4, 0
40008ff8: 32 bf ff ef bne,a 40008fb4 <rtems_rbheap_free+0x38>
40008ffc: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40009000: b8 10 00 1d mov %i5, %i4
return rtems_rbheap_chunk_of_node(
40009004: 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) {
40009008: 80 a7 7f f8 cmp %i5, -8
4000900c: 02 80 00 24 be 4000909c <rtems_rbheap_free+0x120>
40009010: 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);
40009014: c4 07 3f f8 ld [ %i4 + -8 ], %g2
40009018: 80 a0 a0 00 cmp %g2, 0
4000901c: 12 80 00 05 bne 40009030 <rtems_rbheap_free+0xb4>
40009020: 82 10 20 00 clr %g1
40009024: c2 07 60 04 ld [ %i5 + 4 ], %g1
40009028: 80 a0 00 01 cmp %g0, %g1
4000902c: 82 60 3f ff subx %g0, -1, %g1
if (!rtems_rbheap_is_chunk_free(chunk)) {
40009030: 80 a0 60 00 cmp %g1, 0
40009034: 02 80 00 1a be 4000909c <rtems_rbheap_free+0x120>
40009038: 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(
4000903c: b8 07 60 08 add %i5, 8, %i4
40009040: 92 10 20 00 clr %o1
40009044: 40 00 06 fd call 4000ac38 <_RBTree_Next_unprotected>
40009048: 90 10 00 1c mov %i4, %o0
4000904c: 92 10 20 01 mov 1, %o1
40009050: b2 10 00 08 mov %o0, %i1
40009054: 40 00 06 f9 call 4000ac38 <_RBTree_Next_unprotected>
40009058: 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);
4000905c: 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(
40009060: 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);
40009064: 94 10 00 1d mov %i5, %o2
40009068: 7f ff ff 02 call 40008c70 <check_and_merge>
4000906c: 90 10 00 1b mov %i3, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40009070: c2 06 c0 00 ld [ %i3 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40009074: f6 27 60 04 st %i3, [ %i5 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
40009078: fa 26 c0 00 st %i5, [ %i3 ]
the_node->next = before_node;
4000907c: c2 27 40 00 st %g1, [ %i5 ]
before_node->previous = the_node;
40009080: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
40009084: 90 10 00 1b mov %i3, %o0
40009088: 92 10 00 1a mov %i2, %o1
4000908c: 94 10 00 1d mov %i5, %o2
40009090: 96 06 7f f8 add %i1, -8, %o3
40009094: 7f ff fe f7 call 40008c70 <check_and_merge>
40009098: b0 10 20 00 clr %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
4000909c: 81 c7 e0 08 ret
400090a0: 81 e8 00 00 restore
40019fa0 <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)
{
40019fa0: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
40019fa4: 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)
{
40019fa8: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
40019fac: 80 a0 60 00 cmp %g1, 0
40019fb0: 02 80 00 0f be 40019fec <rtems_rfs_bitmap_load_map+0x4c>
40019fb4: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
40019fb8: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
40019fbc: d4 07 60 08 ld [ %i5 + 8 ], %o2
40019fc0: d0 07 60 04 ld [ %i5 + 4 ], %o0
40019fc4: d2 07 40 00 ld [ %i5 ], %o1
40019fc8: 40 00 06 e8 call 4001bb68 <rtems_rfs_buffer_handle_request>
40019fcc: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
40019fd0: b0 92 20 00 orcc %o0, 0, %i0
40019fd4: 12 80 00 06 bne 40019fec <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
40019fd8: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
40019fdc: c2 07 40 00 ld [ %i5 ], %g1
40019fe0: c2 00 60 08 ld [ %g1 + 8 ], %g1
40019fe4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40019fe8: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
40019fec: 81 c7 e0 08 ret
40019ff0: 81 e8 00 00 restore
4001a570 <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)
{
4001a570: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
4001a574: 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))
4001a578: 10 80 00 2d b 4001a62c <rtems_rfs_bitmap_map_alloc+0xbc>
4001a57c: 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)
4001a580: 2a 80 00 07 bcs,a 4001a59c <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
4001a584: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
break;
}
if (lower_seed >= 0)
4001a588: 80 a6 60 00 cmp %i1, 0
4001a58c: 36 80 00 17 bge,a 4001a5e8 <rtems_rfs_bitmap_map_alloc+0x78>
4001a590: 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)
4001a594: 10 80 00 10 b 4001a5d4 <rtems_rfs_bitmap_map_alloc+0x64>
4001a598: 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,
4001a59c: 90 10 00 18 mov %i0, %o0
4001a5a0: 92 10 00 1b mov %i3, %o1
4001a5a4: 94 10 00 1a mov %i2, %o2
4001a5a8: 7f ff fe 93 call 40019ff4 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001a5ac: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
4001a5b0: 80 a2 20 00 cmp %o0, 0
4001a5b4: 34 80 00 2d bg,a 4001a668 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
4001a5b8: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001a5bc: c2 0e 80 00 ldub [ %i2 ], %g1
4001a5c0: 80 a0 60 00 cmp %g1, 0
4001a5c4: 02 bf ff f2 be 4001a58c <rtems_rfs_bitmap_map_alloc+0x1c>
4001a5c8: 80 a6 60 00 cmp %i1, 0
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
4001a5cc: 81 c7 e0 08 ret
4001a5d0: 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)
4001a5d4: 80 a7 40 01 cmp %i5, %g1
4001a5d8: 2a 80 00 12 bcs,a 4001a620 <rtems_rfs_bitmap_map_alloc+0xb0>
4001a5dc: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
4001a5e0: 10 80 00 11 b 4001a624 <rtems_rfs_bitmap_map_alloc+0xb4>
4001a5e4: 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,
4001a5e8: 90 10 00 18 mov %i0, %o0
4001a5ec: 92 10 00 1b mov %i3, %o1
4001a5f0: 94 10 00 1a mov %i2, %o2
4001a5f4: 7f ff fe 80 call 40019ff4 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001a5f8: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
4001a5fc: 80 a2 20 00 cmp %o0, 0
4001a600: 34 80 00 1a bg,a 4001a668 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
4001a604: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001a608: c2 0e 80 00 ldub [ %i2 ], %g1
4001a60c: 80 a0 60 00 cmp %g1, 0
4001a610: 22 bf ff f1 be,a 4001a5d4 <rtems_rfs_bitmap_map_alloc+0x64>
4001a614: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
4001a618: 81 c7 e0 08 ret
4001a61c: 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)
4001a620: 80 a6 60 00 cmp %i1, 0
4001a624: 36 80 00 02 bge,a 4001a62c <rtems_rfs_bitmap_map_alloc+0xbc>
4001a628: 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))
4001a62c: 80 a7 60 00 cmp %i5, 0
4001a630: 06 80 00 07 bl 4001a64c <rtems_rfs_bitmap_map_alloc+0xdc>
4001a634: 80 a6 60 00 cmp %i1, 0
4001a638: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001a63c: 80 a7 40 01 cmp %i5, %g1
4001a640: 2a bf ff d7 bcs,a 4001a59c <rtems_rfs_bitmap_map_alloc+0x2c>
4001a644: fa 26 c0 00 st %i5, [ %i3 ]
|| ((lower_seed >= 0) && (lower_seed < control->size)))
4001a648: 80 a6 60 00 cmp %i1, 0
4001a64c: 26 80 00 07 bl,a 4001a668 <rtems_rfs_bitmap_map_alloc+0xf8>
4001a650: b0 10 20 00 clr %i0
4001a654: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001a658: 80 a6 40 01 cmp %i1, %g1
4001a65c: 0a bf ff c9 bcs 4001a580 <rtems_rfs_bitmap_map_alloc+0x10>
4001a660: 80 a7 40 01 cmp %i5, %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
4001a664: b0 10 20 00 clr %i0
4001a668: 81 c7 e0 08 ret
4001a66c: 81 e8 00 00 restore
4001a274 <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;
}
4001a274: 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);
4001a278: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
4001a27c: 81 c3 e0 08 retl <== NOT EXECUTED
4001a280: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
4001a284 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
4001a284: 82 10 00 08 mov %o0, %g1
rtems_rfs_bitmap_element mask = 0;
if (end > start)
4001a288: 80 a2 40 01 cmp %o1, %g1
4001a28c: 08 80 00 06 bleu 4001a2a4 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
4001a290: 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);
4001a294: 92 20 40 09 sub %g1, %o1, %o1
4001a298: 90 10 3f ff mov -1, %o0
4001a29c: 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;
4001a2a0: 91 2a 00 01 sll %o0, %g1, %o0
return mask;
}
4001a2a4: 81 c3 e0 08 retl
4001a9d8 <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)
{
4001a9d8: 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);
4001a9dc: 96 10 20 01 mov 1, %o3
4001a9e0: 90 10 00 18 mov %i0, %o0
4001a9e4: 92 10 00 19 mov %i1, %o1
4001a9e8: 40 00 04 60 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001a9ec: 94 10 00 1a mov %i2, %o2
if (rc > 0)
4001a9f0: 80 a2 20 00 cmp %o0, 0
4001a9f4: 14 80 00 26 bg 4001aa8c <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
4001a9f8: 87 2e e0 02 sll %i3, 2, %g3
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
4001a9fc: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001aa00: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
4001aa04: 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);
4001aa08: 84 01 00 03 add %g4, %g3, %g2
4001aa0c: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
4001aa10: fa 08 a0 03 ldub [ %g2 + 3 ], %i5
4001aa14: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001aa18: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
4001aa1c: 83 28 60 18 sll %g1, 0x18, %g1
4001aa20: 85 28 a0 08 sll %g2, 8, %g2
4001aa24: 82 17 40 01 or %i5, %g1, %g1
4001aa28: 87 28 e0 10 sll %g3, 0x10, %g3
4001aa2c: 82 10 40 03 or %g1, %g3, %g1
4001aa30: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
4001aa34: 84 38 00 01 xnor %g0, %g1, %g2
4001aa38: 80 a0 00 02 cmp %g0, %g2
4001aa3c: 84 60 20 00 subx %g0, 0, %g2
4001aa40: 82 08 40 02 and %g1, %g2, %g1
if (*result >= rtems_rfs_fs_blocks (fs))
4001aa44: c4 06 20 04 ld [ %i0 + 4 ], %g2
4001aa48: 80 a0 40 02 cmp %g1, %g2
4001aa4c: 0a 80 00 10 bcs 4001aa8c <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
4001aa50: c2 27 00 00 st %g1, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
4001aa54: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001aa58: 7f ff e4 6c call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001aa5c: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
4001aa60: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001aa64: 22 80 00 09 be,a 4001aa88 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
4001aa68: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
4001aa6c: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
4001aa70: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001aa74: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001aa78: 90 12 20 80 or %o0, 0x80, %o0 <== NOT EXECUTED
4001aa7c: 40 00 1f 29 call 40022720 <printf> <== NOT EXECUTED
4001aa80: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
4001aa84: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
4001aa88: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
4001aa8c: 81 c7 e0 08 ret
4001aa90: 91 e8 00 08 restore %g0, %o0, %o0
4001aaf8 <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)
{
4001aaf8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
4001aafc: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
4001ab00: 32 80 00 06 bne,a 4001ab18 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
4001ab04: 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;
4001ab08: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
4001ab0c: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
4001ab10: 81 c7 e0 08 ret <== NOT EXECUTED
4001ab14: 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;
4001ab18: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001ab1c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001ab20: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4001ab24: 40 00 53 86 call 4002f93c <__udivdi3> <== NOT EXECUTED
4001ab28: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001ab2c: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
4001ab30: 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;
4001ab34: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
4001ab38: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001ab3c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001ab40: 40 00 54 53 call 4002fc8c <__umoddi3> <== NOT EXECUTED
4001ab44: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001ab48: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
4001ab4c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ab50: 81 e8 00 00 restore <== NOT EXECUTED
4001ad38 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
4001ad38: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
4001ad3c: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
4001ad40: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
4001ad44: 80 a0 60 00 cmp %g1, 0
4001ad48: 02 80 00 61 be 4001aecc <rtems_rfs_block_map_close+0x194>
4001ad4c: b0 10 20 00 clr %i0
4001ad50: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001ad54: 80 a2 60 00 cmp %o1, 0
4001ad58: 22 80 00 5e be,a 4001aed0 <rtems_rfs_block_map_close+0x198><== NEVER TAKEN
4001ad5c: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
4001ad60: 7f ff dc f4 call 40012130 <rtems_rfs_inode_load>
4001ad64: 90 10 00 1d mov %i5, %o0
if (brc > 0)
4001ad68: b0 92 20 00 orcc %o0, 0, %i0
4001ad6c: 14 80 00 59 bg 4001aed0 <rtems_rfs_block_map_close+0x198> <== NEVER TAKEN
4001ad70: 92 06 60 38 add %i1, 0x38, %o1
4001ad74: 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);
4001ad78: 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]);
4001ad7c: c4 06 60 04 ld [ %i1 + 4 ], %g2
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
4001ad80: 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);
4001ad84: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
4001ad88: 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]);
4001ad8c: c6 00 e0 24 ld [ %g3 + 0x24 ], %g3
4001ad90: 88 00 60 06 add %g1, 6, %g4
4001ad94: 89 29 20 02 sll %g4, 2, %g4
4001ad98: b6 06 c0 04 add %i3, %g4, %i3
4001ad9c: b5 30 e0 18 srl %g3, 0x18, %i2
4001ada0: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
4001ada4: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
4001ada8: b5 30 e0 10 srl %g3, 0x10, %i2
4001adac: b6 06 c0 04 add %i3, %g4, %i3
4001adb0: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
4001adb4: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
4001adb8: b5 30 e0 08 srl %g3, 8, %i2
4001adbc: b6 06 c0 04 add %i3, %g4, %i3
4001adc0: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
4001adc4: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001adc8: 82 00 60 01 inc %g1
4001adcc: 88 06 c0 04 add %i3, %g4, %g4
4001add0: c6 29 20 07 stb %g3, [ %g4 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001add4: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
4001add8: 80 a0 60 05 cmp %g1, 5
4001addc: 12 bf ff e8 bne 4001ad7c <rtems_rfs_block_map_close+0x44>
4001ade0: 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);
4001ade4: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001ade8: 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);
4001adec: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001adf0: b9 30 a0 18 srl %g2, 0x18, %i4
4001adf4: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
4001adf8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001adfc: b9 30 a0 10 srl %g2, 0x10, %i4
4001ae00: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
4001ae04: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae08: b9 30 a0 08 srl %g2, 8, %i4
4001ae0c: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
4001ae10: 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);
4001ae14: 90 10 00 1d mov %i5, %o0
4001ae18: c4 29 20 0f stb %g2, [ %g4 + 0xf ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ae1c: 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);
4001ae20: 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);
4001ae24: f8 0e 60 0e ldub [ %i1 + 0xe ], %i4
4001ae28: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001ae2c: c8 06 60 0c ld [ %i1 + 0xc ], %g4
4001ae30: f8 28 a0 0a stb %i4, [ %g2 + 0xa ]
4001ae34: 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);
4001ae38: 94 10 20 01 mov 1, %o2
4001ae3c: c8 28 a0 0b stb %g4, [ %g2 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ae40: 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);
4001ae44: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001ae48: 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);
4001ae4c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae50: b9 30 a0 18 srl %g2, 0x18, %i4
4001ae54: f8 29 20 30 stb %i4, [ %g4 + 0x30 ]
4001ae58: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae5c: b9 30 a0 10 srl %g2, 0x10, %i4
4001ae60: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
4001ae64: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae68: b9 30 a0 08 srl %g2, 8, %i4
4001ae6c: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
4001ae70: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae74: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ae78: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4001ae7c: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001ae80: 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);
4001ae84: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae88: b9 30 a0 18 srl %g2, 0x18, %i4
4001ae8c: f8 29 20 34 stb %i4, [ %g4 + 0x34 ]
4001ae90: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001ae94: b9 30 a0 10 srl %g2, 0x10, %i4
4001ae98: f8 29 20 35 stb %i4, [ %g4 + 0x35 ]
4001ae9c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001aea0: b9 30 a0 08 srl %g2, 8, %i4
4001aea4: f8 29 20 36 stb %i4, [ %g4 + 0x36 ]
4001aea8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4001aeac: c4 29 20 37 stb %g2, [ %g4 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001aeb0: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001aeb4: 7f ff dd 02 call 400122bc <rtems_rfs_inode_unload>
4001aeb8: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
4001aebc: c0 2e 40 00 clrb [ %i1 ]
4001aec0: 82 38 00 08 xnor %g0, %o0, %g1
4001aec4: 83 38 60 1f sra %g1, 0x1f, %g1
4001aec8: 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);
4001aecc: 92 06 60 38 add %i1, 0x38, %o1
}
}
map->inode = NULL;
4001aed0: c0 26 60 04 clr [ %i1 + 4 ]
4001aed4: 40 00 02 b1 call 4001b998 <rtems_rfs_buffer_handle_release>
4001aed8: 90 10 00 1d mov %i5, %o0
4001aedc: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
4001aee0: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
4001aee4: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
4001aee8: 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);
4001aeec: 40 00 02 ab call 4001b998 <rtems_rfs_buffer_handle_release>
4001aef0: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
4001aef4: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
4001aef8: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
4001aefc: 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;
}
4001af00: 81 c7 e0 08 ret
4001af04: 81 e8 00 00 restore
4001af08 <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)
{
4001af08: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
4001af0c: 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))
4001af10: fa 06 80 00 ld [ %i2 ], %i5
4001af14: 80 a7 60 00 cmp %i5, 0
4001af18: 02 80 00 05 be 4001af2c <rtems_rfs_block_map_find+0x24>
4001af1c: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001af20: 80 a7 20 00 cmp %i4, 0
4001af24: 02 80 00 53 be 4001b070 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
4001af28: 90 10 20 06 mov 6, %o0
4001af2c: 80 a7 40 1c cmp %i5, %i4
4001af30: 1a 80 00 50 bcc 4001b070 <rtems_rfs_block_map_find+0x168>
4001af34: 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))
4001af38: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4001af3c: 80 a7 40 01 cmp %i5, %g1
4001af40: 12 80 00 08 bne 4001af60 <rtems_rfs_block_map_find+0x58>
4001af44: 80 a7 20 05 cmp %i4, 5
4001af48: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4001af4c: 80 a0 60 00 cmp %g1, 0
4001af50: 02 80 00 04 be 4001af60 <rtems_rfs_block_map_find+0x58>
4001af54: 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];
4001af58: 10 80 00 3d b 4001b04c <rtems_rfs_block_map_find+0x144>
4001af5c: 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)
4001af60: 38 80 00 08 bgu,a 4001af80 <rtems_rfs_block_map_find+0x78>
4001af64: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
{
*block = map->blocks[bpos->bno];
4001af68: ba 07 60 08 add %i5, 8, %i5
4001af6c: bb 2f 60 02 sll %i5, 2, %i5
4001af70: ba 06 40 1d add %i1, %i5, %i5
4001af74: c2 07 60 04 ld [ %i5 + 4 ], %g1
4001af78: 10 80 00 35 b 4001b04c <rtems_rfs_block_map_find+0x144>
4001af7c: 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;
4001af80: 90 10 00 1d mov %i5, %o0
4001af84: 40 00 4f 9f call 4002ee00 <.urem>
4001af88: 92 10 00 10 mov %l0, %o1
singly = bpos->bno / fs->blocks_per_block;
4001af8c: 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;
4001af90: a2 10 00 08 mov %o0, %l1
singly = bpos->bno / fs->blocks_per_block;
4001af94: 7f ff 9d ba call 4000267c <.udiv>
4001af98: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
4001af9c: 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;
4001afa0: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
4001afa4: 80 a7 00 01 cmp %i4, %g1
4001afa8: 18 80 00 09 bgu 4001afcc <rtems_rfs_block_map_find+0xc4> <== NEVER TAKEN
4001afac: 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,
4001afb0: ba 02 20 08 add %o0, 8, %i5
4001afb4: 92 06 60 38 add %i1, 0x38, %o1
4001afb8: bb 2f 60 02 sll %i5, 2, %i5
4001afbc: 90 10 00 18 mov %i0, %o0
4001afc0: ba 06 40 1d add %i1, %i5, %i5
4001afc4: 10 80 00 1c b 4001b034 <rtems_rfs_block_map_find+0x12c>
4001afc8: 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;
4001afcc: 40 00 4f 8d call 4002ee00 <.urem> <== NOT EXECUTED
4001afd0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001afd4: 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;
4001afd8: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
4001afdc: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001afe0: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED
4001afe4: 1a 80 00 23 bcc 4001b070 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
4001afe8: 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;
4001afec: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001aff0: 7f ff 9d a3 call 4000267c <.udiv> <== NOT EXECUTED
4001aff4: 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,
4001aff8: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
4001affc: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
4001b000: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001b004: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
4001b008: b8 06 60 44 add %i1, 0x44, %i4 <== NOT EXECUTED
4001b00c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b010: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001b014: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001b018: 7f ff fe 70 call 4001a9d8 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
4001b01c: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
4001b020: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b024: 12 80 00 13 bne 4001b070 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
4001b028: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
4001b02c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b030: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
4001b034: 96 10 00 11 mov %l1, %o3
4001b038: 7f ff fe 68 call 4001a9d8 <rtems_rfs_block_find_indirect>
4001b03c: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
4001b040: 80 a2 20 00 cmp %o0, 0
4001b044: 12 80 00 0b bne 4001b070 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
4001b048: 01 00 00 00 nop
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
4001b04c: c2 06 80 00 ld [ %i2 ], %g1
map->bpos.block = *block;
4001b050: 90 10 20 00 clr %o0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
4001b054: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
4001b058: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4001b05c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
4001b060: c2 06 a0 08 ld [ %i2 + 8 ], %g1
4001b064: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
map->bpos.block = *block;
4001b068: c2 06 c0 00 ld [ %i3 ], %g1
4001b06c: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
4001b070: 81 c7 e0 08 ret
4001b074: 91 e8 00 08 restore %g0, %o0, %o0
4001b120 <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)
{
4001b120: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001b124: 90 10 20 00 clr %o0
4001b128: 13 00 00 08 sethi %hi(0x2000), %o1
4001b12c: 7f ff e2 b7 call 40013c08 <rtems_rfs_trace>
4001b130: ba 10 00 18 mov %i0, %i5
4001b134: 80 8a 20 ff btst 0xff, %o0
4001b138: 22 80 00 08 be,a 4001b158 <rtems_rfs_block_map_grow+0x38><== ALWAYS TAKEN
4001b13c: c4 06 60 08 ld [ %i1 + 8 ], %g2
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
4001b140: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
4001b144: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001b148: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001b14c: 40 00 1d 75 call 40022720 <printf> <== NOT EXECUTED
4001b150: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001b154: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001b158: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
4001b15c: 84 06 80 02 add %i2, %g2, %g2
4001b160: 80 a0 80 01 cmp %g2, %g1
4001b164: 1a 80 00 b2 bcc 4001b42c <rtems_rfs_block_map_grow+0x30c> <== NEVER TAKEN
4001b168: 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,
4001b16c: 10 80 00 d4 b 4001b4bc <rtems_rfs_block_map_grow+0x39c>
4001b170: 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,
4001b174: 90 10 00 1d mov %i5, %o0
4001b178: 94 10 20 00 clr %o2
4001b17c: 7f ff da c5 call 40011c90 <rtems_rfs_group_bitmap_alloc>
4001b180: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
4001b184: b0 92 20 00 orcc %o0, 0, %i0
4001b188: 14 80 00 d4 bg 4001b4d8 <rtems_rfs_block_map_grow+0x3b8>
4001b18c: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
4001b190: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001b194: 80 a7 20 04 cmp %i4, 4
4001b198: 38 80 00 08 bgu,a 4001b1b8 <rtems_rfs_block_map_grow+0x98>
4001b19c: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
map->blocks[map->size.count] = block;
4001b1a0: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001b1a4: b8 07 20 08 add %i4, 8, %i4
4001b1a8: b9 2f 20 02 sll %i4, 2, %i4
4001b1ac: b8 06 40 1c add %i1, %i4, %i4
4001b1b0: 10 80 00 b7 b 4001b48c <rtems_rfs_block_map_grow+0x36c>
4001b1b4: 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;
4001b1b8: 90 10 00 1c mov %i4, %o0
4001b1bc: 40 00 4f 11 call 4002ee00 <.urem>
4001b1c0: 92 10 00 18 mov %i0, %o1
singly = map->size.count / fs->blocks_per_block;
4001b1c4: 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;
4001b1c8: a4 10 00 08 mov %o0, %l2
singly = map->size.count / fs->blocks_per_block;
4001b1cc: 7f ff 9d 2c call 4000267c <.udiv>
4001b1d0: 90 10 00 1c mov %i4, %o0
if (map->size.count < fs->block_map_singly_blocks)
4001b1d4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
4001b1d8: 80 a7 00 01 cmp %i4, %g1
4001b1dc: 1a 80 00 1d bcc 4001b250 <rtems_rfs_block_map_grow+0x130> <== NEVER TAKEN
4001b1e0: 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) ||
4001b1e4: 80 a4 a0 00 cmp %l2, 0
4001b1e8: 22 80 00 07 be,a 4001b204 <rtems_rfs_block_map_grow+0xe4><== NEVER TAKEN
4001b1ec: b8 1f 20 05 xor %i4, 5, %i4 <== NOT EXECUTED
4001b1f0: 80 a4 a0 05 cmp %l2, 5
4001b1f4: 12 80 00 10 bne 4001b234 <rtems_rfs_block_map_grow+0x114>
4001b1f8: 80 a2 20 00 cmp %o0, 0
4001b1fc: 12 80 00 0e bne 4001b234 <rtems_rfs_block_map_grow+0x114> <== NEVER TAKEN
4001b200: 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,
4001b204: 80 a0 00 1c cmp %g0, %i4
&map->singly_buffer,
&map->blocks[singly],
4001b208: 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,
4001b20c: 90 10 00 1d mov %i5, %o0
&map->singly_buffer,
&map->blocks[singly],
4001b210: 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,
4001b214: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
4001b218: 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,
4001b21c: 94 10 00 11 mov %l1, %o2
4001b220: 96 02 e0 04 add %o3, 4, %o3
4001b224: 7f ff fd 9c call 4001a894 <rtems_rfs_block_map_indirect_alloc>
4001b228: 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)
4001b22c: 10 80 00 7a b 4001b414 <rtems_rfs_block_map_grow+0x2f4>
4001b230: b0 92 20 00 orcc %o0, 0, %i0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b234: ac 05 a0 08 add %l6, 8, %l6
4001b238: 90 10 00 1d mov %i5, %o0
4001b23c: ad 2d a0 02 sll %l6, 2, %l6
4001b240: 92 10 00 11 mov %l1, %o1
4001b244: ac 06 40 16 add %i1, %l6, %l6
4001b248: 10 80 00 70 b 4001b408 <rtems_rfs_block_map_grow+0x2e8>
4001b24c: 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;
4001b250: 7f ff 9d 0b call 4000267c <.udiv> <== NOT EXECUTED
4001b254: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001b258: 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;
4001b25c: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001b260: 40 00 4e e8 call 4002ee00 <.urem> <== NOT EXECUTED
4001b264: 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)
4001b268: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001b26c: 12 80 00 4a bne 4001b394 <rtems_rfs_block_map_grow+0x274> <== NOT EXECUTED
4001b270: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b274: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b278: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001b27c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4001b280: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
4001b284: 7f ff fd 84 call 4001a894 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001b288: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
4001b28c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001b290: 04 80 00 04 ble 4001b2a0 <rtems_rfs_block_map_grow+0x180> <== NOT EXECUTED
4001b294: 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);
4001b298: 10 80 00 62 b 4001b420 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
4001b29c: 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) ||
4001b2a0: 22 80 00 08 be,a 4001b2c0 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
4001b2a4: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001b2a8: 80 a7 20 05 cmp %i4, 5 <== NOT EXECUTED
4001b2ac: 12 80 00 13 bne 4001b2f8 <rtems_rfs_block_map_grow+0x1d8> <== NOT EXECUTED
4001b2b0: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
4001b2b4: 32 80 00 12 bne,a 4001b2fc <rtems_rfs_block_map_grow+0x1dc><== NOT EXECUTED
4001b2b8: 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;
4001b2bc: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001b2c0: 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],
4001b2c4: 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;
4001b2c8: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b2cc: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001b2d0: 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,
4001b2d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001b2d8: 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,
4001b2dc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001b2e0: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
4001b2e4: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
4001b2e8: 7f ff fd 6b call 4001a894 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001b2ec: 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)
4001b2f0: 10 80 00 0b b 4001b31c <rtems_rfs_block_map_grow+0x1fc> <== NOT EXECUTED
4001b2f4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001b2f8: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
4001b2fc: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
4001b300: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
4001b304: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
4001b308: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b30c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001b310: 40 00 02 16 call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001b314: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001b318: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001b31c: 24 80 00 08 ble,a 4001b33c <rtems_rfs_block_map_grow+0x21c><== NOT EXECUTED
4001b320: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
4001b324: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4001b328: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b32c: 7f ff da dd call 40011ea0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001b330: 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);
4001b334: 10 80 00 3b b 4001b420 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
4001b338: 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,
4001b33c: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
4001b340: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001b344: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
4001b348: c4 28 40 1c stb %g2, [ %g1 + %i4 ] <== NOT EXECUTED
4001b34c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001b350: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
4001b354: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001b358: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
4001b35c: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
4001b360: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001b364: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
4001b368: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001b36c: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
4001b370: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
4001b374: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
4001b378: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001b37c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001b380: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
4001b384: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001b388: c2 2f 20 03 stb %g1, [ %i4 + 3 ] <== NOT EXECUTED
4001b38c: 10 80 00 2a b 4001b434 <rtems_rfs_block_map_grow+0x314> <== NOT EXECUTED
4001b390: e8 2e 60 44 stb %l4, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001b394: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
4001b398: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
4001b39c: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
4001b3a0: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
4001b3a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b3a8: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001b3ac: 40 00 01 ef call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001b3b0: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
4001b3b4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001b3b8: 24 80 00 04 ble,a 4001b3c8 <rtems_rfs_block_map_grow+0x2a8><== NOT EXECUTED
4001b3bc: 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);
4001b3c0: 10 80 00 18 b 4001b420 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
4001b3c4: 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,
4001b3c8: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
4001b3cc: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b3d0: 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,
4001b3d4: 82 00 80 1c add %g2, %i4, %g1 <== NOT EXECUTED
4001b3d8: d4 08 80 1c ldub [ %g2 + %i4 ], %o2 <== NOT EXECUTED
4001b3dc: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
4001b3e0: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001b3e4: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001b3e8: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED
4001b3ec: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001b3f0: 94 10 c0 0a or %g3, %o2, %o2 <== NOT EXECUTED
4001b3f4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001b3f8: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b3fc: 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,
4001b400: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
4001b404: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b408: 40 00 01 d8 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001b40c: 96 10 20 01 mov 1, %o3
singly_block, true);
if (rc > 0)
4001b410: b0 92 20 00 orcc %o0, 0, %i0
4001b414: 24 80 00 09 ble,a 4001b438 <rtems_rfs_block_map_grow+0x318><== ALWAYS TAKEN
4001b418: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
{
rtems_rfs_group_bitmap_free (fs, false, block);
4001b41c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
4001b420: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b424: 7f ff da 9f call 40011ea0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001b428: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001b42c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b430: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001b434: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
4001b438: c4 0f bf f8 ldub [ %fp + -8 ], %g2
4001b43c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001b440: a5 2c a0 02 sll %l2, 2, %l2
4001b444: c4 28 40 12 stb %g2, [ %g1 + %l2 ]
4001b448: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001b44c: c4 17 bf f8 lduh [ %fp + -8 ], %g2
4001b450: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001b454: 82 00 40 12 add %g1, %l2, %g1
4001b458: c4 28 60 01 stb %g2, [ %g1 + 1 ]
4001b45c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001b460: c4 07 bf f8 ld [ %fp + -8 ], %g2
4001b464: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001b468: 85 30 a0 08 srl %g2, 8, %g2
4001b46c: 82 00 40 12 add %g1, %l2, %g1
4001b470: c4 28 60 02 stb %g2, [ %g1 + 2 ]
4001b474: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001b478: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001b47c: a4 00 40 12 add %g1, %l2, %l2
4001b480: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001b484: c2 2c a0 03 stb %g1, [ %l2 + 3 ]
4001b488: e8 2e 60 38 stb %l4, [ %i1 + 0x38 ]
}
map->size.count++;
4001b48c: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
4001b490: c0 26 60 0c clr [ %i1 + 0xc ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
4001b494: 82 00 60 01 inc %g1
4001b498: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
if (b == 0)
4001b49c: 80 a4 20 00 cmp %l0, 0
4001b4a0: 12 80 00 03 bne 4001b4ac <rtems_rfs_block_map_grow+0x38c> <== NEVER TAKEN
4001b4a4: c2 07 bf f8 ld [ %fp + -8 ], %g1
*new_block = block;
4001b4a8: c2 26 c0 00 st %g1, [ %i3 ]
map->last_data_block = block;
4001b4ac: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
map->dirty = true;
4001b4b0: 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++)
4001b4b4: 10 80 00 05 b 4001b4c8 <rtems_rfs_block_map_grow+0x3a8>
4001b4b8: a0 04 20 01 inc %l0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001b4bc: a8 10 20 01 mov 1, %l4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001b4c0: 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,
4001b4c4: 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++)
4001b4c8: 80 a4 00 1a cmp %l0, %i2
4001b4cc: 32 bf ff 2a bne,a 4001b174 <rtems_rfs_block_map_grow+0x54>
4001b4d0: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
4001b4d4: b0 10 20 00 clr %i0
}
4001b4d8: 81 c7 e0 08 ret
4001b4dc: 81 e8 00 00 restore
4001a894 <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)
{
4001a894: 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);
4001a898: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001a89c: 90 10 00 18 mov %i0, %o0
4001a8a0: 94 10 20 00 clr %o2
4001a8a4: 7f ff dc fb call 40011c90 <rtems_rfs_group_bitmap_alloc>
4001a8a8: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
4001a8ac: ba 92 20 00 orcc %o0, 0, %i5
4001a8b0: 34 80 00 48 bg,a 4001a9d0 <rtems_rfs_block_map_indirect_alloc+0x13c><== NEVER TAKEN
4001a8b4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
4001a8b8: d4 07 bf fc ld [ %fp + -4 ], %o2
4001a8bc: 90 10 00 18 mov %i0, %o0
4001a8c0: 92 10 00 1a mov %i2, %o1
4001a8c4: 40 00 04 a9 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001a8c8: 96 10 20 00 clr %o3
if (rc > 0)
4001a8cc: ba 92 20 00 orcc %o0, 0, %i5
4001a8d0: 04 80 00 07 ble 4001a8ec <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
4001a8d4: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
4001a8d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a8dc: 7f ff dd 71 call 40011ea0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001a8e0: 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;
}
4001a8e4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a8e8: 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));
4001a8ec: c2 06 a0 08 ld [ %i2 + 8 ], %g1
4001a8f0: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001a8f4: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001a8f8: 40 00 1f 0c call 40022528 <memset>
4001a8fc: 92 10 20 ff mov 0xff, %o1
if (upping)
4001a900: 80 a7 20 00 cmp %i4, 0
4001a904: 02 80 00 2d be 4001a9b8 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
4001a908: 82 10 20 01 mov 1, %g1
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001a90c: 90 10 20 00 clr %o0
4001a910: 7f ff e4 be call 40013c08 <rtems_rfs_trace>
4001a914: 13 00 00 08 sethi %hi(0x2000), %o1
4001a918: 80 8a 20 ff btst 0xff, %o0
4001a91c: 02 80 00 07 be 4001a938 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
4001a920: 84 10 00 19 mov %i1, %g2
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
4001a924: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001a928: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001a92c: 40 00 1f 7d call 40022720 <printf> <== NOT EXECUTED
4001a930: 90 12 20 48 or %o0, 0x48, %o0 ! 40035448 <CSWTCH.2+0x8> <== NOT EXECUTED
4001a934: 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)
{
4001a938: 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]);
4001a93c: 86 10 20 01 mov 1, %g3
4001a940: c8 06 a0 08 ld [ %i2 + 8 ], %g4
4001a944: fa 08 a0 24 ldub [ %g2 + 0x24 ], %i5
4001a948: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
4001a94c: fa 29 00 01 stb %i5, [ %g4 + %g1 ]
4001a950: c8 06 a0 08 ld [ %i2 + 8 ], %g4
4001a954: fa 10 a0 24 lduh [ %g2 + 0x24 ], %i5
4001a958: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
4001a95c: 88 01 00 01 add %g4, %g1, %g4
4001a960: fa 29 20 01 stb %i5, [ %g4 + 1 ]
4001a964: c8 06 a0 08 ld [ %i2 + 8 ], %g4
4001a968: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
4001a96c: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
4001a970: bb 37 60 08 srl %i5, 8, %i5
4001a974: 88 01 00 01 add %g4, %g1, %g4
4001a978: fa 29 20 02 stb %i5, [ %g4 + 2 ]
4001a97c: c8 06 a0 08 ld [ %i2 + 8 ], %g4
4001a980: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
4001a984: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
4001a988: 84 00 a0 04 add %g2, 4, %g2
4001a98c: 88 01 00 01 add %g4, %g1, %g4
4001a990: fa 29 20 03 stb %i5, [ %g4 + 3 ]
4001a994: 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++)
4001a998: 80 a0 60 14 cmp %g1, 0x14
4001a99c: 12 bf ff e9 bne 4001a940 <rtems_rfs_block_map_indirect_alloc+0xac>
4001a9a0: c6 2e 80 00 stb %g3, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
4001a9a4: 90 06 60 24 add %i1, 0x24, %o0
4001a9a8: 92 10 20 00 clr %o1
4001a9ac: 40 00 1e df call 40022528 <memset>
4001a9b0: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
4001a9b4: 82 10 20 01 mov 1, %g1
4001a9b8: c2 2e 80 00 stb %g1, [ %i2 ]
*block = new_block;
4001a9bc: c2 07 bf fc ld [ %fp + -4 ], %g1
map->last_map_block = new_block;
return 0;
4001a9c0: 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;
4001a9c4: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
4001a9c8: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
}
4001a9cc: b0 10 00 1d mov %i5, %i0
4001a9d0: 81 c7 e0 08 ret
4001a9d4: 81 e8 00 00 restore
4001a7b4 <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)
{
4001a7b4: 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) ||
4001a7b8: 80 a7 20 00 cmp %i4, 0
4001a7bc: 02 80 00 09 be 4001a7e0 <rtems_rfs_block_map_indirect_shrink+0x2c><== NEVER TAKEN
4001a7c0: 82 06 e0 08 add %i3, 8, %g1
4001a7c4: 80 a7 20 05 cmp %i4, 5
4001a7c8: 32 80 00 2f bne,a 4001a884 <rtems_rfs_block_map_indirect_shrink+0xd0>
4001a7cc: b0 10 20 00 clr %i0
4001a7d0: 80 a6 e0 00 cmp %i3, 0
4001a7d4: 32 80 00 2c bne,a 4001a884 <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
4001a7d8: 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];
4001a7dc: 82 06 e0 08 add %i3, 8, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
4001a7e0: 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];
4001a7e4: 83 28 60 02 sll %g1, 2, %g1
4001a7e8: 82 06 40 01 add %i1, %g1, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
4001a7ec: 12 80 00 1a bne 4001a854 <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
4001a7f0: fa 00 60 04 ld [ %g1 + 4 ], %i5
4001a7f4: 80 a6 e0 00 cmp %i3, 0
4001a7f8: 32 80 00 18 bne,a 4001a858 <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
4001a7fc: 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);
4001a800: c2 06 a0 08 ld [ %i2 + 8 ], %g1
4001a804: 84 10 20 00 clr %g2
4001a808: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001a80c: f8 08 40 00 ldub [ %g1 ], %i4
4001a810: c8 08 60 01 ldub [ %g1 + 1 ], %g4
4001a814: b9 2f 20 18 sll %i4, 0x18, %i4
4001a818: 89 29 20 10 sll %g4, 0x10, %g4
4001a81c: 88 17 00 04 or %i4, %g4, %g4
4001a820: 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,
4001a824: 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);
4001a828: 88 11 00 1c or %g4, %i4, %g4
4001a82c: f8 08 60 02 ldub [ %g1 + 2 ], %i4
4001a830: 84 00 a0 04 add %g2, 4, %g2
4001a834: b9 2f 20 08 sll %i4, 8, %i4
4001a838: 88 11 00 1c or %g4, %i4, %g4
4001a83c: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001a840: 80 a0 a0 14 cmp %g2, 0x14
4001a844: 12 bf ff f2 bne 4001a80c <rtems_rfs_block_map_indirect_shrink+0x58>
4001a848: 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);
4001a84c: 10 80 00 07 b 4001a868 <rtems_rfs_block_map_indirect_shrink+0xb4>
4001a850: 90 10 00 18 mov %i0, %o0
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
4001a854: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
4001a858: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
4001a85c: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
4001a860: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001a864: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a868: 92 10 20 00 clr %o1
4001a86c: 7f ff dd 8d call 40011ea0 <rtems_rfs_group_bitmap_free>
4001a870: 94 10 00 1d mov %i5, %o2
if (rc > 0)
4001a874: b0 92 20 00 orcc %o0, 0, %i0
4001a878: 14 80 00 05 bg 4001a88c <rtems_rfs_block_map_indirect_shrink+0xd8><== NEVER TAKEN
4001a87c: 01 00 00 00 nop
return rc;
map->last_map_block = block_to_free;
4001a880: fa 26 60 1c st %i5, [ %i1 + 0x1c ]
4001a884: 81 c7 e0 08 ret
4001a888: 81 e8 00 00 restore
}
return rc;
}
4001a88c: 81 c7 e0 08 ret <== NOT EXECUTED
4001a890: 81 e8 00 00 restore <== NOT EXECUTED
4001abb4 <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)
{
4001abb4: 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;
4001abb8: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
4001abbc: 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;
4001abc0: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
4001abc4: 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;
4001abc8: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
4001abcc: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
4001abd0: 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;
4001abd4: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
4001abd8: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
4001abdc: 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;
4001abe0: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
4001abe4: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
4001abe8: 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);
4001abec: 90 10 00 18 mov %i0, %o0
4001abf0: 7f ff dd 50 call 40012130 <rtems_rfs_inode_load>
4001abf4: 92 10 00 19 mov %i1, %o1
if (rc > 0)
4001abf8: ba 92 20 00 orcc %o0, 0, %i5
4001abfc: 14 80 00 40 bg 4001acfc <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
4001ac00: 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]);
4001ac04: 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;
4001ac08: f2 26 a0 04 st %i1, [ %i2 + 4 ]
4001ac0c: 88 00 a0 06 add %g2, 6, %g4
4001ac10: 89 29 20 02 sll %g4, 2, %g4
4001ac14: 88 00 40 04 add %g1, %g4, %g4
4001ac18: 86 01 20 04 add %g4, 4, %g3
4001ac1c: f8 09 20 04 ldub [ %g4 + 4 ], %i4
4001ac20: c8 09 20 05 ldub [ %g4 + 5 ], %g4
4001ac24: b9 2f 20 18 sll %i4, 0x18, %i4
4001ac28: 89 29 20 10 sll %g4, 0x10, %g4
4001ac2c: b8 17 00 04 or %i4, %g4, %i4
4001ac30: 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,
4001ac34: bb 28 a0 02 sll %g2, 2, %i5
4001ac38: b8 17 00 04 or %i4, %g4, %i4
4001ac3c: c8 08 e0 02 ldub [ %g3 + 2 ], %g4
4001ac40: ba 06 80 1d add %i2, %i5, %i5
4001ac44: 89 29 20 08 sll %g4, 8, %g4
4001ac48: 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++)
4001ac4c: 84 00 a0 01 inc %g2
4001ac50: 80 a0 a0 05 cmp %g2, 5
4001ac54: 12 bf ff ee bne 4001ac0c <rtems_rfs_block_map_open+0x58>
4001ac58: 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);
4001ac5c: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
4001ac60: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
4001ac64: 87 28 e0 18 sll %g3, 0x18, %g3
4001ac68: 85 28 a0 10 sll %g2, 0x10, %g2
4001ac6c: 84 10 c0 02 or %g3, %g2, %g2
4001ac70: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
4001ac74: 84 10 80 03 or %g2, %g3, %g2
4001ac78: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
4001ac7c: 87 28 e0 08 sll %g3, 8, %g3
4001ac80: 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);
4001ac84: c4 26 a0 08 st %g2, [ %i2 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
4001ac88: 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);
4001ac8c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001ac90: 85 28 a0 08 sll %g2, 8, %g2
4001ac94: 84 10 c0 02 or %g3, %g2, %g2
4001ac98: 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);
4001ac9c: c6 08 60 30 ldub [ %g1 + 0x30 ], %g3
4001aca0: c4 08 60 31 ldub [ %g1 + 0x31 ], %g2
4001aca4: 87 28 e0 18 sll %g3, 0x18, %g3
4001aca8: 85 28 a0 10 sll %g2, 0x10, %g2
4001acac: 84 10 c0 02 or %g3, %g2, %g2
4001acb0: c6 08 60 33 ldub [ %g1 + 0x33 ], %g3
4001acb4: 84 10 80 03 or %g2, %g3, %g2
4001acb8: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
4001acbc: 87 28 e0 08 sll %g3, 8, %g3
4001acc0: 84 10 80 03 or %g2, %g3, %g2
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
4001acc4: 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);
4001acc8: c4 08 60 35 ldub [ %g1 + 0x35 ], %g2
4001accc: c6 08 60 34 ldub [ %g1 + 0x34 ], %g3
4001acd0: 85 28 a0 10 sll %g2, 0x10, %g2
4001acd4: 87 28 e0 18 sll %g3, 0x18, %g3
4001acd8: 86 10 c0 02 or %g3, %g2, %g3
4001acdc: c4 08 60 37 ldub [ %g1 + 0x37 ], %g2
4001ace0: 86 10 c0 02 or %g3, %g2, %g3
4001ace4: c4 08 60 36 ldub [ %g1 + 0x36 ], %g2
4001ace8: 85 28 a0 08 sll %g2, 8, %g2
4001acec: 82 10 c0 02 or %g3, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
4001acf0: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
4001acf4: 7f ff dd 72 call 400122bc <rtems_rfs_inode_unload>
4001acf8: 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);
4001acfc: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
4001ad00: 40 00 03 26 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ad04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ad08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001ad0c: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
4001ad10: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
4001ad14: 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);
4001ad18: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
4001ad1c: 40 00 03 1f call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ad20: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
handle->dirty = false;
4001ad24: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
4001ad28: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
4001ad2c: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
4001ad30: 81 c7 e0 08 ret <== NOT EXECUTED
4001ad34: 81 e8 00 00 restore <== NOT EXECUTED
4001b4e0 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
4001b4e0: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
4001b4e4: 90 10 20 00 clr %o0
4001b4e8: 7f ff e1 c8 call 40013c08 <rtems_rfs_trace>
4001b4ec: 13 00 00 10 sethi %hi(0x4000), %o1
4001b4f0: 80 8a 20 ff btst 0xff, %o0
4001b4f4: 22 80 00 08 be,a 4001b514 <rtems_rfs_block_map_shrink+0x34><== ALWAYS TAKEN
4001b4f8: c2 06 60 08 ld [ %i1 + 8 ], %g1
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
4001b4fc: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
4001b500: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001b504: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001b508: 40 00 1c 86 call 40022720 <printf> <== NOT EXECUTED
4001b50c: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
4001b510: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4001b514: 80 a0 60 00 cmp %g1, 0
4001b518: 12 80 00 04 bne 4001b528 <rtems_rfs_block_map_shrink+0x48>
4001b51c: 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;
4001b520: 10 80 00 b8 b 4001b800 <rtems_rfs_block_map_shrink+0x320>
4001b524: 90 10 20 00 clr %o0
4001b528: 38 80 00 90 bgu,a 4001b768 <rtems_rfs_block_map_shrink+0x288><== NEVER TAKEN
4001b52c: 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,
4001b530: 10 80 00 8f b 4001b76c <rtems_rfs_block_map_shrink+0x28c>
4001b534: 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;
4001b538: ba 00 7f ff add %g1, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
4001b53c: 80 a7 60 04 cmp %i5, 4
4001b540: 38 80 00 08 bgu,a 4001b560 <rtems_rfs_block_map_shrink+0x80>
4001b544: 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];
4001b548: 82 00 60 07 add %g1, 7, %g1
4001b54c: 83 28 60 02 sll %g1, 2, %g1
4001b550: 82 06 40 01 add %i1, %g1, %g1
4001b554: fa 00 60 04 ld [ %g1 + 4 ], %i5
map->blocks[block] = 0;
4001b558: 10 80 00 76 b 4001b730 <rtems_rfs_block_map_shrink+0x250>
4001b55c: 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;
4001b560: 90 10 00 1d mov %i5, %o0
4001b564: 40 00 4e 27 call 4002ee00 <.urem>
4001b568: 92 10 00 1b mov %i3, %o1
singly = block / fs->blocks_per_block;
4001b56c: 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;
4001b570: b8 10 00 08 mov %o0, %i4
singly = block / fs->blocks_per_block;
4001b574: 7f ff 9c 42 call 4000267c <.udiv>
4001b578: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
4001b57c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001b580: 80 a7 40 01 cmp %i5, %g1
4001b584: 1a 80 00 20 bcc 4001b604 <rtems_rfs_block_map_shrink+0x124><== NEVER TAKEN
4001b588: 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,
4001b58c: 82 02 20 08 add %o0, 8, %g1
4001b590: 83 28 60 02 sll %g1, 2, %g1
4001b594: 82 06 40 01 add %i1, %g1, %g1
4001b598: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001b59c: 90 10 00 18 mov %i0, %o0
4001b5a0: 92 10 00 10 mov %l0, %o1
4001b5a4: 40 00 01 71 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001b5a8: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
4001b5ac: 80 a2 20 00 cmp %o0, 0
4001b5b0: 14 80 00 94 bg 4001b800 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001b5b4: 85 2f 20 02 sll %i4, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001b5b8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001b5bc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001b5c0: 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,
4001b5c4: 82 00 c0 02 add %g3, %g2, %g1
4001b5c8: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
4001b5cc: c8 08 60 03 ldub [ %g1 + 3 ], %g4
4001b5d0: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001b5d4: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001b5d8: bb 2f 60 18 sll %i5, 0x18, %i5
4001b5dc: 85 28 a0 10 sll %g2, 0x10, %g2
4001b5e0: ba 11 00 1d or %g4, %i5, %i5
4001b5e4: 83 28 60 08 sll %g1, 8, %g1
4001b5e8: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001b5ec: 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,
4001b5f0: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001b5f4: 94 10 00 10 mov %l0, %o2
4001b5f8: 96 10 00 11 mov %l1, %o3
4001b5fc: 10 80 00 48 b 4001b71c <rtems_rfs_block_map_shrink+0x23c>
4001b600: 98 10 00 1c mov %i4, %o4
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
4001b604: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
4001b608: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4001b60c: 3a 80 00 5d bcc,a 4001b780 <rtems_rfs_block_map_shrink+0x2a0><== NOT EXECUTED
4001b610: 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;
4001b614: 7f ff 9c 1a call 4000267c <.udiv> <== NOT EXECUTED
4001b618: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001b61c: 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;
4001b620: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001b624: 40 00 4d f7 call 4002ee00 <.urem> <== NOT EXECUTED
4001b628: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001b62c: 82 05 20 08 add %l4, 8, %g1 <== NOT EXECUTED
4001b630: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001b634: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001b638: 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;
4001b63c: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001b640: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
4001b644: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b648: 40 00 01 48 call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001b64c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001b650: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b654: 14 80 00 6b bg 4001b800 <rtems_rfs_block_map_shrink+0x320><== NOT EXECUTED
4001b658: 85 2c 60 02 sll %l1, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b65c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001b660: 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,
4001b664: 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,
4001b668: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001b66c: f6 08 c0 02 ldub [ %g3 + %g2 ], %i3 <== NOT EXECUTED
4001b670: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
4001b674: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001b678: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001b67c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001b680: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001b684: 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,
4001b688: 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,
4001b68c: 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,
4001b690: 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,
4001b694: b6 16 c0 02 or %i3, %g2, %i3 <== NOT EXECUTED
4001b698: 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,
4001b69c: 40 00 01 33 call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001b6a0: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
4001b6a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b6a8: 14 80 00 56 bg 4001b800 <rtems_rfs_block_map_shrink+0x320><== NOT EXECUTED
4001b6ac: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001b6b0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
4001b6b4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
4001b6b8: 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,
4001b6bc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001b6c0: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED
4001b6c4: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
4001b6c8: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001b6cc: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001b6d0: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED
4001b6d4: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001b6d8: ba 11 00 1d or %g4, %i5, %i5 <== NOT EXECUTED
4001b6dc: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001b6e0: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
4001b6e4: 12 80 00 13 bne 4001b730 <rtems_rfs_block_map_shrink+0x250><== NOT EXECUTED
4001b6e8: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
4001b6ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b6f0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001b6f4: 7f ff d9 eb call 40011ea0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001b6f8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
if (rc > 0)
4001b6fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b700: 14 80 00 40 bg 4001b800 <rtems_rfs_block_map_shrink+0x320><== NOT EXECUTED
4001b704: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
4001b708: f6 26 60 1c st %i3, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001b70c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b710: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001b714: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001b718: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
4001b71c: 7f ff fc 26 call 4001a7b4 <rtems_rfs_block_map_indirect_shrink>
4001b720: 01 00 00 00 nop
doubly, doubly_singly);
if (rc)
4001b724: 80 a2 20 00 cmp %o0, 0
4001b728: 12 80 00 36 bne 4001b800 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001b72c: 01 00 00 00 nop
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001b730: 90 10 00 18 mov %i0, %o0
4001b734: 92 10 20 00 clr %o1
4001b738: 7f ff d9 da call 40011ea0 <rtems_rfs_group_bitmap_free>
4001b73c: 94 10 00 1d mov %i5, %o2
if (rc > 0)
4001b740: 80 a2 20 00 cmp %o0, 0
4001b744: 14 80 00 2f bg 4001b800 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001b748: b4 06 bf ff add %i2, -1, %i2
return rc;
map->size.count--;
4001b74c: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
4001b750: 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--;
4001b754: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
map->last_data_block = block_to_free;
4001b758: 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--;
4001b75c: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
4001b760: 10 80 00 05 b 4001b774 <rtems_rfs_block_map_shrink+0x294>
4001b764: 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,
4001b768: 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,
4001b76c: 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;
4001b770: a6 10 20 01 mov 1, %l3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001b774: 80 a6 a0 00 cmp %i2, 0
4001b778: 12 bf ff 70 bne 4001b538 <rtems_rfs_block_map_shrink+0x58>
4001b77c: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
4001b780: 80 a0 60 00 cmp %g1, 0
4001b784: 32 80 00 05 bne,a 4001b798 <rtems_rfs_block_map_shrink+0x2b8>
4001b788: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
{
map->last_map_block = 0;
4001b78c: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
4001b790: c0 26 60 20 clr [ %i1 + 0x20 ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
4001b794: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4001b798: 80 a0 a0 00 cmp %g2, 0
4001b79c: 02 80 00 06 be 4001b7b4 <rtems_rfs_block_map_shrink+0x2d4>
4001b7a0: 80 a0 80 01 cmp %g2, %g1
4001b7a4: 80 a0 60 00 cmp %g1, 0
4001b7a8: 22 80 00 0e be,a 4001b7e0 <rtems_rfs_block_map_shrink+0x300><== ALWAYS TAKEN
4001b7ac: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001b7b0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4001b7b4: 3a 80 00 0b bcc,a 4001b7e0 <rtems_rfs_block_map_shrink+0x300>
4001b7b8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001b7bc: 86 00 7f ff add %g1, -1, %g3
4001b7c0: 80 a0 80 03 cmp %g2, %g3
4001b7c4: 12 80 00 0f bne 4001b800 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001b7c8: 90 10 20 00 clr %o0
4001b7cc: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
4001b7d0: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001b7d4: 80 a0 c0 02 cmp %g3, %g2
4001b7d8: 08 80 00 0a bleu 4001b800 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
4001b7dc: 01 00 00 00 nop
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
4001b7e0: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
4001b7e4: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
4001b7e8: 80 a0 a0 00 cmp %g2, 0
4001b7ec: 02 80 00 04 be 4001b7fc <rtems_rfs_block_map_shrink+0x31c><== ALWAYS TAKEN
4001b7f0: c0 26 60 18 clr [ %i1 + 0x18 ]
4001b7f4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4001b7f8: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
4001b7fc: 90 10 20 00 clr %o0
}
4001b800: 81 c7 e0 08 ret
4001b804: 91 e8 00 08 restore %g0, %o0, %o0
40020d50 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
40020d50: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
40020d54: 90 10 20 00 clr %o0
40020d58: 7f ff cb ac call 40013c08 <rtems_rfs_trace>
40020d5c: 92 10 20 40 mov 0x40, %o1
40020d60: 80 8a 20 ff btst 0xff, %o0
40020d64: 02 80 00 0e be 40020d9c <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
40020d68: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40020d6c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
40020d70: 02 80 00 05 be 40020d84 <rtems_rfs_buffer_bdbuf_release+0x34><== NOT EXECUTED
40020d74: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
40020d78: 17 10 00 da sethi %hi(0x40036800), %o3 <== NOT EXECUTED
40020d7c: 10 80 00 04 b 40020d8c <rtems_rfs_buffer_bdbuf_release+0x3c><== NOT EXECUTED
40020d80: 96 12 e3 68 or %o3, 0x368, %o3 ! 40036b68 <rtems_rfs_rtems_file_handlers+0x2c><== NOT EXECUTED
40020d84: 17 10 00 d8 sethi %hi(0x40036000), %o3 <== NOT EXECUTED
40020d88: 96 12 e3 b0 or %o3, 0x3b0, %o3 ! 400363b0 <CSWTCH.2+0xf70><== NOT EXECUTED
40020d8c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
40020d90: 40 00 06 64 call 40022720 <printf> <== NOT EXECUTED
40020d94: 90 12 23 78 or %o0, 0x378, %o0 ! 40036b78 <rtems_rfs_rtems_file_handlers+0x3c><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
40020d98: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40020d9c: 02 80 00 06 be 40020db4 <rtems_rfs_buffer_bdbuf_release+0x64>
40020da0: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
40020da4: 7f ff d4 96 call 40015ffc <rtems_bdbuf_release_modified>
40020da8: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
40020dac: 10 80 00 05 b 40020dc0 <rtems_rfs_buffer_bdbuf_release+0x70>
40020db0: 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);
40020db4: 7f ff d4 5d call 40015f28 <rtems_bdbuf_release>
40020db8: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
40020dbc: 80 a0 00 08 cmp %g0, %o0
40020dc0: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
40020dc4: b0 0e 20 05 and %i0, 5, %i0
40020dc8: 81 c7 e0 08 ret
40020dcc: 81 e8 00 00 restore
40020dd0: 40 02 0f dc call 400a4d40 <__end+0x5b9a0> <== NOT EXECUTED
40020dd4: 40 02 0f d0 call 400a4d14 <__end+0x5b974> <== NOT EXECUTED
40020dd8: 40 02 0f c4 call 400a4ce8 <__end+0x5b948> <== NOT EXECUTED
40020ddc: 40 02 0f b8 call 400a4cbc <__end+0x5b91c> <== NOT EXECUTED
40020de0: 40 02 0f b0 call 400a4ca0 <__end+0x5b900> <== NOT EXECUTED
40020de4: 40 02 0f a4 call 400a4c74 <__end+0x5b8d4> <== NOT EXECUTED
40020de8: 40 02 0f 98 call 400a4c48 <__end+0x5b8a8> <== NOT EXECUTED
40020dec: 40 02 0f 8c call 400a4c1c <__end+0x5b87c> <== NOT EXECUTED
40020df0: 40 02 0f 84 call 400a4c00 <__end+0x5b860> <== NOT EXECUTED
40020df4: 40 02 0f 78 call 400a4bd4 <__end+0x5b834> <== NOT EXECUTED
40020df8: 40 02 0f 6c call 400a4ba8 <__end+0x5b808> <== NOT EXECUTED
40020dfc: 40 02 0f 60 call 400a4b7c <__end+0x5b7dc> <== NOT EXECUTED
4001c16c <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
4001c16c: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c170: 90 10 20 00 clr %o0
4001c174: 7f ff de a5 call 40013c08 <rtems_rfs_trace>
4001c178: 92 10 20 10 mov 0x10, %o1
4001c17c: 80 8a 20 ff btst 0xff, %o0
4001c180: 22 80 00 06 be,a 4001c198 <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
4001c184: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
printf ("rtems-rfs: buffer-close: closing\n");
4001c188: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c18c: 40 00 19 fd call 40022980 <puts> <== NOT EXECUTED
4001c190: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400359e0 <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));
4001c194: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
4001c198: 90 10 00 18 mov %i0, %o0
4001c19c: 7f ff ff b9 call 4001c080 <rtems_rfs_buffer_setblksize>
4001c1a0: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c1a4: ba 92 20 00 orcc %o0, 0, %i5
4001c1a8: 04 80 00 0e ble 4001c1e0 <rtems_rfs_buffer_close+0x74> <== ALWAYS TAKEN
4001c1ac: 90 10 20 00 clr %o0
4001c1b0: 7f ff de 96 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c1b4: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
4001c1b8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c1bc: 02 80 00 09 be 4001c1e0 <rtems_rfs_buffer_close+0x74> <== NOT EXECUTED
4001c1c0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
4001c1c4: 40 00 1d c3 call 400238d0 <strerror> <== NOT EXECUTED
4001c1c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c1cc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c1d0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001c1d4: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c1d8: 40 00 19 52 call 40022720 <printf> <== NOT EXECUTED
4001c1dc: 90 12 22 08 or %o0, 0x208, %o0 ! 40035a08 <CSWTCH.2+0x5c8><== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
4001c1e0: 7f ff b1 4e call 40008718 <close>
4001c1e4: d0 06 20 0c ld [ %i0 + 0xc ], %o0
4001c1e8: 80 a2 20 00 cmp %o0, 0
4001c1ec: 16 80 00 12 bge 4001c234 <rtems_rfs_buffer_close+0xc8> <== ALWAYS TAKEN
4001c1f0: 01 00 00 00 nop
{
rc = errno;
4001c1f4: 40 00 13 f2 call 400211bc <__errno> <== NOT EXECUTED
4001c1f8: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c1fc: 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;
4001c200: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c204: 7f ff de 81 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c208: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c20c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c210: 02 80 00 09 be 4001c234 <rtems_rfs_buffer_close+0xc8> <== NOT EXECUTED
4001c214: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
4001c218: 40 00 1d ae call 400238d0 <strerror> <== NOT EXECUTED
4001c21c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c220: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c224: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001c228: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c22c: 40 00 19 3d call 40022720 <printf> <== NOT EXECUTED
4001c230: 90 12 22 48 or %o0, 0x248, %o0 ! 40035a48 <CSWTCH.2+0x608><== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
4001c234: 81 c7 e0 08 ret
4001c238: 91 e8 00 1d restore %g0, %i5, %o0
4001b998 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
4001b998: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
4001b99c: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
4001b9a0: ba 10 00 18 mov %i0, %i5
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
4001b9a4: 80 a0 60 00 cmp %g1, 0
4001b9a8: 02 80 00 6e be 4001bb60 <rtems_rfs_buffer_handle_release+0x1c8>
4001b9ac: b0 10 20 00 clr %i0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001b9b0: 90 10 20 00 clr %o0
4001b9b4: 7f ff e0 95 call 40013c08 <rtems_rfs_trace>
4001b9b8: 92 10 22 00 mov 0x200, %o1
4001b9bc: 80 8a 20 ff btst 0xff, %o0
4001b9c0: 22 80 00 18 be,a 4001ba20 <rtems_rfs_buffer_handle_release+0x88><== ALWAYS TAKEN
4001b9c4: d0 06 60 08 ld [ %i1 + 8 ], %o0
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001b9c8: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
4001b9cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001b9d0: 02 80 00 05 be 4001b9e4 <rtems_rfs_buffer_handle_release+0x4c><== NOT EXECUTED
4001b9d4: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
4001b9d8: 15 10 00 d5 sethi %hi(0x40035400), %o2 <== NOT EXECUTED
4001b9dc: 10 80 00 04 b 4001b9ec <rtems_rfs_buffer_handle_release+0x54><== NOT EXECUTED
4001b9e0: 94 12 a1 d0 or %o2, 0x1d0, %o2 ! 400355d0 <CSWTCH.2+0x190><== NOT EXECUTED
4001b9e4: 15 10 00 d8 sethi %hi(0x40036000), %o2 <== NOT EXECUTED
4001b9e8: 94 12 a3 b0 or %o2, 0x3b0, %o2 ! 400363b0 <CSWTCH.2+0xf70><== 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" : "");
4001b9ec: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4001b9f0: 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",
4001b9f4: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4001b9f8: 32 80 00 05 bne,a 4001ba0c <rtems_rfs_buffer_handle_release+0x74><== NOT EXECUTED
4001b9fc: 19 10 00 d8 sethi %hi(0x40036000), %o4 <== NOT EXECUTED
4001ba00: 19 10 00 d5 sethi %hi(0x40035400), %o4 <== NOT EXECUTED
4001ba04: 10 80 00 03 b 4001ba10 <rtems_rfs_buffer_handle_release+0x78><== NOT EXECUTED
4001ba08: 98 13 21 d8 or %o4, 0x1d8, %o4 ! 400355d8 <CSWTCH.2+0x198><== NOT EXECUTED
4001ba0c: 98 13 23 b0 or %o4, 0x3b0, %o4 <== NOT EXECUTED
4001ba10: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001ba14: 40 00 1b 43 call 40022720 <printf> <== NOT EXECUTED
4001ba18: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 400355e8 <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)
4001ba1c: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
4001ba20: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4001ba24: 80 a0 60 00 cmp %g1, 0
4001ba28: 04 80 00 03 ble 4001ba34 <rtems_rfs_buffer_handle_release+0x9c><== NEVER TAKEN
4001ba2c: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_buffer_refs_down (handle);
4001ba30: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
4001ba34: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4001ba38: 80 a0 60 00 cmp %g1, 0
4001ba3c: 12 80 00 48 bne 4001bb5c <rtems_rfs_buffer_handle_release+0x1c4>
4001ba40: b0 10 20 00 clr %i0
4001ba44: 7f ff f3 dc call 400189b4 <_Chain_Extract>
4001ba48: 01 00 00 00 nop
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
4001ba4c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (rtems_rfs_fs_no_local_cache (fs))
4001ba50: 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--;
4001ba54: 82 00 7f ff add %g1, -1, %g1
if (rtems_rfs_fs_no_local_cache (fs))
4001ba58: b0 8e 20 02 andcc %i0, 2, %i0
4001ba5c: 02 80 00 08 be 4001ba7c <rtems_rfs_buffer_handle_release+0xe4>
4001ba60: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
{
handle->buffer->user = (void*) 0;
4001ba64: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
4001ba68: d2 0e 40 00 ldub [ %i1 ], %o1
4001ba6c: 40 00 14 b9 call 40020d50 <rtems_rfs_buffer_bdbuf_release>
4001ba70: c0 22 20 34 clr [ %o0 + 0x34 ]
4001ba74: 10 80 00 3a b 4001bb5c <rtems_rfs_buffer_handle_release+0x1c4>
4001ba78: 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 +
4001ba7c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001ba80: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
4001ba84: 84 00 80 01 add %g2, %g1, %g2
4001ba88: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
4001ba8c: 80 a0 80 01 cmp %g2, %g1
4001ba90: 2a 80 00 25 bcs,a 4001bb24 <rtems_rfs_buffer_handle_release+0x18c>
4001ba94: 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))
4001ba98: 90 10 20 00 clr %o0
4001ba9c: 7f ff e0 5b call 40013c08 <rtems_rfs_trace>
4001baa0: 92 10 22 00 mov 0x200, %o1
4001baa4: 80 8a 20 ff btst 0xff, %o0
4001baa8: 22 80 00 09 be,a 4001bacc <rtems_rfs_buffer_handle_release+0x134><== ALWAYS TAKEN
4001baac: c4 07 60 60 ld [ %i5 + 0x60 ], %g2
printf ("rtems-rfs: buffer-release: local cache overflow:"
4001bab0: d2 07 60 70 ld [ %i5 + 0x70 ], %o1 <== NOT EXECUTED
4001bab4: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
4001bab8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001babc: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
4001bac0: 40 00 1b 18 call 40022720 <printf> <== NOT EXECUTED
4001bac4: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
4001bac8: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
4001bacc: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001bad0: 80 a0 80 01 cmp %g2, %g1
4001bad4: 08 80 00 09 bleu 4001baf8 <rtems_rfs_buffer_handle_release+0x160>
4001bad8: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4001badc: 7f ff c8 5b call 4000dc48 <_Chain_Get>
4001bae0: 90 07 60 54 add %i5, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
4001bae4: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
modified = false;
4001bae8: 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--;
4001baec: 82 00 7f ff add %g1, -1, %g1
4001baf0: 10 80 00 08 b 4001bb10 <rtems_rfs_buffer_handle_release+0x178>
4001baf4: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
4001baf8: 7f ff c8 54 call 4000dc48 <_Chain_Get>
4001bafc: 90 07 60 64 add %i5, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001bb00: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
modified = true;
4001bb04: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001bb08: 82 00 7f ff add %g1, -1, %g1
4001bb0c: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
modified = true;
}
buffer->user = (void*) 0;
4001bb10: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001bb14: 40 00 14 8f call 40020d50 <rtems_rfs_buffer_bdbuf_release>
4001bb18: 92 0a 60 01 and %o1, 1, %o1
4001bb1c: b0 10 00 08 mov %o0, %i0
}
if (rtems_rfs_buffer_dirty (handle))
4001bb20: c2 0e 40 00 ldub [ %i1 ], %g1
4001bb24: 80 a0 60 00 cmp %g1, 0
4001bb28: 02 80 00 08 be 4001bb48 <rtems_rfs_buffer_handle_release+0x1b0>
4001bb2c: 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 );
4001bb30: 7f ff c8 3a call 4000dc18 <_Chain_Append>
4001bb34: 90 07 60 64 add %i5, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
4001bb38: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001bb3c: 82 00 60 01 inc %g1
4001bb40: 10 80 00 07 b 4001bb5c <rtems_rfs_buffer_handle_release+0x1c4>
4001bb44: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
4001bb48: 7f ff c8 34 call 4000dc18 <_Chain_Append>
4001bb4c: 90 07 60 54 add %i5, 0x54, %o0
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
4001bb50: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001bb54: 82 00 60 01 inc %g1
4001bb58: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
}
}
}
handle->buffer = NULL;
4001bb5c: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
4001bb60: 81 c7 e0 08 ret
4001bb64: 81 e8 00 00 restore
4001bb68 <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)
{
4001bb68: 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))
4001bb6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bb70: 80 a0 60 00 cmp %g1, 0
4001bb74: 02 80 00 1a be 4001bbdc <rtems_rfs_buffer_handle_request+0x74>
4001bb78: 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))
4001bb7c: 80 a6 a0 00 cmp %i2, 0
4001bb80: 02 80 00 06 be 4001bb98 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
4001bb84: 90 10 20 00 clr %o0
4001bb88: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001bb8c: 80 a0 40 1a cmp %g1, %i2
4001bb90: 02 80 00 75 be 4001bd64 <rtems_rfs_buffer_handle_request+0x1fc>
4001bb94: b0 10 20 00 clr %i0
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bb98: 7f ff e0 1c call 40013c08 <rtems_rfs_trace>
4001bb9c: 92 10 21 00 mov 0x100, %o1
4001bba0: 80 8a 20 ff btst 0xff, %o0
4001bba4: 22 80 00 07 be,a 4001bbc0 <rtems_rfs_buffer_handle_request+0x58><== ALWAYS TAKEN
4001bba8: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
4001bbac: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
4001bbb0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001bbb4: 40 00 1a db call 40022720 <printf> <== NOT EXECUTED
4001bbb8: 90 12 22 60 or %o0, 0x260, %o0 ! 40035660 <CSWTCH.2+0x220><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
4001bbbc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001bbc0: 7f ff ff 76 call 4001b998 <rtems_rfs_buffer_handle_release>
4001bbc4: 92 10 00 19 mov %i1, %o1
if (rc > 0)
4001bbc8: b0 92 20 00 orcc %o0, 0, %i0
4001bbcc: 14 80 00 8b bg 4001bdf8 <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
4001bbd0: 01 00 00 00 nop
return rc;
handle->dirty = false;
4001bbd4: c0 2e 40 00 clrb [ %i1 ]
handle->bnum = 0;
4001bbd8: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bbdc: 90 10 20 00 clr %o0
4001bbe0: 7f ff e0 0a call 40013c08 <rtems_rfs_trace>
4001bbe4: 92 10 21 00 mov 0x100, %o1
4001bbe8: 80 8a 20 ff btst 0xff, %o0
4001bbec: 22 80 00 07 be,a 4001bc08 <rtems_rfs_buffer_handle_request+0xa0><== ALWAYS TAKEN
4001bbf0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
4001bbf4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001bbf8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001bbfc: 40 00 1a c9 call 40022720 <printf> <== NOT EXECUTED
4001bc00: 90 12 22 98 or %o0, 0x298, %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)
4001bc04: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
4001bc08: 80 a0 60 00 cmp %g1, 0
4001bc0c: 22 80 00 16 be,a 4001bc64 <rtems_rfs_buffer_handle_request+0xfc>
4001bc10: c2 07 40 00 ld [ %i5 ], %g1
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4001bc14: 90 07 60 44 add %i5, 0x44, %o0
4001bc18: 92 07 60 50 add %i5, 0x50, %o1
4001bc1c: 7f ff ff 22 call 4001b8a4 <rtems_rfs_scan_chain>
4001bc20: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
4001bc24: 80 a2 20 00 cmp %o0, 0
4001bc28: 02 80 00 0e be 4001bc60 <rtems_rfs_buffer_handle_request+0xf8>
4001bc2c: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bc30: 90 10 20 00 clr %o0
4001bc34: 7f ff df f5 call 40013c08 <rtems_rfs_trace>
4001bc38: 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) &&
4001bc3c: 80 8a 20 ff btst 0xff, %o0
4001bc40: 22 80 00 09 be,a 4001bc64 <rtems_rfs_buffer_handle_request+0xfc><== ALWAYS TAKEN
4001bc44: 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);
4001bc48: 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",
4001bc4c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001bc50: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
4001bc54: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
4001bc58: 40 00 1a b2 call 40022720 <printf> <== NOT EXECUTED
4001bc5c: 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) &&
4001bc60: c2 07 40 00 ld [ %i5 ], %g1
4001bc64: 80 88 60 02 btst 2, %g1
4001bc68: 12 80 00 20 bne 4001bce8 <rtems_rfs_buffer_handle_request+0x180>
4001bc6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bc70: 80 a0 60 00 cmp %g1, 0
4001bc74: 32 80 00 42 bne,a 4001bd7c <rtems_rfs_buffer_handle_request+0x214>
4001bc78: 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)
4001bc7c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001bc80: 80 a0 60 00 cmp %g1, 0
4001bc84: 22 80 00 08 be,a 4001bca4 <rtems_rfs_buffer_handle_request+0x13c>
4001bc88: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->buffer = rtems_rfs_scan_chain (&fs->release,
4001bc8c: 90 07 60 54 add %i5, 0x54, %o0
4001bc90: 92 07 60 60 add %i5, 0x60, %o1
4001bc94: 7f ff ff 04 call 4001b8a4 <rtems_rfs_scan_chain>
4001bc98: 94 10 00 1a mov %i2, %o2
4001bc9c: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001bca0: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bca4: 80 a0 60 00 cmp %g1, 0
4001bca8: 32 80 00 10 bne,a 4001bce8 <rtems_rfs_buffer_handle_request+0x180>
4001bcac: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bcb0: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001bcb4: 80 a0 60 00 cmp %g1, 0
4001bcb8: 22 80 00 0c be,a 4001bce8 <rtems_rfs_buffer_handle_request+0x180>
4001bcbc: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
4001bcc0: 90 07 60 64 add %i5, 0x64, %o0
4001bcc4: 92 07 60 70 add %i5, 0x70, %o1
4001bcc8: 7f ff fe f7 call 4001b8a4 <rtems_rfs_scan_chain>
4001bccc: 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))
4001bcd0: 80 a2 20 00 cmp %o0, 0
4001bcd4: 02 80 00 04 be 4001bce4 <rtems_rfs_buffer_handle_request+0x17c>
4001bcd8: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_buffer_mark_dirty (handle);
4001bcdc: 82 10 20 01 mov 1, %g1
4001bce0: 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))
4001bce4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bce8: 80 a0 60 00 cmp %g1, 0
4001bcec: 32 80 00 24 bne,a 4001bd7c <rtems_rfs_buffer_handle_request+0x214>
4001bcf0: d2 06 60 08 ld [ %i1 + 8 ], %o1
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4001bcf4: 90 10 00 1d mov %i5, %o0
4001bcf8: 92 10 00 1a mov %i2, %o1
4001bcfc: 94 10 00 1b mov %i3, %o2
4001bd00: 40 00 14 03 call 40020d0c <rtems_rfs_buffer_bdbuf_request>
4001bd04: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
4001bd08: b0 92 20 00 orcc %o0, 0, %i0
4001bd0c: 04 80 00 18 ble 4001bd6c <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
4001bd10: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bd14: 7f ff df bd call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001bd18: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
4001bd1c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bd20: 02 80 00 11 be 4001bd64 <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
4001bd24: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001bd28: 22 80 00 05 be,a 4001bd3c <rtems_rfs_buffer_handle_request+0x1d4><== NOT EXECUTED
4001bd2c: 3b 10 00 d5 sethi %hi(0x40035400), %i5 <== NOT EXECUTED
4001bd30: 3b 10 00 d2 sethi %hi(0x40034800), %i5 <== NOT EXECUTED
4001bd34: 10 80 00 03 b 4001bd40 <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
4001bd38: ba 17 63 20 or %i5, 0x320, %i5 ! 40034b20 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001bd3c: ba 17 62 58 or %i5, 0x258, %i5 <== NOT EXECUTED
4001bd40: 40 00 1e e4 call 400238d0 <strerror> <== NOT EXECUTED
4001bd44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bd48: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001bd4c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001bd50: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001bd54: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001bd58: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001bd5c: 40 00 1a 71 call 40022720 <printf> <== NOT EXECUTED
4001bd60: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
4001bd64: 81 c7 e0 08 ret
4001bd68: 81 e8 00 00 restore
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
4001bd6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bd70: c0 20 60 04 clr [ %g1 + 4 ]
4001bd74: c0 20 40 00 clr [ %g1 ]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
4001bd78: d2 06 60 08 ld [ %i1 + 8 ], %o1
4001bd7c: 90 07 60 44 add %i5, 0x44, %o0
4001bd80: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
4001bd84: 82 00 60 01 inc %g1
4001bd88: 7f ff c7 a4 call 4000dc18 <_Chain_Append>
4001bd8c: c2 22 60 30 st %g1, [ %o1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
4001bd90: 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))
4001bd94: 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++;
4001bd98: 82 00 60 01 inc %g1
4001bd9c: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
4001bda0: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bda4: 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);
4001bda8: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bdac: 7f ff df 97 call 40013c08 <rtems_rfs_trace>
4001bdb0: f4 26 60 04 st %i2, [ %i1 + 4 ]
4001bdb4: 80 8a 20 ff btst 0xff, %o0
4001bdb8: 02 80 00 0f be 4001bdf4 <rtems_rfs_buffer_handle_request+0x28c><== ALWAYS TAKEN
4001bdbc: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001bdc0: 22 80 00 05 be,a 4001bdd4 <rtems_rfs_buffer_handle_request+0x26c><== NOT EXECUTED
4001bdc4: 15 10 00 d5 sethi %hi(0x40035400), %o2 <== NOT EXECUTED
4001bdc8: 15 10 00 d2 sethi %hi(0x40034800), %o2 <== NOT EXECUTED
4001bdcc: 10 80 00 03 b 4001bdd8 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
4001bdd0: 94 12 a3 20 or %o2, 0x320, %o2 ! 40034b20 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001bdd4: 94 12 a2 58 or %o2, 0x258, %o2 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
4001bdd8: 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",
4001bddc: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001bde0: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
4001bde4: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
4001bde8: 90 12 23 30 or %o0, 0x330, %o0 <== NOT EXECUTED
4001bdec: 40 00 1a 4d call 40022720 <printf> <== NOT EXECUTED
4001bdf0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
4001bdf4: b0 10 20 00 clr %i0
}
4001bdf8: 81 c7 e0 08 ret
4001bdfc: 81 e8 00 00 restore
4001be00 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
4001be00: 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))
4001be04: 90 10 20 00 clr %o0
4001be08: 7f ff df 80 call 40013c08 <rtems_rfs_trace>
4001be0c: 92 10 20 20 mov 0x20, %o1
4001be10: 80 8a 20 ff btst 0xff, %o0
4001be14: 22 80 00 07 be,a 4001be30 <rtems_rfs_buffer_open+0x30> <== ALWAYS TAKEN
4001be18: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
4001be1c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001be20: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001be24: 40 00 1a 3f call 40022720 <printf> <== NOT EXECUTED
4001be28: 90 12 23 70 or %o0, 0x370, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
4001be2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001be30: 7f ff b6 05 call 40009644 <open>
4001be34: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
4001be38: 80 a2 20 00 cmp %o0, 0
4001be3c: 16 80 00 0f bge 4001be78 <rtems_rfs_buffer_open+0x78> <== ALWAYS TAKEN
4001be40: d0 26 60 0c st %o0, [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001be44: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001be48: 7f ff df 70 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001be4c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001be50: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001be54: 12 80 00 04 bne 4001be64 <rtems_rfs_buffer_open+0x64> <== NOT EXECUTED
4001be58: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
4001be5c: 81 c7 e0 08 ret <== NOT EXECUTED
4001be60: 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");
4001be64: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
4001be68: 40 00 1a c6 call 40022980 <puts> <== NOT EXECUTED
4001be6c: 01 00 00 00 nop <== NOT EXECUTED
return ENXIO;
4001be70: 81 c7 e0 08 ret <== NOT EXECUTED
4001be74: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
4001be78: 7f ff b2 73 call 40008844 <fstat>
4001be7c: 92 07 bf b8 add %fp, -72, %o1
4001be80: 80 a2 20 00 cmp %o0, 0
4001be84: 16 80 00 12 bge 4001becc <rtems_rfs_buffer_open+0xcc> <== ALWAYS TAKEN
4001be88: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001be8c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001be90: 7f ff df 5e call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001be94: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001be98: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001be9c: 02 bf ff f5 be 4001be70 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
4001bea0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
4001bea4: 40 00 14 c6 call 400211bc <__errno> <== NOT EXECUTED
4001bea8: 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",
4001beac: 40 00 1e 89 call 400238d0 <strerror> <== NOT EXECUTED
4001beb0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4001beb4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001beb8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001bebc: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001bec0: 40 00 1a 18 call 40022720 <printf> <== NOT EXECUTED
4001bec4: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 400357c8 <CSWTCH.2+0x388><== NOT EXECUTED
4001bec8: 30 bf ff ea b,a 4001be70 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
4001becc: 03 00 00 3c sethi %hi(0xf000), %g1
4001bed0: 84 08 80 01 and %g2, %g1, %g2
4001bed4: 03 00 00 18 sethi %hi(0x6000), %g1
4001bed8: 80 a0 80 01 cmp %g2, %g1
4001bedc: 22 80 00 0c be,a 4001bf0c <rtems_rfs_buffer_open+0x10c> <== ALWAYS TAKEN
4001bee0: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001bee4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001bee8: 7f ff df 48 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001beec: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001bef0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bef4: 02 bf ff df be 4001be70 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
4001bef8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4001befc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001bf00: 40 00 1a 08 call 40022720 <printf> <== NOT EXECUTED
4001bf04: 90 12 23 f8 or %o0, 0x3f8, %o0 <== NOT EXECUTED
4001bf08: 30 bf ff da b,a 4001be70 <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);
4001bf0c: 13 10 01 10 sethi %hi(0x40044000), %o1
4001bf10: 94 06 60 10 add %i1, 0x10, %o2
4001bf14: 7f ff b2 9f call 40008990 <ioctl>
4001bf18: 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)
4001bf1c: 80 a2 20 00 cmp %o0, 0
4001bf20: 02 80 00 09 be 4001bf44 <rtems_rfs_buffer_open+0x144> <== ALWAYS TAKEN
4001bf24: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001bf28: 7f ff df 38 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001bf2c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001bf30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bf34: 02 bf ff cf be 4001be70 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
4001bf38: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
4001bf3c: 10 bf ff cb b 4001be68 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
4001bf40: 90 12 20 30 or %o0, 0x30, %o0 ! 40035830 <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))
4001bf44: 92 10 20 20 mov 0x20, %o1
4001bf48: 7f ff df 30 call 40013c08 <rtems_rfs_trace>
4001bf4c: b0 10 20 00 clr %i0
4001bf50: 80 8a 20 ff btst 0xff, %o0
4001bf54: 02 80 00 07 be 4001bf70 <rtems_rfs_buffer_open+0x170> <== ALWAYS TAKEN
4001bf58: 11 10 00 d6 sethi %hi(0x40035800), %o0
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
4001bf5c: 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",
4001bf60: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4001bf64: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
4001bf68: 40 00 19 ee call 40022720 <printf> <== NOT EXECUTED
4001bf6c: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
4001bf70: 81 c7 e0 08 ret
4001bf74: 81 e8 00 00 restore
4001c080 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001c080: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c084: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001c088: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c08c: 7f ff de df call 40013c08 <rtems_rfs_trace>
4001c090: 92 10 24 00 mov 0x400, %o1
4001c094: 80 8a 20 ff btst 0xff, %o0
4001c098: 02 80 00 05 be 4001c0ac <rtems_rfs_buffer_setblksize+0x2c><== ALWAYS TAKEN
4001c09c: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
4001c0a0: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c0a4: 40 00 19 9f call 40022720 <printf> <== NOT EXECUTED
4001c0a8: 90 12 21 30 or %o0, 0x130, %o0 ! 40035930 <CSWTCH.2+0x4f0><== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
4001c0ac: 7f ff ff d5 call 4001c000 <rtems_rfs_buffers_release>
4001c0b0: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c0b4: ba 92 20 00 orcc %o0, 0, %i5
4001c0b8: 04 80 00 0e ble 4001c0f0 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
4001c0bc: 90 10 20 00 clr %o0
4001c0c0: 7f ff de d2 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c0c4: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001c0c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c0cc: 02 80 00 09 be 4001c0f0 <rtems_rfs_buffer_setblksize+0x70><== NOT EXECUTED
4001c0d0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
4001c0d4: 40 00 1d ff call 400238d0 <strerror> <== NOT EXECUTED
4001c0d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c0dc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c0e0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001c0e4: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c0e8: 40 00 19 8e call 40022720 <printf> <== NOT EXECUTED
4001c0ec: 90 12 21 60 or %o0, 0x160, %o0 ! 40035960 <CSWTCH.2+0x520><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
4001c0f0: 7f ff ff a2 call 4001bf78 <rtems_rfs_buffer_sync>
4001c0f4: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c0f8: ba 92 20 00 orcc %o0, 0, %i5
4001c0fc: 04 80 00 0e ble 4001c134 <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
4001c100: 90 10 20 00 clr %o0
4001c104: 7f ff de c1 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c108: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001c10c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c110: 22 80 00 0a be,a 4001c138 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
4001c114: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
4001c118: 40 00 1d ee call 400238d0 <strerror> <== NOT EXECUTED
4001c11c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c120: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c124: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001c128: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c12c: 40 00 19 7d call 40022720 <printf> <== NOT EXECUTED
4001c130: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400359a0 <CSWTCH.2+0x560><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001c134: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001c138: 13 20 01 10 sethi %hi(0x80044000), %o1
4001c13c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4001c140: 92 12 62 04 or %o1, 0x204, %o1
4001c144: 9f c0 40 00 call %g1
4001c148: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
4001c14c: b0 92 20 00 orcc %o0, 0, %i0
4001c150: 16 80 00 05 bge 4001c164 <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
4001c154: 01 00 00 00 nop
rc = errno;
4001c158: 40 00 14 19 call 400211bc <__errno> <== NOT EXECUTED
4001c15c: 01 00 00 00 nop <== NOT EXECUTED
4001c160: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
4001c164: 81 c7 e0 08 ret
4001c168: 81 e8 00 00 restore
4001bf78 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
4001bf78: 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))
4001bf7c: 90 10 20 00 clr %o0
4001bf80: 7f ff df 22 call 40013c08 <rtems_rfs_trace>
4001bf84: 92 10 20 20 mov 0x20, %o1
4001bf88: 80 8a 20 ff btst 0xff, %o0
4001bf8c: 22 80 00 06 be,a 4001bfa4 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
4001bf90: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: syncing\n");
4001bf94: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001bf98: 40 00 1a 7a call 40022980 <puts> <== NOT EXECUTED
4001bf9c: 90 12 20 90 or %o0, 0x90, %o0 ! 40035890 <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));
4001bfa0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
4001bfa4: 7f ff e8 80 call 400161a4 <rtems_bdbuf_syncdev>
4001bfa8: ba 10 20 00 clr %i5
if (sc != RTEMS_SUCCESSFUL)
4001bfac: 80 a2 20 00 cmp %o0, 0
4001bfb0: 02 80 00 0f be 4001bfec <rtems_rfs_buffer_sync+0x74> <== ALWAYS TAKEN
4001bfb4: b8 10 00 08 mov %o0, %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001bfb8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001bfbc: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
4001bfc0: 7f ff df 12 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001bfc4: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
4001bfc8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001bfcc: 22 80 00 09 be,a 4001bff0 <rtems_rfs_buffer_sync+0x78> <== NOT EXECUTED
4001bfd0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
4001bfd4: 7f ff ec 53 call 40017120 <rtems_status_text> <== NOT EXECUTED
4001bfd8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001bfdc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001bfe0: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001bfe4: 40 00 19 cf call 40022720 <printf> <== NOT EXECUTED
4001bfe8: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400358b0 <CSWTCH.2+0x470> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
4001bfec: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001bff0: 7f ff a4 99 call 40005254 <rtems_disk_release>
4001bff4: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
4001bff8: 81 c7 e0 08 ret
4001bffc: 81 e8 00 00 restore
4001c000 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
4001c000: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4001c004: 90 10 20 00 clr %o0
4001c008: 92 10 20 40 mov 0x40, %o1
4001c00c: 7f ff de ff call 40013c08 <rtems_rfs_trace>
4001c010: ba 10 00 18 mov %i0, %i5
4001c014: 80 8a 20 ff btst 0xff, %o0
4001c018: 02 80 00 09 be 4001c03c <rtems_rfs_buffers_release+0x3c> <== ALWAYS TAKEN
4001c01c: 92 07 60 60 add %i5, 0x60, %o1
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
4001c020: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
4001c024: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
4001c028: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
4001c02c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c030: 40 00 19 bc call 40022720 <printf> <== NOT EXECUTED
4001c034: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400358e0 <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,
4001c038: 92 07 60 60 add %i5, 0x60, %o1 <== NOT EXECUTED
4001c03c: 94 10 20 00 clr %o2
4001c040: 7f ff fd f6 call 4001b818 <rtems_rfs_release_chain>
4001c044: 90 07 60 54 add %i5, 0x54, %o0
4001c048: 82 38 00 08 xnor %g0, %o0, %g1
4001c04c: 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,
4001c050: 92 07 60 70 add %i5, 0x70, %o1
4001c054: b0 0a 00 01 and %o0, %g1, %i0
4001c058: 94 10 20 01 mov 1, %o2
4001c05c: 7f ff fd ef call 4001b818 <rtems_rfs_release_chain>
4001c060: 90 07 60 64 add %i5, 0x64, %o0
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
4001c064: 80 a6 20 00 cmp %i0, 0
4001c068: 12 80 00 04 bne 4001c078 <rtems_rfs_buffers_release+0x78> <== NEVER TAKEN
4001c06c: 80 a2 20 00 cmp %o0, 0
4001c070: 34 80 00 02 bg,a 4001c078 <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
4001c074: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
4001c078: 81 c7 e0 08 ret
4001c07c: 81 e8 00 00 restore
4001c75c <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)
{
4001c75c: 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))
4001c760: 90 10 20 00 clr %o0
4001c764: 7f ff dd 29 call 40013c08 <rtems_rfs_trace>
4001c768: 13 08 00 00 sethi %hi(0x20000000), %o1
4001c76c: 80 8a 20 ff btst 0xff, %o0
4001c770: 02 80 00 14 be 4001c7c0 <rtems_rfs_dir_add_entry+0x64> <== ALWAYS TAKEN
4001c774: a6 07 bf b0 add %fp, -80, %l3
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
4001c778: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c77c: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c780: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED
4001c784: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
4001c788: 40 00 17 e6 call 40022720 <printf> <== NOT EXECUTED
4001c78c: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
4001c790: 10 80 00 05 b 4001c7a4 <rtems_rfs_dir_add_entry+0x48> <== NOT EXECUTED
4001c794: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
4001c798: 40 00 18 4c call 400228c8 <putchar> <== NOT EXECUTED
4001c79c: 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++)
4001c7a0: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
4001c7a4: 32 bf ff fd bne,a 4001c798 <rtems_rfs_dir_add_entry+0x3c><== NOT EXECUTED
4001c7a8: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
4001c7ac: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c7b0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001c7b4: 40 00 17 db call 40022720 <printf> <== NOT EXECUTED
4001c7b8: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001c7bc: a6 07 bf b0 add %fp, -80, %l3 <== NOT EXECUTED
4001c7c0: 90 10 00 18 mov %i0, %o0
4001c7c4: 92 10 00 19 mov %i1, %o1
4001c7c8: 7f ff f8 fb call 4001abb4 <rtems_rfs_block_map_open>
4001c7cc: 94 10 00 13 mov %l3, %o2
if (rc > 0)
4001c7d0: ba 92 20 00 orcc %o0, 0, %i5
4001c7d4: 34 80 00 c5 bg,a 4001cae8 <rtems_rfs_dir_add_entry+0x38c><== NEVER TAKEN
4001c7d8: 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)
4001c7dc: 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;
4001c7e0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001c7e4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001c7e8: 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;
4001c7ec: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
4001c7f0: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
4001c7f4: c0 27 bf a0 clr [ %fp + -96 ]
4001c7f8: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001c7fc: 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);
4001c800: 90 10 00 18 mov %i0, %o0
4001c804: 92 10 00 13 mov %l3, %o1
4001c808: 94 07 bf 98 add %fp, -104, %o2
4001c80c: 7f ff f9 bf call 4001af08 <rtems_rfs_block_map_find>
4001c810: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001c814: ba 92 20 00 orcc %o0, 0, %i5
4001c818: 04 80 00 29 ble 4001c8bc <rtems_rfs_dir_add_entry+0x160>
4001c81c: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
4001c820: 02 80 00 0f be 4001c85c <rtems_rfs_dir_add_entry+0x100> <== ALWAYS TAKEN
4001c824: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001c828: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c82c: 7f ff dc f7 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c830: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001c834: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c838: 22 80 00 a6 be,a 4001cad0 <rtems_rfs_dir_add_entry+0x374><== NOT EXECUTED
4001c83c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001c840: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001c844: 40 00 1c 23 call 400238d0 <strerror> <== NOT EXECUTED
4001c848: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c84c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c850: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c854: 10 80 00 15 b 4001c8a8 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
4001c858: 90 12 21 90 or %o0, 0x190, %o0 ! 40035d90 <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);
4001c85c: 92 10 00 13 mov %l3, %o1
4001c860: 94 10 20 01 mov 1, %o2
4001c864: 7f ff fa 2f call 4001b120 <rtems_rfs_block_map_grow>
4001c868: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001c86c: ba 92 20 00 orcc %o0, 0, %i5
4001c870: 04 80 00 14 ble 4001c8c0 <rtems_rfs_dir_add_entry+0x164> <== ALWAYS TAKEN
4001c874: a0 10 20 00 clr %l0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001c878: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c87c: 7f ff dc e3 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c880: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001c884: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c888: 22 80 00 92 be,a 4001cad0 <rtems_rfs_dir_add_entry+0x374><== NOT EXECUTED
4001c88c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001c890: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001c894: 40 00 1c 0f call 400238d0 <strerror> <== NOT EXECUTED
4001c898: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c89c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c8a0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c8a4: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 40035dd8 <CSWTCH.2+0x998><== NOT EXECUTED
4001c8a8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001c8ac: 40 00 17 9d call 40022720 <printf> <== NOT EXECUTED
4001c8b0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001c8b4: 10 80 00 87 b 4001cad0 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
4001c8b8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001c8bc: a0 10 20 01 mov 1, %l0
}
read = false;
}
bpos.bno++;
4001c8c0: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001c8c4: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
4001c8c8: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001c8cc: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
4001c8d0: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001c8d4: 90 10 00 18 mov %i0, %o0
4001c8d8: 92 07 bf a4 add %fp, -92, %o1
4001c8dc: 7f ff fc a3 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001c8e0: 96 10 00 10 mov %l0, %o3
if (rc > 0)
4001c8e4: ba 92 20 00 orcc %o0, 0, %i5
4001c8e8: 04 80 00 0f ble 4001c924 <rtems_rfs_dir_add_entry+0x1c8> <== ALWAYS TAKEN
4001c8ec: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001c8f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c8f4: 7f ff dc c5 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c8f8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001c8fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c900: 22 80 00 74 be,a 4001cad0 <rtems_rfs_dir_add_entry+0x374><== NOT EXECUTED
4001c904: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001c908: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001c90c: 40 00 1b f1 call 400238d0 <strerror> <== NOT EXECUTED
4001c910: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c914: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c918: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c91c: 10 bf ff e3 b 4001c8a8 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
4001c920: 90 12 22 20 or %o0, 0x220, %o0 ! 40035e20 <CSWTCH.2+0x9e0><== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
4001c924: 80 a4 20 00 cmp %l0, 0
4001c928: 12 80 00 06 bne 4001c940 <rtems_rfs_dir_add_entry+0x1e4>
4001c92c: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
4001c930: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001c934: 90 10 00 1d mov %i5, %o0
4001c938: 40 00 16 fc call 40022528 <memset>
4001c93c: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c940: 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;
4001c944: a2 10 20 00 clr %l1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c948: 10 80 00 5d b 4001cabc <rtems_rfs_dir_add_entry+0x360>
4001c94c: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001c950: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001c954: 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);
4001c958: a1 2c 20 08 sll %l0, 8, %l0
4001c95c: a0 14 00 03 or %l0, %g3, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001c960: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
4001c964: a5 2c a0 18 sll %l2, 0x18, %l2
4001c968: 87 28 e0 10 sll %g3, 0x10, %g3
4001c96c: a4 14 80 03 or %l2, %g3, %l2
4001c970: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c974: 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);
4001c978: a4 14 80 03 or %l2, %g3, %l2
4001c97c: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
4001c980: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c984: 12 80 00 2a bne 4001ca2c <rtems_rfs_dir_add_entry+0x2d0>
4001c988: a4 14 80 03 or %l2, %g3, %l2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
4001c98c: 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) <
4001c990: 80 a5 40 11 cmp %l5, %l1
4001c994: 3a bf ff 9c bcc,a 4001c804 <rtems_rfs_dir_add_entry+0xa8><== NEVER TAKEN
4001c998: 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);
4001c99c: 92 10 00 1b mov %i3, %o1
4001c9a0: 40 00 11 18 call 40020e00 <rtems_rfs_dir_hash>
4001c9a4: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
4001c9a8: 83 32 20 18 srl %o0, 0x18, %g1
4001c9ac: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
4001c9b0: 83 32 20 10 srl %o0, 0x10, %g1
4001c9b4: c2 2f 60 05 stb %g1, [ %i5 + 5 ]
4001c9b8: 83 32 20 08 srl %o0, 8, %g1
4001c9bc: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001c9c0: 83 37 20 18 srl %i4, 0x18, %g1
4001c9c4: c2 2f 40 00 stb %g1, [ %i5 ]
4001c9c8: 83 37 20 10 srl %i4, 0x10, %g1
4001c9cc: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
4001c9d0: 83 37 20 08 srl %i4, 8, %g1
4001c9d4: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
rtems_rfs_dir_set_entry_length (entry,
4001c9d8: 82 06 e0 0a add %i3, 0xa, %g1
4001c9dc: 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);
4001c9e0: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
4001c9e4: c4 2f 60 08 stb %g2, [ %i5 + 8 ]
4001c9e8: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001c9ec: 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);
4001c9f0: 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);
4001c9f4: 90 07 60 0a add %i5, 0xa, %o0
4001c9f8: 40 00 16 3d call 400222ec <memcpy>
4001c9fc: 92 10 00 1a mov %i2, %o1
rtems_rfs_buffer_mark_dirty (&buffer);
4001ca00: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ca04: 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);
4001ca08: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ca0c: 7f ff fe 0c call 4001c23c <rtems_rfs_buffer_handle_close>
4001ca10: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001ca14: 90 10 00 18 mov %i0, %o0
4001ca18: 92 07 bf b0 add %fp, -80, %o1
4001ca1c: 7f ff f8 c7 call 4001ad38 <rtems_rfs_block_map_close>
4001ca20: ba 10 20 00 clr %i5
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001ca24: 81 c7 e0 08 ret
4001ca28: 91 e8 00 1d restore %g0, %i5, %o0
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001ca2c: 80 a4 20 0a cmp %l0, 0xa
4001ca30: 04 80 00 0d ble 4001ca64 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
4001ca34: 90 10 20 00 clr %o0
4001ca38: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
4001ca3c: 80 a4 00 03 cmp %l0, %g3
4001ca40: 1a 80 00 09 bcc 4001ca64 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
4001ca44: 80 a4 a0 00 cmp %l2, 0
4001ca48: 02 80 00 07 be 4001ca64 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
4001ca4c: 01 00 00 00 nop
4001ca50: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
4001ca54: 80 a4 80 03 cmp %l2, %g3
4001ca58: 28 80 00 18 bleu,a 4001cab8 <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
4001ca5c: ba 07 40 10 add %i5, %l0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001ca60: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ca64: 7f ff dc 69 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001ca68: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001ca6c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ca70: 02 80 00 0a be 4001ca98 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
4001ca74: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001ca78: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001ca7c: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001ca80: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001ca84: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
4001ca88: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001ca8c: 40 00 17 25 call 40022720 <printf> <== NOT EXECUTED
4001ca90: 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);
4001ca94: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001ca98: 7f ff fd e9 call 4001c23c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001ca9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001caa0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001caa4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001caa8: 7f ff f8 a4 call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001caac: 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;
}
4001cab0: 81 c7 e0 08 ret <== NOT EXECUTED
4001cab4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
4001cab8: 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))
4001cabc: 80 a4 40 02 cmp %l1, %g2
4001cac0: 2a bf ff a4 bcs,a 4001c950 <rtems_rfs_dir_add_entry+0x1f4><== ALWAYS TAKEN
4001cac4: 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);
4001cac8: 10 bf ff 4f b 4001c804 <rtems_rfs_dir_add_entry+0xa8> <== NOT EXECUTED
4001cacc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001cad0: 7f ff fd db call 4001c23c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001cad4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001cad8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cadc: 7f ff f8 97 call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001cae0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
return rc;
}
4001cae4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001cae8: 81 c7 e0 08 ret <== NOT EXECUTED
4001caec: 81 e8 00 00 restore <== NOT EXECUTED
4001caf0 <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)
{
4001caf0: 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))
4001caf4: 90 10 20 00 clr %o0
4001caf8: 13 10 00 00 sethi %hi(0x40000000), %o1
4001cafc: 7f ff dc 43 call 40013c08 <rtems_rfs_trace>
4001cb00: ba 10 00 18 mov %i0, %i5
4001cb04: 80 8a 20 ff btst 0xff, %o0
4001cb08: 02 80 00 09 be 4001cb2c <rtems_rfs_dir_del_entry+0x3c> <== ALWAYS TAKEN
4001cb0c: aa 07 bf b0 add %fp, -80, %l5
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
4001cb10: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001cb14: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001cb18: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001cb1c: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
4001cb20: 40 00 17 00 call 40022720 <printf> <== NOT EXECUTED
4001cb24: 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);
4001cb28: aa 07 bf b0 add %fp, -80, %l5 <== NOT EXECUTED
4001cb2c: 90 10 00 1d mov %i5, %o0
4001cb30: 92 10 00 19 mov %i1, %o1
4001cb34: 7f ff f8 20 call 4001abb4 <rtems_rfs_block_map_open>
4001cb38: 94 10 00 15 mov %l5, %o2
if (rc > 0)
4001cb3c: b0 92 20 00 orcc %o0, 0, %i0
4001cb40: 14 80 00 c4 bg 4001ce50 <rtems_rfs_dir_del_entry+0x360> <== NEVER TAKEN
4001cb44: ac 07 bf a0 add %fp, -96, %l6
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001cb48: 90 10 00 1d mov %i5, %o0
4001cb4c: 92 10 00 15 mov %l5, %o1
4001cb50: 94 10 20 00 clr %o2
4001cb54: 96 10 00 1b mov %i3, %o3
4001cb58: 7f ff f9 48 call 4001b078 <rtems_rfs_block_map_seek>
4001cb5c: 98 10 00 16 mov %l6, %o4
if (rc > 0)
4001cb60: b0 92 20 00 orcc %o0, 0, %i0
4001cb64: 04 80 00 06 ble 4001cb7c <rtems_rfs_dir_del_entry+0x8c> <== ALWAYS TAKEN
4001cb68: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
4001cb6c: 22 80 00 b6 be,a 4001ce44 <rtems_rfs_dir_del_entry+0x354><== NOT EXECUTED
4001cb70: 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);
4001cb74: 10 80 00 b5 b 4001ce48 <rtems_rfs_dir_del_entry+0x358> <== NOT EXECUTED
4001cb78: 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)
4001cb7c: 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)
4001cb80: 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: "
4001cb84: 2f 10 00 d7 sethi %hi(0x40035c00), %l7
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001cb88: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001cb8c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001cb90: 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);
4001cb94: 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)
4001cb98: 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)
4001cb9c: 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)
4001cba0: 10 80 00 c1 b 4001cea4 <rtems_rfs_dir_del_entry+0x3b4>
4001cba4: ae 15 e3 38 or %l7, 0x338, %l7
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001cba8: 90 10 00 1d mov %i5, %o0
4001cbac: 92 07 bf a4 add %fp, -92, %o1
4001cbb0: 7f ff fb ee call 4001bb68 <rtems_rfs_buffer_handle_request>
4001cbb4: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001cbb8: a4 92 20 00 orcc %o0, 0, %l2
4001cbbc: 04 80 00 13 ble 4001cc08 <rtems_rfs_dir_del_entry+0x118> <== ALWAYS TAKEN
4001cbc0: 80 a4 e0 00 cmp %l3, 0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001cbc4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001cbc8: 7f ff dc 10 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001cbcc: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001cbd0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cbd4: 22 80 00 b9 be,a 4001ceb8 <rtems_rfs_dir_del_entry+0x3c8><== NOT EXECUTED
4001cbd8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001cbdc: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001cbe0: 40 00 1b 3c call 400238d0 <strerror> <== NOT EXECUTED
4001cbe4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4001cbe8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001cbec: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001cbf0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001cbf4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001cbf8: 40 00 16 ca call 40022720 <printf> <== NOT EXECUTED
4001cbfc: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <CSWTCH.2+0xab0><== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001cc00: 10 80 00 ae b 4001ceb8 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
4001cc04: 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)
4001cc08: 12 80 00 06 bne 4001cc20 <rtems_rfs_dir_del_entry+0x130> <== NEVER TAKEN
4001cc0c: a0 10 20 00 clr %l0
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
4001cc10: d2 07 60 08 ld [ %i5 + 8 ], %o1
4001cc14: 40 00 48 7b call 4002ee00 <.urem>
4001cc18: 90 10 00 1b mov %i3, %o0
4001cc1c: a0 10 00 08 mov %o0, %l0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001cc20: c2 07 bf ac ld [ %fp + -84 ], %g1
4001cc24: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001cc28: 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;
4001cc2c: b8 07 00 10 add %i4, %l0, %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001cc30: 10 80 00 8d b 4001ce64 <rtems_rfs_dir_del_entry+0x374>
4001cc34: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001cc38: e2 0f 20 08 ldub [ %i4 + 8 ], %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001cc3c: 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);
4001cc40: a3 2c 60 08 sll %l1, 8, %l1
4001cc44: a2 14 40 03 or %l1, %g3, %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001cc48: c6 0f 20 01 ldub [ %i4 + 1 ], %g3
4001cc4c: 97 2a e0 18 sll %o3, 0x18, %o3
4001cc50: 87 28 e0 10 sll %g3, 0x10, %g3
4001cc54: 96 12 c0 03 or %o3, %g3, %o3
4001cc58: c6 0f 20 03 ldub [ %i4 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001cc5c: 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);
4001cc60: 96 12 c0 03 or %o3, %g3, %o3
4001cc64: c6 0f 20 02 ldub [ %i4 + 2 ], %g3
4001cc68: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001cc6c: 02 80 00 81 be 4001ce70 <rtems_rfs_dir_del_entry+0x380> <== NEVER TAKEN
4001cc70: 96 12 c0 03 or %o3, %g3, %o3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001cc74: 80 a4 60 0a cmp %l1, 0xa
4001cc78: 24 80 00 0d ble,a 4001ccac <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
4001cc7c: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
4001cc80: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
4001cc84: 80 a4 40 03 cmp %l1, %g3
4001cc88: 1a 80 00 08 bcc 4001cca8 <rtems_rfs_dir_del_entry+0x1b8> <== NEVER TAKEN
4001cc8c: 80 a2 e0 00 cmp %o3, 0
4001cc90: 22 80 00 07 be,a 4001ccac <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
4001cc94: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
4001cc98: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
4001cc9c: 80 a2 c0 03 cmp %o3, %g3
4001cca0: 08 80 00 11 bleu 4001cce4 <rtems_rfs_dir_del_entry+0x1f4> <== ALWAYS TAKEN
4001cca4: 80 a6 80 0b cmp %i2, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001cca8: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
4001ccac: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ccb0: 7f ff db d6 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001ccb4: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001ccb8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ccbc: 02 80 00 87 be 4001ced8 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
4001ccc0: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001ccc4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001ccc8: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
4001cccc: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4001ccd0: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4001ccd4: 40 00 16 93 call 40022720 <printf> <== NOT EXECUTED
4001ccd8: 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);
4001ccdc: 10 80 00 71 b 4001cea0 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
4001cce0: 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))
4001cce4: 12 80 00 5d bne 4001ce58 <rtems_rfs_dir_del_entry+0x368> <== NEVER TAKEN
4001cce8: 80 a4 e0 00 cmp %l3, 0
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
4001ccec: 92 07 00 11 add %i4, %l1, %o1
4001ccf0: 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);
4001ccf4: b6 04 00 11 add %l0, %l1, %i3
4001ccf8: b6 20 40 1b sub %g1, %i3, %i3
memmove (entry, entry + elength, remaining);
4001ccfc: 40 00 15 b9 call 400223e0 <memmove>
4001cd00: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
4001cd04: 90 07 00 1b add %i4, %i3, %o0
4001cd08: 92 10 20 ff mov 0xff, %o1
4001cd0c: 40 00 16 07 call 40022528 <memset>
4001cd10: 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);
4001cd14: c4 0f 20 08 ldub [ %i4 + 8 ], %g2
4001cd18: c2 0f 20 09 ldub [ %i4 + 9 ], %g1
4001cd1c: 85 28 a0 08 sll %g2, 8, %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001cd20: 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);
4001cd24: b8 10 80 01 or %g2, %g1, %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001cd28: 7f ff db b8 call 40013c08 <rtems_rfs_trace>
4001cd2c: 13 10 00 00 sethi %hi(0x40000000), %o1
4001cd30: 80 8a 20 ff btst 0xff, %o0
4001cd34: 02 80 00 1a be 4001cd9c <rtems_rfs_dir_del_entry+0x2ac> <== ALWAYS TAKEN
4001cd38: 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");
4001cd3c: 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: "
4001cd40: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
4001cd44: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001cd48: 12 80 00 08 bne 4001cd68 <rtems_rfs_dir_del_entry+0x278> <== NOT EXECUTED
4001cd4c: 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");
4001cd50: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001cd54: 12 80 00 06 bne 4001cd6c <rtems_rfs_dir_del_entry+0x27c> <== NOT EXECUTED
4001cd58: 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: "
4001cd5c: 1b 10 00 d1 sethi %hi(0x40034400), %o5 <== NOT EXECUTED
4001cd60: 10 80 00 08 b 4001cd80 <rtems_rfs_dir_del_entry+0x290> <== NOT EXECUTED
4001cd64: 9a 13 61 a0 or %o5, 0x1a0, %o5 ! 400345a0 <_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");
4001cd68: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001cd6c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001cd70: 02 bf ff fc be 4001cd60 <rtems_rfs_dir_del_entry+0x270> <== NOT EXECUTED
4001cd74: 1b 10 00 d1 sethi %hi(0x40034400), %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: "
4001cd78: 1b 10 00 ca sethi %hi(0x40032800), %o5 <== NOT EXECUTED
4001cd7c: 9a 13 61 e8 or %o5, 0x1e8, %o5 ! 400329e8 <Callbacks.6428+0x1d0><== NOT EXECUTED
4001cd80: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001cd84: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001cd88: 90 12 23 88 or %o0, 0x388, %o0 <== NOT EXECUTED
4001cd8c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001cd90: 40 00 16 64 call 40022720 <printf> <== NOT EXECUTED
4001cd94: 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) &&
4001cd98: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
4001cd9c: b8 38 40 1c xnor %g1, %i4, %i4
4001cda0: 80 a7 20 00 cmp %i4, 0
4001cda4: 12 80 00 23 bne 4001ce30 <rtems_rfs_dir_del_entry+0x340>
4001cda8: 80 a4 20 00 cmp %l0, 0
4001cdac: 12 80 00 21 bne 4001ce30 <rtems_rfs_dir_del_entry+0x340> <== ALWAYS TAKEN
4001cdb0: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001cdb4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001cdb8: 12 80 00 05 bne 4001cdcc <rtems_rfs_dir_del_entry+0x2dc> <== NOT EXECUTED
4001cdbc: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
4001cdc0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001cdc4: 02 80 00 07 be 4001cde0 <rtems_rfs_dir_del_entry+0x2f0> <== NOT EXECUTED
4001cdc8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001cdcc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001cdd0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001cdd4: 12 80 00 18 bne 4001ce34 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
4001cdd8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001cddc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001cde0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001cde4: 7f ff f9 bf call 4001b4e0 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
4001cde8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
4001cdec: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001cdf0: 04 80 00 10 ble 4001ce30 <rtems_rfs_dir_del_entry+0x340> <== NOT EXECUTED
4001cdf4: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001cdf8: 7f ff db 84 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001cdfc: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001ce00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ce04: 02 80 00 0c be 4001ce34 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
4001ce08: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001ce0c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
4001ce10: 40 00 1a b0 call 400238d0 <strerror> <== NOT EXECUTED
4001ce14: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001ce18: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001ce1c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001ce20: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001ce24: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001ce28: 40 00 16 3e call 40022720 <printf> <== NOT EXECUTED
4001ce2c: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 40035fe8 <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);
4001ce30: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ce34: 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);
4001ce38: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ce3c: 7f ff fd 00 call 4001c23c <rtems_rfs_buffer_handle_close>
4001ce40: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_block_map_close (fs, &map);
4001ce44: 90 10 00 1d mov %i5, %o0
4001ce48: 7f ff f7 bc call 4001ad38 <rtems_rfs_block_map_close>
4001ce4c: 92 07 bf b0 add %fp, -80, %o1
4001ce50: 81 c7 e0 08 ret
4001ce54: 81 e8 00 00 restore
return 0;
}
if (!search)
4001ce58: 02 80 00 20 be 4001ced8 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
4001ce5c: b8 07 00 11 add %i4, %l1, %i4 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
4001ce60: 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))
4001ce64: 80 a4 00 02 cmp %l0, %g2
4001ce68: 2a bf ff 74 bcs,a 4001cc38 <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
4001ce6c: c6 0f 20 09 ldub [ %i4 + 9 ], %g3
entry += elength;
eoffset += elength;
}
if (rc == 0)
4001ce70: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4001ce74: 32 80 00 0c bne,a 4001cea4 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
4001ce78: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001ce7c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ce80: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001ce84: 7f ff f8 9a call 4001b0ec <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001ce88: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
if (rc == ENXIO)
4001ce8c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
4001ce90: 12 80 00 05 bne 4001cea4 <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
4001ce94: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = ENOENT;
4001ce98: 10 80 00 06 b 4001ceb0 <rtems_rfs_dir_del_entry+0x3c0> <== NOT EXECUTED
4001ce9c: 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);
4001cea0: 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)
4001cea4: 80 a6 20 00 cmp %i0, 0
4001cea8: 02 bf ff 40 be 4001cba8 <rtems_rfs_dir_del_entry+0xb8> <== ALWAYS TAKEN
4001ceac: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001ceb0: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001ceb4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001ceb8: 7f ff fc e1 call 4001c23c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001cebc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001cec0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001cec4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001cec8: 7f ff f7 9c call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001cecc: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
4001ced0: 81 c7 e0 08 ret <== NOT EXECUTED
4001ced4: 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);
4001ced8: 10 bf ff f2 b 4001cea0 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
4001cedc: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
4001d278 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
4001d278: 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))
4001d27c: 90 10 20 00 clr %o0
4001d280: 7f ff da 62 call 40013c08 <rtems_rfs_trace>
4001d284: 13 20 00 00 sethi %hi(0x80000000), %o1
4001d288: 80 8a 20 ff btst 0xff, %o0
4001d28c: 02 80 00 07 be 4001d2a8 <rtems_rfs_dir_empty+0x30> <== ALWAYS TAKEN
4001d290: b8 07 bf b0 add %fp, -80, %i4
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
4001d294: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d298: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d29c: 40 00 15 21 call 40022720 <printf> <== NOT EXECUTED
4001d2a0: 90 12 21 18 or %o0, 0x118, %o0 ! 40036118 <CSWTCH.2+0xcd8><== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d2a4: b8 07 bf b0 add %fp, -80, %i4 <== NOT EXECUTED
4001d2a8: 90 10 00 18 mov %i0, %o0
4001d2ac: 92 10 00 19 mov %i1, %o1
4001d2b0: 7f ff f6 41 call 4001abb4 <rtems_rfs_block_map_open>
4001d2b4: 94 10 00 1c mov %i4, %o2
if (rc > 0)
4001d2b8: ba 92 20 00 orcc %o0, 0, %i5
4001d2bc: 34 80 00 82 bg,a 4001d4c4 <rtems_rfs_dir_empty+0x24c> <== NEVER TAKEN
4001d2c0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001d2c4: b6 07 bf a0 add %fp, -96, %i3
4001d2c8: 90 10 00 18 mov %i0, %o0
4001d2cc: 92 10 00 1c mov %i4, %o1
4001d2d0: 94 10 20 00 clr %o2
4001d2d4: 96 10 20 00 clr %o3
4001d2d8: 7f ff f7 68 call 4001b078 <rtems_rfs_block_map_seek>
4001d2dc: 98 10 00 1b mov %i3, %o4
if (rc > 0)
4001d2e0: ba 92 20 00 orcc %o0, 0, %i5
4001d2e4: 04 80 00 05 ble 4001d2f8 <rtems_rfs_dir_empty+0x80> <== ALWAYS TAKEN
4001d2e8: 25 00 00 3f sethi %hi(0xfc00), %l2
{
rtems_rfs_block_map_close (fs, &map);
4001d2ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d2f0: 10 80 00 69 b 4001d494 <rtems_rfs_dir_empty+0x21c> <== NOT EXECUTED
4001d2f4: 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: "
4001d2f8: 27 10 00 d8 sethi %hi(0x40036000), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001d2fc: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001d300: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001d304: 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)
4001d308: 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: "
4001d30c: a6 14 e1 38 or %l3, 0x138, %l3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d310: a2 10 00 1c mov %i4, %l1
4001d314: a0 10 00 1b mov %i3, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001d318: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001d31c: 90 10 00 18 mov %i0, %o0
4001d320: 92 07 bf a4 add %fp, -92, %o1
4001d324: 7f ff fa 11 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001d328: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001d32c: ba 92 20 00 orcc %o0, 0, %i5
4001d330: 14 80 00 4c bg 4001d460 <rtems_rfs_dir_empty+0x1e8> <== NEVER TAKEN
4001d334: 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))
4001d338: 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);
4001d33c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d340: 84 00 bf f6 add %g2, -10, %g2
4001d344: 10 80 00 3b b 4001d430 <rtems_rfs_dir_empty+0x1b8>
4001d348: b6 10 20 00 clr %i3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001d34c: f8 08 60 08 ldub [ %g1 + 8 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001d350: 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);
4001d354: b9 2f 20 08 sll %i4, 8, %i4
4001d358: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001d35c: c6 08 60 01 ldub [ %g1 + 1 ], %g3
4001d360: b5 2e a0 18 sll %i2, 0x18, %i2
4001d364: 87 28 e0 10 sll %g3, 0x10, %g3
4001d368: b4 16 80 03 or %i2, %g3, %i2
4001d36c: c6 08 60 03 ldub [ %g1 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d370: 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);
4001d374: b4 16 80 03 or %i2, %g3, %i2
4001d378: c6 08 60 02 ldub [ %g1 + 2 ], %g3
4001d37c: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d380: 02 80 00 48 be 4001d4a0 <rtems_rfs_dir_empty+0x228>
4001d384: b4 16 80 03 or %i2, %g3, %i2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d388: 80 a7 20 0a cmp %i4, 0xa
4001d38c: 04 80 00 0d ble 4001d3c0 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
4001d390: 90 10 20 01 mov 1, %o0
4001d394: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
4001d398: 80 a7 00 03 cmp %i4, %g3
4001d39c: 1a 80 00 09 bcc 4001d3c0 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
4001d3a0: 80 a6 a0 00 cmp %i2, 0
4001d3a4: 02 80 00 07 be 4001d3c0 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
4001d3a8: 01 00 00 00 nop
4001d3ac: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
4001d3b0: 80 a6 80 03 cmp %i2, %g3
4001d3b4: 08 80 00 10 bleu 4001d3f4 <rtems_rfs_dir_empty+0x17c> <== ALWAYS TAKEN
4001d3b8: 80 a7 20 0b cmp %i4, 0xb
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001d3bc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
4001d3c0: 7f ff da 12 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001d3c4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d3c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d3cc: 22 80 00 36 be,a 4001d4a4 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
4001d3d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
4001d3d4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d3d8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4001d3dc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001d3e0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4001d3e4: 40 00 14 cf call 40022720 <printf> <== NOT EXECUTED
4001d3e8: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d3ec: 10 80 00 2e b 4001d4a4 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
4001d3f0: 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)) ||
4001d3f4: 12 80 00 04 bne 4001d404 <rtems_rfs_dir_empty+0x18c>
4001d3f8: 80 a7 20 0c cmp %i4, 0xc
4001d3fc: 10 80 00 09 b 4001d420 <rtems_rfs_dir_empty+0x1a8>
4001d400: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
4001d404: 32 80 00 18 bne,a 4001d464 <rtems_rfs_dir_empty+0x1ec>
4001d408: 82 10 20 00 clr %g1
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
4001d40c: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
4001d410: 80 a0 e0 2e cmp %g3, 0x2e
4001d414: 32 80 00 14 bne,a 4001d464 <rtems_rfs_dir_empty+0x1ec> <== NEVER TAKEN
4001d418: 82 10 20 00 clr %g1 <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001d41c: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
4001d420: 80 a0 e0 2e cmp %g3, 0x2e
4001d424: 12 80 00 0c bne 4001d454 <rtems_rfs_dir_empty+0x1dc> <== NEVER TAKEN
4001d428: b6 06 c0 1c add %i3, %i4, %i3
{
empty = false;
break;
}
entry += elength;
4001d42c: 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))
4001d430: 80 a6 c0 02 cmp %i3, %g2
4001d434: 2a bf ff c6 bcs,a 4001d34c <rtems_rfs_dir_empty+0xd4> <== ALWAYS TAKEN
4001d438: c6 08 60 09 ldub [ %g1 + 9 ], %g3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d43c: 10 80 00 1a b 4001d4a4 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
4001d440: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
{
if (rc == ENXIO)
4001d444: 02 80 00 06 be 4001d45c <rtems_rfs_dir_empty+0x1e4> <== ALWAYS TAKEN
4001d448: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
4001d44c: 10 80 00 07 b 4001d468 <rtems_rfs_dir_empty+0x1f0> <== NOT EXECUTED
4001d450: 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] != '.') ||
4001d454: 10 80 00 04 b 4001d464 <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
4001d458: 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;
4001d45c: ba 10 20 00 clr %i5
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
4001d460: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
4001d464: 82 18 60 01 xor %g1, 1, %g1
4001d468: 80 88 60 ff btst 0xff, %g1
4001d46c: 02 80 00 06 be 4001d484 <rtems_rfs_dir_empty+0x20c>
4001d470: 92 07 bf a4 add %fp, -92, %o1
4001d474: 80 a7 60 00 cmp %i5, 0
4001d478: 22 80 00 03 be,a 4001d484 <rtems_rfs_dir_empty+0x20c> <== ALWAYS TAKEN
4001d47c: ba 10 20 5a mov 0x5a, %i5
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
4001d480: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001d484: 7f ff fb 6e call 4001c23c <rtems_rfs_buffer_handle_close>
4001d488: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001d48c: 90 10 00 18 mov %i0, %o0
4001d490: 92 07 bf b0 add %fp, -80, %o1
4001d494: 7f ff f6 29 call 4001ad38 <rtems_rfs_block_map_close>
4001d498: b0 10 00 1d mov %i5, %i0
4001d49c: 30 80 00 0a b,a 4001d4c4 <rtems_rfs_dir_empty+0x24c>
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d4a0: 90 10 00 18 mov %i0, %o0
4001d4a4: 92 10 00 11 mov %l1, %o1
4001d4a8: 7f ff f7 11 call 4001b0ec <rtems_rfs_block_map_next_block>
4001d4ac: 94 10 00 10 mov %l0, %o2
if (rc > 0)
4001d4b0: ba 92 20 00 orcc %o0, 0, %i5
4001d4b4: 24 bf ff 9a ble,a 4001d31c <rtems_rfs_dir_empty+0xa4> <== NEVER TAKEN
4001d4b8: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
{
if (rc == ENXIO)
4001d4bc: 10 bf ff e2 b 4001d444 <rtems_rfs_dir_empty+0x1cc>
4001d4c0: 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;
}
4001d4c4: 81 c7 e0 08 ret
4001d4c8: 81 e8 00 00 restore
40020e00 <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;
40020e00: 05 37 f7 c5 sethi %hi(0xdfdf1400), %g2
40020e04: 84 10 a2 9f or %g2, 0x29f, %g2 ! dfdf169f <LEON_REG+0x5fdf169f>
40020e08: 84 02 40 02 add %o1, %g2, %g2
40020e0c: 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)
40020e10: 10 80 00 48 b 40020f30 <rtems_rfs_dir_hash+0x130>
40020e14: 88 10 00 02 mov %g2, %g4
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
40020e18: 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];
40020e1c: 88 03 40 04 add %o5, %g4, %g4
a += ((uint32_t)k[1])<<8;
40020e20: da 0a 20 01 ldub [ %o0 + 1 ], %o5
a += ((uint32_t)k[2])<<16;
40020e24: 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;
40020e28: 9b 2b 60 08 sll %o5, 8, %o5
40020e2c: 9a 01 00 0d add %g4, %o5, %o5
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
40020e30: 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;
40020e34: 9a 03 40 0c add %o5, %o4, %o5
a += ((uint32_t)k[3])<<24;
b += k[4];
40020e38: 86 01 00 03 add %g4, %g3, %g3
b += ((uint32_t)k[5])<<8;
40020e3c: 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;
40020e40: d8 0a 20 03 ldub [ %o0 + 3 ], %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
40020e44: 89 29 20 08 sll %g4, 8, %g4
40020e48: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[6])<<16;
40020e4c: 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;
40020e50: 99 2b 20 18 sll %o4, 0x18, %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
40020e54: 89 29 20 10 sll %g4, 0x10, %g4
40020e58: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[7])<<24;
40020e5c: 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;
40020e60: 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;
40020e64: 89 29 20 18 sll %g4, 0x18, %g4
40020e68: 86 00 c0 04 add %g3, %g4, %g3
c += k[8];
40020e6c: 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;
40020e70: 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];
40020e74: 84 01 00 02 add %g4, %g2, %g2
c += ((uint32_t)k[9])<<8;
40020e78: c8 0a 20 09 ldub [ %o0 + 9 ], %g4
40020e7c: 89 29 20 08 sll %g4, 8, %g4
40020e80: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[10])<<16;
40020e84: c8 0a 20 0a ldub [ %o0 + 0xa ], %g4
40020e88: 89 29 20 10 sll %g4, 0x10, %g4
40020e8c: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[11])<<24;
40020e90: c8 0a 20 0b ldub [ %o0 + 0xb ], %g4
mix(a,b,c);
length -= 12;
k += 12;
40020e94: 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;
40020e98: 89 29 20 18 sll %g4, 0x18, %g4
40020e9c: 84 00 80 04 add %g2, %g4, %g2
mix(a,b,c);
40020ea0: 9a 23 40 02 sub %o5, %g2, %o5
40020ea4: 99 28 a0 04 sll %g2, 4, %o4
40020ea8: 89 30 a0 1c srl %g2, 0x1c, %g4
40020eac: 88 13 00 04 or %o4, %g4, %g4
40020eb0: 88 1b 40 04 xor %o5, %g4, %g4
40020eb4: 99 29 20 06 sll %g4, 6, %o4
40020eb8: 9b 31 20 1a srl %g4, 0x1a, %o5
40020ebc: 9a 13 00 0d or %o4, %o5, %o5
40020ec0: 84 00 80 03 add %g2, %g3, %g2
40020ec4: 86 20 c0 04 sub %g3, %g4, %g3
40020ec8: 86 1b 40 03 xor %o5, %g3, %g3
40020ecc: 99 28 e0 08 sll %g3, 8, %o4
40020ed0: 9b 30 e0 18 srl %g3, 0x18, %o5
40020ed4: 9a 13 00 0d or %o4, %o5, %o5
40020ed8: 88 01 00 02 add %g4, %g2, %g4
40020edc: 84 20 80 03 sub %g2, %g3, %g2
40020ee0: 84 1b 40 02 xor %o5, %g2, %g2
40020ee4: 99 28 a0 10 sll %g2, 0x10, %o4
40020ee8: 9b 30 a0 10 srl %g2, 0x10, %o5
40020eec: 9a 13 00 0d or %o4, %o5, %o5
40020ef0: 86 00 c0 04 add %g3, %g4, %g3
40020ef4: 88 21 00 02 sub %g4, %g2, %g4
40020ef8: 88 1b 40 04 xor %o5, %g4, %g4
40020efc: 99 29 20 13 sll %g4, 0x13, %o4
40020f00: 9b 31 20 0d srl %g4, 0xd, %o5
40020f04: 9a 13 00 0d or %o4, %o5, %o5
40020f08: 84 00 80 03 add %g2, %g3, %g2
40020f0c: 86 20 c0 04 sub %g3, %g4, %g3
40020f10: 88 01 00 02 add %g4, %g2, %g4
40020f14: 86 1b 40 03 xor %o5, %g3, %g3
40020f18: 84 20 80 03 sub %g2, %g3, %g2
40020f1c: 99 28 e0 04 sll %g3, 4, %o4
40020f20: 9b 30 e0 1c srl %g3, 0x1c, %o5
40020f24: 86 00 c0 04 add %g3, %g4, %g3
40020f28: 9a 13 00 0d or %o4, %o5, %o5
40020f2c: 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)
40020f30: 80 a2 60 0c cmp %o1, 0xc
40020f34: 38 bf ff b9 bgu,a 40020e18 <rtems_rfs_dir_hash+0x18>
40020f38: 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 */
40020f3c: 92 02 7f ff add %o1, -1, %o1
40020f40: 80 a2 60 0b cmp %o1, 0xb
40020f44: 18 80 00 4b bgu 40021070 <rtems_rfs_dir_hash+0x270> <== NEVER TAKEN
40020f48: 93 2a 60 02 sll %o1, 2, %o1
40020f4c: 1b 10 00 83 sethi %hi(0x40020c00), %o5
40020f50: 9a 13 61 d0 or %o5, 0x1d0, %o5 ! 40020dd0 <rtems_rfs_buffer_bdbuf_release+0x80>
40020f54: da 03 40 09 ld [ %o5 + %o1 ], %o5
40020f58: 81 c3 40 00 jmp %o5
40020f5c: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
40020f60: da 0a 20 0b ldub [ %o0 + 0xb ], %o5
40020f64: 9b 2b 60 18 sll %o5, 0x18, %o5
40020f68: 84 03 40 02 add %o5, %g2, %g2
case 11: c+=((uint32_t)k[10])<<16;
40020f6c: da 0a 20 0a ldub [ %o0 + 0xa ], %o5
40020f70: 9b 2b 60 10 sll %o5, 0x10, %o5
40020f74: 84 00 80 0d add %g2, %o5, %g2
case 10: c+=((uint32_t)k[9])<<8;
40020f78: da 0a 20 09 ldub [ %o0 + 9 ], %o5
40020f7c: 9b 2b 60 08 sll %o5, 8, %o5
40020f80: 84 00 80 0d add %g2, %o5, %g2
case 9 : c+=k[8];
40020f84: da 0a 20 08 ldub [ %o0 + 8 ], %o5
40020f88: 84 00 80 0d add %g2, %o5, %g2
case 8 : b+=((uint32_t)k[7])<<24;
40020f8c: da 0a 20 07 ldub [ %o0 + 7 ], %o5
40020f90: 9b 2b 60 18 sll %o5, 0x18, %o5
40020f94: 86 03 40 03 add %o5, %g3, %g3
case 7 : b+=((uint32_t)k[6])<<16;
40020f98: da 0a 20 06 ldub [ %o0 + 6 ], %o5
40020f9c: 9b 2b 60 10 sll %o5, 0x10, %o5
40020fa0: 86 00 c0 0d add %g3, %o5, %g3
case 6 : b+=((uint32_t)k[5])<<8;
40020fa4: da 0a 20 05 ldub [ %o0 + 5 ], %o5
40020fa8: 9b 2b 60 08 sll %o5, 8, %o5
40020fac: 86 00 c0 0d add %g3, %o5, %g3
case 5 : b+=k[4];
40020fb0: da 0a 20 04 ldub [ %o0 + 4 ], %o5
40020fb4: 86 00 c0 0d add %g3, %o5, %g3
case 4 : a+=((uint32_t)k[3])<<24;
40020fb8: da 0a 20 03 ldub [ %o0 + 3 ], %o5
40020fbc: 9b 2b 60 18 sll %o5, 0x18, %o5
40020fc0: 88 03 40 04 add %o5, %g4, %g4
case 3 : a+=((uint32_t)k[2])<<16;
40020fc4: da 0a 20 02 ldub [ %o0 + 2 ], %o5
40020fc8: 9b 2b 60 10 sll %o5, 0x10, %o5
40020fcc: 88 01 00 0d add %g4, %o5, %g4
case 2 : a+=((uint32_t)k[1])<<8;
40020fd0: da 0a 20 01 ldub [ %o0 + 1 ], %o5
40020fd4: 9b 2b 60 08 sll %o5, 8, %o5
40020fd8: 88 01 00 0d add %g4, %o5, %g4
case 1 : a+=k[0];
40020fdc: c2 0a 00 00 ldub [ %o0 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
40020fe0: 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];
40020fe4: 88 01 00 01 add %g4, %g1, %g4
break;
case 0 : return c;
}
}
final(a,b,c);
40020fe8: 83 28 e0 0e sll %g3, 0xe, %g1
40020fec: 82 13 40 01 or %o5, %g1, %g1
40020ff0: 84 18 80 03 xor %g2, %g3, %g2
40020ff4: 84 20 80 01 sub %g2, %g1, %g2
40020ff8: 9b 28 a0 0b sll %g2, 0xb, %o5
40020ffc: 83 30 a0 15 srl %g2, 0x15, %g1
40021000: 82 13 40 01 or %o5, %g1, %g1
40021004: 88 18 80 04 xor %g2, %g4, %g4
40021008: 88 21 00 01 sub %g4, %g1, %g4
4002100c: 9b 29 20 19 sll %g4, 0x19, %o5
40021010: 83 31 20 07 srl %g4, 7, %g1
40021014: 82 13 40 01 or %o5, %g1, %g1
40021018: 86 19 00 03 xor %g4, %g3, %g3
4002101c: 86 20 c0 01 sub %g3, %g1, %g3
40021020: 9b 28 e0 10 sll %g3, 0x10, %o5
40021024: 83 30 e0 10 srl %g3, 0x10, %g1
40021028: 82 13 40 01 or %o5, %g1, %g1
4002102c: 84 18 c0 02 xor %g3, %g2, %g2
40021030: 84 20 80 01 sub %g2, %g1, %g2
40021034: 9b 28 a0 04 sll %g2, 4, %o5
40021038: 83 30 a0 1c srl %g2, 0x1c, %g1
4002103c: 82 13 40 01 or %o5, %g1, %g1
40021040: 88 18 80 04 xor %g2, %g4, %g4
40021044: 88 21 00 01 sub %g4, %g1, %g4
40021048: 83 29 20 0e sll %g4, 0xe, %g1
4002104c: 86 19 00 03 xor %g4, %g3, %g3
40021050: 89 31 20 12 srl %g4, 0x12, %g4
40021054: 88 10 40 04 or %g1, %g4, %g4
40021058: 86 20 c0 04 sub %g3, %g4, %g3
4002105c: 84 18 c0 02 xor %g3, %g2, %g2
40021060: 83 28 e0 18 sll %g3, 0x18, %g1
40021064: 87 30 e0 08 srl %g3, 8, %g3
40021068: 86 10 40 03 or %g1, %g3, %g3
4002106c: 84 20 80 03 sub %g2, %g3, %g2
return c;
}
40021070: 81 c3 e0 08 retl
40021074: 90 10 00 02 mov %g2, %o0
4001c264 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
4001c264: 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))
4001c268: 90 10 20 00 clr %o0
4001c26c: 13 01 00 00 sethi %hi(0x4000000), %o1
4001c270: 7f ff de 66 call 40013c08 <rtems_rfs_trace>
4001c274: a0 10 00 18 mov %i0, %l0
4001c278: 80 8a 20 ff btst 0xff, %o0
4001c27c: 22 80 00 13 be,a 4001c2c8 <rtems_rfs_dir_lookup_ino+0x64><== ALWAYS TAKEN
4001c280: c0 27 00 00 clr [ %i4 ]
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001c284: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c288: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
4001c28c: 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=",
4001c290: 40 00 19 24 call 40022720 <printf> <== NOT EXECUTED
4001c294: 90 12 22 80 or %o0, 0x280, %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
4001c298: 10 80 00 05 b 4001c2ac <rtems_rfs_dir_lookup_ino+0x48> <== NOT EXECUTED
4001c29c: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
4001c2a0: 40 00 19 8a call 400228c8 <putchar> <== NOT EXECUTED
4001c2a4: 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++)
4001c2a8: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
4001c2ac: 26 bf ff fd bl,a 4001c2a0 <rtems_rfs_dir_lookup_ino+0x3c><== NOT EXECUTED
4001c2b0: d0 4e 80 18 ldsb [ %i2 + %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
4001c2b4: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c2b8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001c2bc: 40 00 19 19 call 40022720 <printf> <== NOT EXECUTED
4001c2c0: 90 12 22 b8 or %o0, 0x2b8, %o0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
4001c2c4: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
4001c2c8: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001c2cc: 90 10 00 10 mov %l0, %o0
4001c2d0: 92 10 00 19 mov %i1, %o1
4001c2d4: 7f ff fa 38 call 4001abb4 <rtems_rfs_block_map_open>
4001c2d8: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001c2dc: b0 92 20 00 orcc %o0, 0, %i0
4001c2e0: 04 80 00 12 ble 4001c328 <rtems_rfs_dir_lookup_ino+0xc4> <== ALWAYS TAKEN
4001c2e4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c2e8: 7f ff de 48 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c2ec: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001c2f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c2f4: 02 80 01 18 be 4001c754 <rtems_rfs_dir_lookup_ino+0x4f0> <== NOT EXECUTED
4001c2f8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
4001c2fc: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
4001c300: 40 00 1d 74 call 400238d0 <strerror> <== NOT EXECUTED
4001c304: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c308: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c30c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c310: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001c314: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c318: 40 00 19 02 call 40022720 <printf> <== NOT EXECUTED
4001c31c: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 40035ac8 <CSWTCH.2+0x688><== NOT EXECUTED
4001c320: 81 c7 e0 08 ret <== NOT EXECUTED
4001c324: 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);
4001c328: 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;
4001c32c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001c330: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001c334: c0 27 bf ac clr [ %fp + -84 ]
4001c338: 40 00 12 b2 call 40020e00 <rtems_rfs_dir_hash>
4001c33c: 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);
4001c340: 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);
4001c344: 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);
4001c348: 94 10 20 00 clr %o2
4001c34c: 90 10 00 10 mov %l0, %o0
4001c350: 96 10 20 00 clr %o3
4001c354: 7f ff fb 49 call 4001b078 <rtems_rfs_block_map_seek>
4001c358: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001c35c: b0 92 20 00 orcc %o0, 0, %i0
4001c360: 04 80 00 d3 ble 4001c6ac <rtems_rfs_dir_lookup_ino+0x448> <== ALWAYS TAKEN
4001c364: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c368: 7f ff de 28 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c36c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001c370: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c374: 02 80 00 0a be 4001c39c <rtems_rfs_dir_lookup_ino+0x138> <== NOT EXECUTED
4001c378: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
4001c37c: 40 00 1d 55 call 400238d0 <strerror> <== NOT EXECUTED
4001c380: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c384: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001c388: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001c38c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c390: 40 00 18 e4 call 40022720 <printf> <== NOT EXECUTED
4001c394: 90 12 23 08 or %o0, 0x308, %o0 ! 40035b08 <CSWTCH.2+0x6c8><== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
4001c398: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
4001c39c: 22 80 00 dc be,a 4001c70c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
4001c3a0: 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);
4001c3a4: 10 80 00 db b 4001c710 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
4001c3a8: 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))
4001c3ac: 7f ff de 17 call 40013c08 <rtems_rfs_trace>
4001c3b0: 13 01 00 00 sethi %hi(0x4000000), %o1
4001c3b4: 80 8a 20 ff btst 0xff, %o0
4001c3b8: 02 80 00 08 be 4001c3d8 <rtems_rfs_dir_lookup_ino+0x174> <== ALWAYS TAKEN
4001c3bc: d4 07 bf a0 ld [ %fp + -96 ], %o2
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001c3c0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c3c4: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
4001c3c8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c3cc: 40 00 18 d5 call 40022720 <printf> <== NOT EXECUTED
4001c3d0: 90 12 23 48 or %o0, 0x348, %o0 ! 40035b48 <CSWTCH.2+0x708><== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001c3d4: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
4001c3d8: 90 10 00 10 mov %l0, %o0
4001c3dc: 92 07 bf a4 add %fp, -92, %o1
4001c3e0: 7f ff fd e2 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001c3e4: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001c3e8: a2 92 20 00 orcc %o0, 0, %l1
4001c3ec: 04 80 00 15 ble 4001c440 <rtems_rfs_dir_lookup_ino+0x1dc> <== ALWAYS TAKEN
4001c3f0: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c3f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c3f8: 7f ff de 04 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c3fc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001c400: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c404: 22 80 00 c2 be,a 4001c70c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
4001c408: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
4001c40c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001c410: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
4001c414: 40 00 1d 2f call 400238d0 <strerror> <== NOT EXECUTED
4001c418: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001c41c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001c420: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001c424: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001c428: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4001c42c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001c430: 40 00 18 bc call 40022720 <printf> <== NOT EXECUTED
4001c434: 90 12 23 80 or %o0, 0x380, %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;
4001c438: 10 80 00 b5 b 4001c70c <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
4001c43c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
4001c440: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c444: 10 80 00 71 b 4001c608 <rtems_rfs_dir_lookup_ino+0x3a4>
4001c448: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001c44c: c8 0c a0 04 ldub [ %l2 + 4 ], %g4
4001c450: 85 28 a0 10 sll %g2, 0x10, %g2
4001c454: 89 29 20 18 sll %g4, 0x18, %g4
4001c458: 88 11 00 02 or %g4, %g2, %g4
4001c45c: c4 0c a0 07 ldub [ %l2 + 7 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
4001c460: 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);
4001c464: 88 11 00 02 or %g4, %g2, %g4
4001c468: c4 0c a0 06 ldub [ %l2 + 6 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
4001c46c: 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);
4001c470: 85 28 a0 08 sll %g2, 8, %g2
4001c474: 88 11 00 02 or %g4, %g2, %g4
elength = rtems_rfs_dir_entry_length (entry);
4001c478: c4 0c a0 08 ldub [ %l2 + 8 ], %g2
*ino = rtems_rfs_dir_entry_ino (entry);
4001c47c: 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);
4001c480: 85 28 a0 08 sll %g2, 8, %g2
4001c484: a6 10 80 03 or %g2, %g3, %l3
*ino = rtems_rfs_dir_entry_ino (entry);
4001c488: c6 0c a0 01 ldub [ %l2 + 1 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c48c: 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);
4001c490: 87 28 e0 10 sll %g3, 0x10, %g3
4001c494: 86 13 c0 03 or %o7, %g3, %g3
4001c498: de 0c a0 03 ldub [ %l2 + 3 ], %o7
4001c49c: 86 10 c0 0f or %g3, %o7, %g3
4001c4a0: de 0c a0 02 ldub [ %l2 + 2 ], %o7
4001c4a4: 9f 2b e0 08 sll %o7, 8, %o7
4001c4a8: 86 10 c0 0f or %g3, %o7, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c4ac: 12 80 00 07 bne 4001c4c8 <rtems_rfs_dir_lookup_ino+0x264>
4001c4b0: c6 27 00 00 st %g3, [ %i4 ]
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001c4b4: 80 a4 60 00 cmp %l1, 0
4001c4b8: 32 80 00 85 bne,a 4001c6cc <rtems_rfs_dir_lookup_ino+0x468><== NEVER TAKEN
4001c4bc: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c4c0: 10 80 00 5a b 4001c628 <rtems_rfs_dir_lookup_ino+0x3c4>
4001c4c4: 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))
4001c4c8: 80 a4 e0 0a cmp %l3, 0xa
4001c4cc: 34 80 00 0a bg,a 4001c4f4 <rtems_rfs_dir_lookup_ino+0x290><== ALWAYS TAKEN
4001c4d0: de 04 20 1c ld [ %l0 + 0x1c ], %o7
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c4d4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c4d8: 7f ff dd cc call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c4dc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001c4e0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c4e4: 22 80 00 70 be,a 4001c6a4 <rtems_rfs_dir_lookup_ino+0x440><== NOT EXECUTED
4001c4e8: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001c4ec: 10 80 00 0c b 4001c51c <rtems_rfs_dir_lookup_ino+0x2b8> <== NOT EXECUTED
4001c4f0: 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))
4001c4f4: 80 a4 c0 0f cmp %l3, %o7
4001c4f8: 1a bf ff f7 bcc 4001c4d4 <rtems_rfs_dir_lookup_ino+0x270> <== NEVER TAKEN
4001c4fc: 80 a0 e0 00 cmp %g3, 0
4001c500: 02 bf ff f6 be 4001c4d8 <rtems_rfs_dir_lookup_ino+0x274> <== NEVER TAKEN
4001c504: 90 10 20 00 clr %o0
4001c508: de 04 20 14 ld [ %l0 + 0x14 ], %o7
4001c50c: 80 a0 c0 0f cmp %g3, %o7
4001c510: 08 80 00 0a bleu 4001c538 <rtems_rfs_dir_lookup_ino+0x2d4><== ALWAYS TAKEN
4001c514: c2 07 bf 9c ld [ %fp + -100 ], %g1
4001c518: 30 bf ff f0 b,a 4001c4d8 <rtems_rfs_dir_lookup_ino+0x274><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001c51c: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001c520: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001c524: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4001c528: 40 00 18 7e call 40022720 <printf> <== NOT EXECUTED
4001c52c: 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;
4001c530: 10 80 00 5d b 4001c6a4 <rtems_rfs_dir_lookup_ino+0x440> <== NOT EXECUTED
4001c534: 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)
4001c538: 80 a1 00 01 cmp %g4, %g1
4001c53c: 12 80 00 30 bne 4001c5fc <rtems_rfs_dir_lookup_ino+0x398>
4001c540: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001c544: 90 10 20 00 clr %o0
4001c548: 7f ff dd b0 call 40013c08 <rtems_rfs_trace>
4001c54c: 13 02 00 00 sethi %hi(0x8000000), %o1
4001c550: 80 8a 20 ff btst 0xff, %o0
4001c554: 02 80 00 12 be 4001c59c <rtems_rfs_dir_lookup_ino+0x338> <== ALWAYS TAKEN
4001c558: 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));
4001c55c: c6 0c a0 01 ldub [ %l2 + 1 ], %g3 <== NOT EXECUTED
4001c560: da 0c 80 00 ldub [ %l2 ], %o5 <== NOT EXECUTED
4001c564: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4001c568: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
4001c56c: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
4001c570: 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: "
4001c574: 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));
4001c578: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
4001c57c: 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: "
4001c580: 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));
4001c584: 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: "
4001c588: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
4001c58c: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
4001c590: 40 00 18 64 call 40022720 <printf> <== NOT EXECUTED
4001c594: 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)
4001c598: 90 04 a0 0a add %l2, 0xa, %o0 <== NOT EXECUTED
4001c59c: 92 10 00 1a mov %i2, %o1
4001c5a0: 40 00 17 29 call 40022244 <memcmp>
4001c5a4: 94 10 00 1b mov %i3, %o2
4001c5a8: 80 a2 20 00 cmp %o0, 0
4001c5ac: 12 80 00 14 bne 4001c5fc <rtems_rfs_dir_lookup_ino+0x398> <== NEVER TAKEN
4001c5b0: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
*offset = rtems_rfs_block_map_pos (fs, &map);
4001c5b4: 90 10 00 10 mov %l0, %o0
4001c5b8: 7f ff f9 48 call 4001aad8 <rtems_rfs_block_get_pos>
4001c5bc: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001c5c0: 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);
4001c5c4: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001c5c8: 7f ff dd 90 call 40013c08 <rtems_rfs_trace>
4001c5cc: 13 04 00 00 sethi %hi(0x10000000), %o1
4001c5d0: 80 8a 20 ff btst 0xff, %o0
4001c5d4: 22 80 00 4f be,a 4001c710 <rtems_rfs_dir_lookup_ino+0x4ac><== ALWAYS TAKEN
4001c5d8: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
4001c5dc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c5e0: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4001c5e4: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001c5e8: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c5ec: 40 00 18 4d call 40022720 <printf> <== NOT EXECUTED
4001c5f0: 90 12 20 78 or %o0, 0x78, %o0 ! 40035c78 <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);
4001c5f4: 10 80 00 47 b 4001c710 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
4001c5f8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
4001c5fc: a4 04 80 13 add %l2, %l3, %l2
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
4001c600: 86 00 c0 13 add %g3, %l3, %g3
4001c604: 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))
4001c608: c4 04 20 08 ld [ %l0 + 8 ], %g2
4001c60c: c6 07 bf c4 ld [ %fp + -60 ], %g3
4001c610: 84 00 bf f6 add %g2, -10, %g2
4001c614: 80 a0 c0 02 cmp %g3, %g2
4001c618: 2a bf ff 8d bcs,a 4001c44c <rtems_rfs_dir_lookup_ino+0x1e8><== ALWAYS TAKEN
4001c61c: c4 0c a0 05 ldub [ %l2 + 5 ], %g2
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001c620: 10 bf ff a6 b 4001c4b8 <rtems_rfs_dir_lookup_ino+0x254> <== NOT EXECUTED
4001c624: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c628: 92 07 bf b0 add %fp, -80, %o1
4001c62c: 7f ff fa b0 call 4001b0ec <rtems_rfs_block_map_next_block>
4001c630: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
4001c634: 80 a2 20 06 cmp %o0, 6
4001c638: 02 80 00 05 be 4001c64c <rtems_rfs_dir_lookup_ino+0x3e8> <== ALWAYS TAKEN
4001c63c: b0 10 00 08 mov %o0, %i0
4001c640: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c644: 14 80 00 07 bg 4001c660 <rtems_rfs_dir_lookup_ino+0x3fc> <== NOT EXECUTED
4001c648: 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)
4001c64c: 80 a6 20 06 cmp %i0, 6
4001c650: 12 80 00 20 bne 4001c6d0 <rtems_rfs_dir_lookup_ino+0x46c> <== NEVER TAKEN
4001c654: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
4001c658: 10 80 00 11 b 4001c69c <rtems_rfs_dir_lookup_ino+0x438>
4001c65c: 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))
4001c660: 7f ff dd 6a call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c664: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001c668: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c66c: 22 bf ff f9 be,a 4001c650 <rtems_rfs_dir_lookup_ino+0x3ec><== NOT EXECUTED
4001c670: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001c674: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
4001c678: 40 00 1c 96 call 400238d0 <strerror> <== NOT EXECUTED
4001c67c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c680: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001c684: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c688: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001c68c: 40 00 18 25 call 40022720 <printf> <== NOT EXECUTED
4001c690: 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)
4001c694: 10 80 00 0f b 4001c6d0 <rtems_rfs_dir_lookup_ino+0x46c> <== NOT EXECUTED
4001c698: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001c69c: 10 80 00 25 b 4001c730 <rtems_rfs_dir_lookup_ino+0x4cc>
4001c6a0: 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;
4001c6a4: 10 80 00 0a b 4001c6cc <rtems_rfs_dir_lookup_ino+0x468> <== NOT EXECUTED
4001c6a8: 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)
4001c6ac: 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: "
4001c6b0: 2b 10 00 d7 sethi %hi(0x40035c00), %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: "
4001c6b4: 2d 10 00 d7 sethi %hi(0x40035c00), %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: "
4001c6b8: 2f 10 00 d6 sethi %hi(0x40035800), %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)
4001c6bc: 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: "
4001c6c0: aa 15 60 18 or %l5, 0x18, %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: "
4001c6c4: ac 15 a0 c0 or %l6, 0xc0, %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: "
4001c6c8: ae 15 e3 c8 or %l7, 0x3c8, %l7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001c6cc: 80 a6 20 00 cmp %i0, 0
4001c6d0: 12 80 00 17 bne 4001c72c <rtems_rfs_dir_lookup_ino+0x4c8> <== NEVER TAKEN
4001c6d4: c2 07 bf a0 ld [ %fp + -96 ], %g1
4001c6d8: 80 a0 60 00 cmp %g1, 0
4001c6dc: 12 bf ff 34 bne 4001c3ac <rtems_rfs_dir_lookup_ino+0x148> <== ALWAYS TAKEN
4001c6e0: 90 10 20 00 clr %o0
4001c6e4: 30 80 00 15 b,a 4001c738 <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",
4001c6e8: 40 00 1c 7a call 400238d0 <strerror> <== NOT EXECUTED
4001c6ec: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
4001c6f0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001c6f4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001c6f8: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
4001c6fc: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001c700: 40 00 18 08 call 40022720 <printf> <== NOT EXECUTED
4001c704: 90 12 21 10 or %o0, 0x110, %o0 ! 40035d10 <CSWTCH.2+0x8d0><== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
4001c708: 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);
4001c70c: 92 07 bf a4 add %fp, -92, %o1
4001c710: 7f ff fe cb call 4001c23c <rtems_rfs_buffer_handle_close>
4001c714: 90 10 00 10 mov %l0, %o0
rtems_rfs_block_map_close (fs, &map);
4001c718: 90 10 00 10 mov %l0, %o0
4001c71c: 7f ff f9 87 call 4001ad38 <rtems_rfs_block_map_close>
4001c720: 92 07 bf b0 add %fp, -80, %o1
4001c724: 81 c7 e0 08 ret
4001c728: 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)
4001c72c: 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;
4001c730: 10 bf ff f7 b 4001c70c <rtems_rfs_dir_lookup_ino+0x4a8>
4001c734: b0 10 00 11 mov %l1, %i0
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c738: 7f ff dd 34 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001c73c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001c740: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c744: 32 bf ff e9 bne,a 4001c6e8 <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED
4001c748: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
4001c74c: 10 bf ff f0 b 4001c70c <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
4001c750: 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;
}
4001c754: 81 c7 e0 08 ret <== NOT EXECUTED
4001c758: 81 e8 00 00 restore <== NOT EXECUTED
4001cee0 <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)
{
4001cee0: 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))
4001cee4: 90 10 20 00 clr %o0
4001cee8: 7f ff db 48 call 40013c08 <rtems_rfs_trace>
4001ceec: 13 20 00 00 sethi %hi(0x80000000), %o1
4001cef0: 80 8a 20 ff btst 0xff, %o0
4001cef4: 22 80 00 09 be,a 4001cf18 <rtems_rfs_dir_read+0x38> <== ALWAYS TAKEN
4001cef8: c0 27 40 00 clr [ %i5 ]
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
4001cefc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001cf00: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001cf04: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001cf08: 90 12 20 30 or %o0, 0x30, %o0 <== NOT EXECUTED
4001cf0c: 40 00 16 05 call 40022720 <printf> <== NOT EXECUTED
4001cf10: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
4001cf14: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001cf18: 90 10 00 18 mov %i0, %o0
4001cf1c: 92 10 00 19 mov %i1, %o1
4001cf20: 7f ff f7 25 call 4001abb4 <rtems_rfs_block_map_open>
4001cf24: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001cf28: a0 92 20 00 orcc %o0, 0, %l0
4001cf2c: 14 80 00 d1 bg 4001d270 <rtems_rfs_dir_read+0x390> <== NEVER TAKEN
4001cf30: 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))
4001cf34: e0 06 20 08 ld [ %i0 + 8 ], %l0
4001cf38: a2 10 00 10 mov %l0, %l1
4001cf3c: 92 10 00 1b mov %i3, %o1
4001cf40: a0 10 20 00 clr %l0
4001cf44: 96 10 00 11 mov %l1, %o3
4001cf48: 40 00 49 89 call 4002f56c <__moddi3>
4001cf4c: 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) -
4001cf50: 92 a4 40 09 subcc %l1, %o1, %o1
4001cf54: 90 64 00 08 subx %l0, %o0, %o0
4001cf58: 80 a2 20 00 cmp %o0, 0
4001cf5c: 34 80 00 17 bg,a 4001cfb8 <rtems_rfs_dir_read+0xd8> <== NEVER TAKEN
4001cf60: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
4001cf64: 80 a2 20 00 cmp %o0, 0
4001cf68: 12 80 00 06 bne 4001cf80 <rtems_rfs_dir_read+0xa0> <== NEVER TAKEN
4001cf6c: 90 10 00 1a mov %i2, %o0
4001cf70: 80 a2 60 0a cmp %o1, 0xa
4001cf74: 38 80 00 11 bgu,a 4001cfb8 <rtems_rfs_dir_read+0xd8> <== ALWAYS TAKEN
4001cf78: 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) *
4001cf7c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001cf80: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001cf84: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001cf88: 40 00 48 8e call 4002f1c0 <__divdi3> <== NOT EXECUTED
4001cf8c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001cf90: 86 82 60 01 addcc %o1, 1, %g3 <== NOT EXECUTED
4001cf94: 84 42 20 00 addx %o0, 0, %g2 <== NOT EXECUTED
4001cf98: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
4001cf9c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
4001cfa0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001cfa4: 40 00 48 43 call 4002f0b0 <__muldi3> <== NOT EXECUTED
4001cfa8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001cfac: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
4001cfb0: 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);
4001cfb4: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
4001cfb8: a4 07 bf a0 add %fp, -96, %l2
4001cfbc: 90 10 00 18 mov %i0, %o0
4001cfc0: 92 10 00 11 mov %l1, %o1
4001cfc4: 94 10 00 1a mov %i2, %o2
4001cfc8: 96 10 00 1b mov %i3, %o3
4001cfcc: 7f ff f8 2b call 4001b078 <rtems_rfs_block_map_seek>
4001cfd0: 98 10 00 12 mov %l2, %o4
if (rc > 0)
4001cfd4: a0 92 20 00 orcc %o0, 0, %l0
4001cfd8: 04 80 00 07 ble 4001cff4 <rtems_rfs_dir_read+0x114> <== ALWAYS TAKEN
4001cfdc: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
4001cfe0: 22 80 00 02 be,a 4001cfe8 <rtems_rfs_dir_read+0x108> <== NOT EXECUTED
4001cfe4: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
4001cfe8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cfec: 10 80 00 9f b 4001d268 <rtems_rfs_dir_read+0x388> <== NOT EXECUTED
4001cff0: 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)
4001cff4: 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",
4001cff8: 2d 10 00 d8 sethi %hi(0x40036000), %l6
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001cffc: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001d000: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001d004: 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)
4001d008: 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",
4001d00c: ac 15 a0 e0 or %l6, 0xe0, %l6
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d010: ae 10 00 11 mov %l1, %l7
4001d014: 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);
4001d018: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001d01c: 90 10 00 18 mov %i0, %o0
4001d020: 92 07 bf a4 add %fp, -92, %o1
4001d024: 7f ff fa d1 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001d028: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001d02c: a0 92 20 00 orcc %o0, 0, %l0
4001d030: 04 80 00 04 ble 4001d040 <rtems_rfs_dir_read+0x160> <== ALWAYS TAKEN
4001d034: 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);
4001d038: 10 80 00 88 b 4001d258 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001d03c: 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;
4001d040: 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);
4001d044: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
entry += map.bpos.boff;
4001d048: a2 00 40 13 add %g1, %l3, %l1
elength = rtems_rfs_dir_entry_length (entry);
4001d04c: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
4001d050: e4 0c 60 08 ldub [ %l1 + 8 ], %l2
eino = rtems_rfs_dir_entry_ino (entry);
4001d054: 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);
4001d058: a5 2c a0 08 sll %l2, 8, %l2
eino = rtems_rfs_dir_entry_ino (entry);
4001d05c: 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);
4001d060: a4 14 80 02 or %l2, %g2, %l2
eino = rtems_rfs_dir_entry_ino (entry);
4001d064: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d068: 80 a4 80 15 cmp %l2, %l5
4001d06c: 02 80 00 5d be 4001d1e0 <rtems_rfs_dir_read+0x300>
4001d070: 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);
4001d074: a9 29 20 18 sll %g4, 0x18, %l4
4001d078: 86 08 e0 ff and %g3, 0xff, %g3
4001d07c: 84 08 a0 ff and %g2, 0xff, %g2
4001d080: 87 28 e0 10 sll %g3, 0x10, %g3
4001d084: 82 08 60 ff and %g1, 0xff, %g1
4001d088: a8 15 00 03 or %l4, %g3, %l4
4001d08c: 83 28 60 08 sll %g1, 8, %g1
4001d090: a8 15 00 02 or %l4, %g2, %l4
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d094: 80 a4 a0 0a cmp %l2, 0xa
4001d098: 04 80 00 0d ble 4001d0cc <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
4001d09c: a8 15 00 01 or %l4, %g1, %l4
4001d0a0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001d0a4: 80 a4 80 01 cmp %l2, %g1
4001d0a8: 1a 80 00 0a bcc 4001d0d0 <rtems_rfs_dir_read+0x1f0> <== NEVER TAKEN
4001d0ac: 90 10 20 00 clr %o0
4001d0b0: 80 a5 20 00 cmp %l4, 0
4001d0b4: 02 80 00 08 be 4001d0d4 <rtems_rfs_dir_read+0x1f4> <== NEVER TAKEN
4001d0b8: 13 20 00 00 sethi %hi(0x80000000), %o1
4001d0bc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001d0c0: 80 a5 00 01 cmp %l4, %g1
4001d0c4: 08 80 00 12 bleu 4001d10c <rtems_rfs_dir_read+0x22c> <== ALWAYS TAKEN
4001d0c8: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d0cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d0d0: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
4001d0d4: 7f ff da cd call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001d0d8: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
4001d0dc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d0e0: 22 80 00 5e be,a 4001d258 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001d0e4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
4001d0e8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d0ec: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001d0f0: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d0f4: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001d0f8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001d0fc: 40 00 15 89 call 40022720 <printf> <== NOT EXECUTED
4001d100: 90 12 20 60 or %o0, 0x60, %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);
4001d104: 10 80 00 55 b 4001d258 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001d108: 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));
4001d10c: 92 10 20 00 clr %o1
4001d110: 40 00 15 06 call 40022528 <memset>
4001d114: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
4001d118: 82 10 21 18 mov 0x118, %g1
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
4001d11c: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
4001d120: c2 37 20 10 sth %g1, [ %i4 + 0x10 ]
*length += elength;
4001d124: c2 07 40 00 ld [ %i5 ], %g1
4001d128: 82 04 80 01 add %l2, %g1, %g1
4001d12c: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001d130: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001d134: a6 20 80 13 sub %g2, %l3, %l3
4001d138: a6 24 c0 12 sub %l3, %l2, %l3
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
4001d13c: 80 a4 e0 0a cmp %l3, 0xa
4001d140: 14 80 00 04 bg 4001d150 <rtems_rfs_dir_read+0x270> <== ALWAYS TAKEN
4001d144: a4 04 bf f6 add %l2, -10, %l2
*length += remaining;
4001d148: 82 04 c0 01 add %l3, %g1, %g1 <== NOT EXECUTED
4001d14c: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
4001d150: 80 a4 a0 ff cmp %l2, 0xff
4001d154: 34 80 00 02 bg,a 4001d15c <rtems_rfs_dir_read+0x27c> <== NEVER TAKEN
4001d158: 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);
4001d15c: 92 04 60 0a add %l1, 0xa, %o1
4001d160: 94 10 00 12 mov %l2, %o2
4001d164: ba 07 20 14 add %i4, 0x14, %i5
4001d168: 40 00 14 61 call 400222ec <memcpy>
4001d16c: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001d170: c4 0c 40 00 ldub [ %l1 ], %g2
4001d174: c2 0c 60 01 ldub [ %l1 + 1 ], %g1
4001d178: 85 28 a0 18 sll %g2, 0x18, %g2
4001d17c: 83 28 60 10 sll %g1, 0x10, %g1
4001d180: 82 10 80 01 or %g2, %g1, %g1
4001d184: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d188: 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);
4001d18c: 82 10 40 02 or %g1, %g2, %g1
4001d190: c4 0c 60 02 ldub [ %l1 + 2 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d194: 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);
4001d198: 85 28 a0 08 sll %g2, 8, %g2
4001d19c: 82 10 40 02 or %g1, %g2, %g1
dirent->d_namlen = elength;
4001d1a0: e4 37 20 12 sth %l2, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d1a4: 7f ff da 99 call 40013c08 <rtems_rfs_trace>
4001d1a8: c2 27 00 00 st %g1, [ %i4 ]
4001d1ac: 80 8a 20 ff btst 0xff, %o0
4001d1b0: 22 80 00 2a be,a 4001d258 <rtems_rfs_dir_read+0x378> <== ALWAYS TAKEN
4001d1b4: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001d1b8: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
4001d1bc: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001d1c0: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d1c4: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
4001d1c8: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
4001d1cc: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
4001d1d0: 40 00 15 54 call 40022720 <printf> <== NOT EXECUTED
4001d1d4: 90 12 20 a8 or %o0, 0xa8, %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);
4001d1d8: 10 80 00 20 b 4001d258 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001d1dc: 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;
4001d1e0: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d1e4: 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;
4001d1e8: a6 20 40 13 sub %g1, %l3, %l3
4001d1ec: c2 07 40 00 ld [ %i5 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d1f0: 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;
4001d1f4: a6 00 40 13 add %g1, %l3, %l3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d1f8: 7f ff da 84 call 40013c08 <rtems_rfs_trace>
4001d1fc: e6 27 40 00 st %l3, [ %i5 ]
4001d200: 80 8a 20 ff btst 0xff, %o0
4001d204: 02 80 00 08 be 4001d224 <rtems_rfs_dir_read+0x344> <== ALWAYS TAKEN
4001d208: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001d20c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001d210: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
4001d214: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001d218: 40 00 15 42 call 40022720 <printf> <== NOT EXECUTED
4001d21c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d220: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d224: 92 10 00 17 mov %l7, %o1
4001d228: 7f ff f7 b1 call 4001b0ec <rtems_rfs_block_map_next_block>
4001d22c: 94 10 00 14 mov %l4, %o2
if (rc == ENXIO)
4001d230: 80 a2 20 06 cmp %o0, 6
4001d234: 02 80 00 07 be 4001d250 <rtems_rfs_dir_read+0x370> <== ALWAYS TAKEN
4001d238: 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)
4001d23c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d240: 02 bf ff 77 be 4001d01c <rtems_rfs_dir_read+0x13c> <== NOT EXECUTED
4001d244: 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);
4001d248: 10 80 00 04 b 4001d258 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
4001d24c: 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;
4001d250: a0 10 20 02 mov 2, %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
4001d254: 92 07 bf a4 add %fp, -92, %o1
4001d258: 7f ff fb f9 call 4001c23c <rtems_rfs_buffer_handle_close>
4001d25c: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001d260: 90 10 00 18 mov %i0, %o0
4001d264: 92 07 bf b0 add %fp, -80, %o1
4001d268: 7f ff f6 b4 call 4001ad38 <rtems_rfs_block_map_close>
4001d26c: 01 00 00 00 nop
return rc;
}
4001d270: 81 c7 e0 08 ret
4001d274: 91 e8 00 10 restore %g0, %l0, %o0
4001d4cc <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
4001d4cc: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001d4d0: 90 10 20 10 mov 0x10, %o0
4001d4d4: 7f ff d9 cd call 40013c08 <rtems_rfs_trace>
4001d4d8: 92 10 20 00 clr %o1
4001d4dc: 80 8a 20 ff btst 0xff, %o0
4001d4e0: 22 80 00 08 be,a 4001d500 <rtems_rfs_file_close+0x34> <== ALWAYS TAKEN
4001d4e4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
4001d4e8: 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",
4001d4ec: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d4f0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
4001d4f4: 40 00 14 8b call 40022720 <printf> <== NOT EXECUTED
4001d4f8: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
4001d4fc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
4001d500: c2 02 60 08 ld [ %o1 + 8 ], %g1
4001d504: 80 a0 60 00 cmp %g1, 0
4001d508: 04 80 00 03 ble 4001d514 <rtems_rfs_file_close+0x48> <== NEVER TAKEN
4001d50c: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
4001d510: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
4001d514: c2 02 60 08 ld [ %o1 + 8 ], %g1
4001d518: 80 a0 60 00 cmp %g1, 0
4001d51c: 12 80 00 7e bne 4001d714 <rtems_rfs_file_close+0x248> <== NEVER TAKEN
4001d520: ba 10 20 00 clr %i5
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
4001d524: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001d528: 80 a0 60 00 cmp %g1, 0
4001d52c: 32 80 00 09 bne,a 4001d550 <rtems_rfs_file_close+0x84> <== NEVER TAKEN
4001d530: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
4001d534: 90 10 00 18 mov %i0, %o0
4001d538: 7f ff d2 fe call 40012130 <rtems_rfs_inode_load>
4001d53c: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
4001d540: ba 92 20 00 orcc %o0, 0, %i5
4001d544: 32 80 00 3f bne,a 4001d640 <rtems_rfs_file_close+0x174> <== NEVER TAKEN
4001d548: 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,
4001d54c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001d550: 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);
4001d554: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001d558: 89 30 a0 18 srl %g2, 0x18, %g4
4001d55c: c8 28 e0 10 stb %g4, [ %g3 + 0x10 ]
4001d560: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001d564: 89 30 a0 10 srl %g2, 0x10, %g4
4001d568: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
4001d56c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001d570: 89 30 a0 08 srl %g2, 8, %g4
4001d574: c8 28 e0 12 stb %g4, [ %g3 + 0x12 ]
4001d578: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
4001d57c: c4 28 e0 13 stb %g2, [ %g3 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001d580: 86 10 20 01 mov 1, %g3
4001d584: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
4001d588: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001d58c: 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);
4001d590: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d594: bb 30 a0 18 srl %g2, 0x18, %i5
4001d598: fa 29 20 14 stb %i5, [ %g4 + 0x14 ]
4001d59c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5a0: bb 30 a0 10 srl %g2, 0x10, %i5
4001d5a4: fa 29 20 15 stb %i5, [ %g4 + 0x15 ]
4001d5a8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5ac: bb 30 a0 08 srl %g2, 8, %i5
4001d5b0: fa 29 20 16 stb %i5, [ %g4 + 0x16 ]
4001d5b4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5b8: c4 29 20 17 stb %g2, [ %g4 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001d5bc: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
4001d5c0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001d5c4: 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);
4001d5c8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5cc: bb 30 a0 18 srl %g2, 0x18, %i5
4001d5d0: fa 29 20 18 stb %i5, [ %g4 + 0x18 ]
4001d5d4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5d8: bb 30 a0 10 srl %g2, 0x10, %i5
4001d5dc: fa 29 20 19 stb %i5, [ %g4 + 0x19 ]
4001d5e0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5e4: bb 30 a0 08 srl %g2, 8, %i5
4001d5e8: fa 29 20 1a stb %i5, [ %g4 + 0x1a ]
4001d5ec: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001d5f0: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001d5f4: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001d5f8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001d5fc: c4 00 60 84 ld [ %g1 + 0x84 ], %g2
4001d600: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
4001d604: 80 a0 80 03 cmp %g2, %g3
4001d608: 32 80 00 08 bne,a 4001d628 <rtems_rfs_file_close+0x15c> <== NEVER TAKEN
4001d60c: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
4001d610: c8 00 60 88 ld [ %g1 + 0x88 ], %g4
4001d614: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
4001d618: 80 a1 00 03 cmp %g4, %g3
4001d61c: 02 80 00 08 be 4001d63c <rtems_rfs_file_close+0x170> <== ALWAYS TAKEN
4001d620: 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);
4001d624: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
4001d628: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 <== NOT EXECUTED
map->dirty = true;
4001d62c: 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);
4001d630: c4 20 60 40 st %g2, [ %g1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001d634: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4001d638: 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);
4001d63c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001d640: 90 10 00 18 mov %i0, %o0
4001d644: 7f ff f5 bd call 4001ad38 <rtems_rfs_block_map_close>
4001d648: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001d64c: b8 92 20 00 orcc %o0, 0, %i4
4001d650: 04 80 00 14 ble 4001d6a0 <rtems_rfs_file_close+0x1d4> <== ALWAYS TAKEN
4001d654: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001d658: 7f ff d9 6c call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001d65c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d660: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d664: 02 80 00 0d be 4001d698 <rtems_rfs_file_close+0x1cc> <== NOT EXECUTED
4001d668: 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));
4001d66c: 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",
4001d670: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001d674: 40 00 18 97 call 400238d0 <strerror> <== NOT EXECUTED
4001d678: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001d67c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001d680: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d684: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001d688: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d68c: 40 00 14 25 call 40022720 <printf> <== NOT EXECUTED
4001d690: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400361a8 <CSWTCH.2+0xd68><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001d694: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4001d698: 22 80 00 02 be,a 4001d6a0 <rtems_rfs_file_close+0x1d4> <== NOT EXECUTED
4001d69c: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001d6a0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001d6a4: 90 10 00 18 mov %i0, %o0
4001d6a8: 7f ff d3 41 call 400123ac <rtems_rfs_inode_close>
4001d6ac: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
4001d6b0: b8 92 20 00 orcc %o0, 0, %i4
4001d6b4: 04 80 00 14 ble 4001d704 <rtems_rfs_file_close+0x238> <== ALWAYS TAKEN
4001d6b8: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001d6bc: 7f ff d9 53 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001d6c0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d6c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d6c8: 02 80 00 0d be 4001d6fc <rtems_rfs_file_close+0x230> <== NOT EXECUTED
4001d6cc: 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));
4001d6d0: 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",
4001d6d4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001d6d8: 40 00 18 7e call 400238d0 <strerror> <== NOT EXECUTED
4001d6dc: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001d6e0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001d6e4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d6e8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001d6ec: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d6f0: 40 00 14 0c call 40022720 <printf> <== NOT EXECUTED
4001d6f4: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 400361e8 <CSWTCH.2+0xda8><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001d6f8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4001d6fc: 22 80 00 02 be,a 4001d704 <rtems_rfs_file_close+0x238> <== NOT EXECUTED
4001d700: 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 );
4001d704: 7f ff ec ac call 400189b4 <_Chain_Extract>
4001d708: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
4001d70c: 7f ff ac 24 call 4000879c <free>
4001d710: 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);
4001d714: 90 10 00 18 mov %i0, %o0
4001d718: 7f ff f8 a0 call 4001b998 <rtems_rfs_buffer_handle_release>
4001d71c: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
4001d720: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
4001d724: 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)
4001d728: 80 a7 60 00 cmp %i5, 0
4001d72c: 04 80 00 0f ble 4001d768 <rtems_rfs_file_close+0x29c> <== ALWAYS TAKEN
4001d730: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001d734: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
4001d738: 7f ff d9 34 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001d73c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d740: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d744: 22 80 00 0a be,a 4001d76c <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
4001d748: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001d74c: 40 00 18 61 call 400238d0 <strerror> <== NOT EXECUTED
4001d750: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d754: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001d758: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d75c: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d760: 40 00 13 f0 call 40022720 <printf> <== NOT EXECUTED
4001d764: 90 12 22 28 or %o0, 0x228, %o0 ! 40036228 <CSWTCH.2+0xde8><== NOT EXECUTED
}
free (handle);
4001d768: 90 10 00 19 mov %i1, %o0
4001d76c: 7f ff ac 0c call 4000879c <free>
4001d770: b0 10 00 1d mov %i5, %i0
return rrc;
}
4001d774: 81 c7 e0 08 ret
4001d778: 81 e8 00 00 restore
4001d9a0 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
4001d9a0: 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))
4001d9a4: 90 10 20 20 mov 0x20, %o0
4001d9a8: 92 10 20 00 clr %o1
4001d9ac: 7f ff d8 97 call 40013c08 <rtems_rfs_trace>
4001d9b0: ba 10 00 18 mov %i0, %i5
4001d9b4: 80 8a 20 ff btst 0xff, %o0
4001d9b8: 22 80 00 0e be,a 4001d9f0 <rtems_rfs_file_io_end+0x50> <== ALWAYS TAKEN
4001d9bc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001d9c0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001d9c4: 22 80 00 05 be,a 4001d9d8 <rtems_rfs_file_io_end+0x38> <== NOT EXECUTED
4001d9c8: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
4001d9cc: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
4001d9d0: 10 80 00 03 b 4001d9dc <rtems_rfs_file_io_end+0x3c> <== NOT EXECUTED
4001d9d4: 92 12 63 20 or %o1, 0x320, %o1 ! 40034b20 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001d9d8: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
4001d9dc: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d9e0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001d9e4: 40 00 13 4f call 40022720 <printf> <== NOT EXECUTED
4001d9e8: 90 12 23 10 or %o0, 0x310, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001d9ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001d9f0: 80 a0 60 00 cmp %g1, 0
4001d9f4: 02 80 00 1e be 4001da6c <rtems_rfs_file_io_end+0xcc> <== NEVER TAKEN
4001d9f8: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
4001d9fc: 32 80 00 05 bne,a 4001da10 <rtems_rfs_file_io_end+0x70>
4001da00: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001da04: 82 10 20 01 mov 1, %g1
4001da08: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001da0c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001da10: 92 07 60 04 add %i5, 4, %o1
4001da14: 7f ff f7 e1 call 4001b998 <rtems_rfs_buffer_handle_release>
4001da18: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001da1c: b0 92 20 00 orcc %o0, 0, %i0
4001da20: 04 80 00 14 ble 4001da70 <rtems_rfs_file_io_end+0xd0> <== ALWAYS TAKEN
4001da24: 80 a6 a0 00 cmp %i2, 0
{
printf (
4001da28: 22 80 00 05 be,a 4001da3c <rtems_rfs_file_io_end+0x9c> <== NOT EXECUTED
4001da2c: 3b 10 00 d8 sethi %hi(0x40036000), %i5 <== NOT EXECUTED
4001da30: 3b 10 00 d2 sethi %hi(0x40034800), %i5 <== NOT EXECUTED
4001da34: 10 80 00 03 b 4001da40 <rtems_rfs_file_io_end+0xa0> <== NOT EXECUTED
4001da38: ba 17 63 20 or %i5, 0x320, %i5 ! 40034b20 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001da3c: ba 17 62 50 or %i5, 0x250, %i5 <== NOT EXECUTED
4001da40: 40 00 17 a4 call 400238d0 <strerror> <== NOT EXECUTED
4001da44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001da48: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001da4c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001da50: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001da54: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001da58: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001da5c: 40 00 13 31 call 40022720 <printf> <== NOT EXECUTED
4001da60: 90 12 23 38 or %o0, 0x338, %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;
4001da64: 81 c7 e0 08 ret <== NOT EXECUTED
4001da68: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
4001da6c: 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;
4001da70: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001da74: b2 06 40 01 add %i1, %g1, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001da78: 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;
4001da7c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001da80: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
4001da84: 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 >=
4001da88: 80 a6 40 02 cmp %i1, %g2
4001da8c: 0a 80 00 07 bcs 4001daa8 <rtems_rfs_file_io_end+0x108>
4001da90: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
4001da94: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001da98: 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++;
4001da9c: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001daa0: 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++;
4001daa4: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
4001daa8: 12 80 00 19 bne 4001db0c <rtems_rfs_file_io_end+0x16c>
4001daac: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001dab0: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
}
length = false;
mtime = false;
if (!read &&
4001dab4: 80 a0 e0 00 cmp %g3, 0
4001dab8: 02 80 00 05 be 4001dacc <rtems_rfs_file_io_end+0x12c>
4001dabc: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001dac0: 80 a0 a0 00 cmp %g2, 0
4001dac4: 22 80 00 0f be,a 4001db00 <rtems_rfs_file_io_end+0x160> <== NEVER TAKEN
4001dac8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
4001dacc: 80 a0 c0 02 cmp %g3, %g2
4001dad0: 3a 80 00 0c bcc,a 4001db00 <rtems_rfs_file_io_end+0x160>
4001dad4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001dad8: 88 00 bf ff add %g2, -1, %g4
4001dadc: 80 a0 c0 04 cmp %g3, %g4
4001dae0: 12 80 00 0b bne 4001db0c <rtems_rfs_file_io_end+0x16c>
4001dae4: 84 10 20 00 clr %g2
4001dae8: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
4001daec: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
4001daf0: 80 a1 00 03 cmp %g4, %g3
4001daf4: 28 80 00 07 bleu,a 4001db10 <rtems_rfs_file_io_end+0x170>
4001daf8: 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;
4001dafc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001db00: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
map->dirty = true;
4001db04: 84 10 20 01 mov 1, %g2
4001db08: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001db0c: c2 07 40 00 ld [ %i5 ], %g1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001db10: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001db14: a2 08 60 01 and %g1, 1, %l1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001db18: 80 88 60 02 btst 2, %g1
4001db1c: a2 1c 60 01 xor %l1, 1, %l1
4001db20: 12 80 00 03 bne 4001db2c <rtems_rfs_file_io_end+0x18c> <== NEVER TAKEN
4001db24: a0 10 00 11 mov %l1, %l0
4001db28: b8 08 a0 ff and %g2, 0xff, %i4
4001db2c: b2 0f 20 01 and %i4, 1, %i1
length = rtems_rfs_file_update_length (handle) && length;
4001db30: 80 88 60 04 btst 4, %g1
4001db34: 12 80 00 03 bne 4001db40 <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
4001db38: b6 10 20 00 clr %i3
4001db3c: b6 08 a0 ff and %g2, 0xff, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001db40: 90 10 20 20 mov 0x20, %o0
4001db44: 92 10 20 00 clr %o1
4001db48: 7f ff d8 30 call 40013c08 <rtems_rfs_trace>
4001db4c: b6 0e e0 01 and %i3, 1, %i3
4001db50: 80 8a 20 ff btst 0xff, %o0
4001db54: 22 80 00 17 be,a 4001dbb0 <rtems_rfs_file_io_end+0x210> <== ALWAYS TAKEN
4001db58: b8 17 00 11 or %i4, %l1, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
4001db5c: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
4001db60: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4001db64: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
4001db68: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
4001db6c: 82 0e 60 ff and %i1, 0xff, %g1 <== NOT EXECUTED
4001db70: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
4001db74: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4001db78: 82 0e e0 ff and %i3, 0xff, %g1 <== NOT EXECUTED
4001db7c: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
4001db80: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4001db84: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
4001db88: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
4001db8c: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
4001db90: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001db94: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
4001db98: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
4001db9c: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
4001dba0: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
4001dba4: 40 00 12 df call 40022720 <printf> <== NOT EXECUTED
4001dba8: 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)
4001dbac: b8 17 00 11 or %i4, %l1, %i4 <== NOT EXECUTED
4001dbb0: 80 8f 20 01 btst 1, %i4
4001dbb4: 02 80 00 13 be 4001dc00 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
4001dbb8: 80 8e e0 ff btst 0xff, %i3
{
time_t now = time (NULL);
4001dbbc: 40 00 23 3f call 400268b8 <time>
4001dbc0: 90 10 20 00 clr %o0
if (read && atime)
4001dbc4: 80 a6 a0 00 cmp %i2, 0
4001dbc8: 02 80 00 07 be 4001dbe4 <rtems_rfs_file_io_end+0x244>
4001dbcc: 80 8e 60 ff btst 0xff, %i1
4001dbd0: 80 8c 20 ff btst 0xff, %l0
4001dbd4: 02 80 00 04 be 4001dbe4 <rtems_rfs_file_io_end+0x244> <== NEVER TAKEN
4001dbd8: 80 8e 60 ff btst 0xff, %i1
handle->shared->atime = now;
4001dbdc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001dbe0: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (!read && mtime)
4001dbe4: 02 80 00 07 be 4001dc00 <rtems_rfs_file_io_end+0x260>
4001dbe8: 80 8e e0 ff btst 0xff, %i3
4001dbec: 80 a6 a0 01 cmp %i2, 1
4001dbf0: 02 80 00 04 be 4001dc00 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
4001dbf4: 80 8e e0 ff btst 0xff, %i3
handle->shared->mtime = now;
4001dbf8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001dbfc: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
}
if (length)
4001dc00: 02 80 00 07 be 4001dc1c <rtems_rfs_file_io_end+0x27c>
4001dc04: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
4001dc08: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
4001dc0c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
4001dc10: c4 20 60 84 st %g2, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
4001dc14: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
4001dc18: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
4001dc1c: 81 c7 e0 08 ret
4001dc20: 81 e8 00 00 restore
4001dc24 <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))
4001dc24: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4001dc28: 80 a0 60 00 cmp %g1, 0
4001dc2c: 02 80 00 08 be 4001dc4c <rtems_rfs_file_io_release+0x28> <== ALWAYS TAKEN
4001dc30: 92 10 00 08 mov %o0, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001dc34: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
4001dc38: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
4001dc3c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001dc40: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001dc44: 7f ff f7 55 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001dc48: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
4001dc4c: 81 c3 e0 08 retl
4001dc50: 90 10 20 00 clr %o0
4001d77c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
4001d77c: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001d780: 90 10 20 20 mov 0x20, %o0
4001d784: 92 10 20 00 clr %o1
4001d788: 7f ff d9 20 call 40013c08 <rtems_rfs_trace>
4001d78c: ba 10 00 18 mov %i0, %i5
4001d790: 80 8a 20 ff btst 0xff, %o0
4001d794: 22 80 00 0f be,a 4001d7d0 <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
4001d798: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001d79c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001d7a0: 22 80 00 05 be,a 4001d7b4 <rtems_rfs_file_io_start+0x38> <== NOT EXECUTED
4001d7a4: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
4001d7a8: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
4001d7ac: 10 80 00 03 b 4001d7b8 <rtems_rfs_file_io_start+0x3c> <== NOT EXECUTED
4001d7b0: 92 12 63 20 or %o1, 0x320, %o1 ! 40034b20 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001d7b4: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
4001d7b8: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
4001d7bc: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
4001d7c0: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d7c4: 40 00 13 d7 call 40022720 <printf> <== NOT EXECUTED
4001d7c8: 90 12 22 58 or %o0, 0x258, %o0 ! 40036258 <CSWTCH.2+0xe18><== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001d7cc: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001d7d0: 80 a0 60 00 cmp %g1, 0
4001d7d4: 12 80 00 4f bne 4001d910 <rtems_rfs_file_io_start+0x194>
4001d7d8: 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),
4001d7dc: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001d7e0: 94 07 60 10 add %i5, 0x10, %o2
4001d7e4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001d7e8: 96 07 bf fc add %fp, -4, %o3
4001d7ec: 7f ff f5 c7 call 4001af08 <rtems_rfs_block_map_find>
4001d7f0: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001d7f4: b0 92 20 00 orcc %o0, 0, %i0
4001d7f8: 04 80 00 1e ble 4001d870 <rtems_rfs_file_io_start+0xf4>
4001d7fc: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
4001d800: 32 80 00 66 bne,a 4001d998 <rtems_rfs_file_io_start+0x21c><== NEVER TAKEN
4001d804: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
4001d808: 80 a6 a0 00 cmp %i2, 0
4001d80c: 22 80 00 05 be,a 4001d820 <rtems_rfs_file_io_start+0xa4> <== ALWAYS TAKEN
4001d810: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
4001d814: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
4001d818: 81 c7 e0 08 ret <== NOT EXECUTED
4001d81c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if (rc != ENXIO)
4001d820: 12 80 00 5e bne 4001d998 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
4001d824: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001d828: 7f ff d8 f8 call 40013c08 <rtems_rfs_trace>
4001d82c: 92 10 20 00 clr %o1
4001d830: 80 8a 20 ff btst 0xff, %o0
4001d834: 22 80 00 06 be,a 4001d84c <rtems_rfs_file_io_start+0xd0> <== ALWAYS TAKEN
4001d838: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-io: start: grow\n");
4001d83c: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d840: 40 00 14 50 call 40022980 <puts> <== NOT EXECUTED
4001d844: 90 12 22 88 or %o0, 0x288, %o0 ! 40036288 <CSWTCH.2+0xe48><== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001d848: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
4001d84c: 94 10 20 01 mov 1, %o2
4001d850: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001d854: 96 07 bf fc add %fp, -4, %o3
4001d858: 7f ff f6 32 call 4001b120 <rtems_rfs_block_map_grow>
4001d85c: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
4001d860: b0 92 20 00 orcc %o0, 0, %i0
4001d864: 14 80 00 4d bg 4001d998 <rtems_rfs_file_io_start+0x21c>
4001d868: b8 10 20 00 clr %i4
4001d86c: 30 80 00 0f b,a 4001d8a8 <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 &&
4001d870: 80 a6 a0 00 cmp %i2, 0
4001d874: 12 80 00 0d bne 4001d8a8 <rtems_rfs_file_io_start+0x12c>
4001d878: b8 10 00 1a mov %i2, %i4
4001d87c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001d880: 80 a0 60 00 cmp %g1, 0
4001d884: 12 80 00 09 bne 4001d8a8 <rtems_rfs_file_io_start+0x12c>
4001d888: b8 10 20 01 mov 1, %i4
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001d88c: 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) ||
4001d890: c4 06 40 00 ld [ %i1 ], %g2
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001d894: 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) ||
4001d898: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001d89c: 80 a0 80 01 cmp %g2, %g1
4001d8a0: 3a 80 00 02 bcc,a 4001d8a8 <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
4001d8a4: 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))
4001d8a8: 90 10 20 20 mov 0x20, %o0
4001d8ac: 7f ff d8 d7 call 40013c08 <rtems_rfs_trace>
4001d8b0: 92 10 20 00 clr %o1
4001d8b4: 80 8a 20 ff btst 0xff, %o0
4001d8b8: 22 80 00 0e be,a 4001d8f0 <rtems_rfs_file_io_start+0x174><== ALWAYS TAKEN
4001d8bc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001d8c0: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4001d8c4: 02 80 00 05 be 4001d8d8 <rtems_rfs_file_io_start+0x15c> <== NOT EXECUTED
4001d8c8: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
4001d8cc: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED
4001d8d0: 10 80 00 04 b 4001d8e0 <rtems_rfs_file_io_start+0x164> <== NOT EXECUTED
4001d8d4: 94 12 a1 a0 or %o2, 0x1a0, %o2 ! 400345a0 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
4001d8d8: 15 10 00 ca sethi %hi(0x40032800), %o2 <== NOT EXECUTED
4001d8dc: 94 12 a1 e8 or %o2, 0x1e8, %o2 ! 400329e8 <Callbacks.6428+0x1d0><== NOT EXECUTED
4001d8e0: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001d8e4: 40 00 13 8f call 40022720 <printf> <== NOT EXECUTED
4001d8e8: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 400362a8 <CSWTCH.2+0xe68><== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001d8ec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001d8f0: d4 07 bf fc ld [ %fp + -4 ], %o2
4001d8f4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001d8f8: 92 07 60 04 add %i5, 4, %o1
4001d8fc: 7f ff f8 9b call 4001bb68 <rtems_rfs_buffer_handle_request>
4001d900: 96 0f 20 ff and %i4, 0xff, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
4001d904: b0 92 20 00 orcc %o0, 0, %i0
4001d908: 14 80 00 24 bg 4001d998 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
4001d90c: 80 a6 a0 00 cmp %i2, 0
return rc;
}
if (read
4001d910: 02 80 00 12 be 4001d958 <rtems_rfs_file_io_start+0x1dc>
4001d914: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001d918: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
4001d91c: 80 a0 a0 00 cmp %g2, 0
4001d920: 12 80 00 05 bne 4001d934 <rtems_rfs_file_io_start+0x1b8>
4001d924: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
4001d928: 80 a0 e0 00 cmp %g3, 0
4001d92c: 22 80 00 07 be,a 4001d948 <rtems_rfs_file_io_start+0x1cc><== NEVER TAKEN
4001d930: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
4001d934: 86 00 ff ff add %g3, -1, %g3
4001d938: 80 a0 80 03 cmp %g2, %g3
4001d93c: 32 80 00 07 bne,a 4001d958 <rtems_rfs_file_io_start+0x1dc>
4001d940: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001d944: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
4001d948: 80 a7 20 00 cmp %i4, 0
4001d94c: 32 80 00 06 bne,a 4001d964 <rtems_rfs_file_io_start+0x1e8>
4001d950: 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));
4001d954: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001d958: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
4001d95c: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
4001d960: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001d964: 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);
4001d968: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001d96c: 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);
4001d970: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001d974: 7f ff d8 a5 call 40013c08 <rtems_rfs_trace>
4001d978: b0 10 20 00 clr %i0
4001d97c: 80 8a 20 ff btst 0xff, %o0
4001d980: 02 80 00 06 be 4001d998 <rtems_rfs_file_io_start+0x21c> <== ALWAYS TAKEN
4001d984: 11 10 00 d8 sethi %hi(0x40036000), %o0
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
4001d988: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001d98c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001d990: 40 00 13 64 call 40022720 <printf> <== NOT EXECUTED
4001d994: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED
*available, size);
return 0;
}
4001d998: 81 c7 e0 08 ret
4001d99c: 81 e8 00 00 restore
4001e0ac <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)
{
4001e0ac: 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))
4001e0b0: 90 10 20 08 mov 8, %o0
4001e0b4: 7f ff d6 d5 call 40013c08 <rtems_rfs_trace>
4001e0b8: 92 10 20 00 clr %o1
4001e0bc: 80 8a 20 ff btst 0xff, %o0
4001e0c0: 22 80 00 07 be,a 4001e0dc <rtems_rfs_file_open+0x30> <== ALWAYS TAKEN
4001e0c4: c0 26 c0 00 clr [ %i3 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
4001e0c8: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e0cc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001e0d0: 40 00 11 94 call 40022720 <printf> <== NOT EXECUTED
4001e0d4: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
*file = NULL;
4001e0d8: 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));
4001e0dc: 90 10 20 20 mov 0x20, %o0
4001e0e0: 7f ff ab 40 call 40008de0 <malloc>
4001e0e4: a0 10 20 0c mov 0xc, %l0
if (!handle)
4001e0e8: 80 a2 20 00 cmp %o0, 0
4001e0ec: 02 80 00 a4 be 4001e37c <rtems_rfs_file_open+0x2d0> <== NEVER TAKEN
4001e0f0: ba 10 00 08 mov %o0, %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
4001e0f4: 92 10 20 00 clr %o1
4001e0f8: 40 00 11 0c call 40022528 <memset>
4001e0fc: 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);
4001e100: 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;
4001e104: c0 2f 60 04 clrb [ %i5 + 4 ]
handle->bnum = 0;
4001e108: c0 27 60 08 clr [ %i5 + 8 ]
handle->buffer = NULL;
4001e10c: c0 27 60 0c clr [ %i5 + 0xc ]
4001e110: 7f ff ff d9 call 4001e074 <rtems_rfs_file_get_shared>
4001e114: 92 10 00 19 mov %i1, %o1
if (shared)
4001e118: b8 92 20 00 orcc %o0, 0, %i4
4001e11c: 02 80 00 0d be 4001e150 <rtems_rfs_file_open+0xa4> <== ALWAYS TAKEN
4001e120: 90 10 20 08 mov 8, %o0
{
shared->references++;
4001e124: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
4001e128: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e12c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e130: 7f ff d6 b6 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e134: c2 27 20 08 st %g1, [ %i4 + 8 ] <== NOT EXECUTED
4001e138: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e13c: 22 80 00 8d be,a 4001e370 <rtems_rfs_file_open+0x2c4> <== NOT EXECUTED
4001e140: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001e144: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e148: 10 80 00 87 b 4001e364 <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
4001e14c: 90 12 20 20 or %o0, 0x20, %o0 ! 40036420 <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));
4001e150: 7f ff ab 24 call 40008de0 <malloc>
4001e154: 90 10 20 9c mov 0x9c, %o0
if (!shared)
4001e158: b8 92 20 00 orcc %o0, 0, %i4
4001e15c: 12 80 00 04 bne 4001e16c <rtems_rfs_file_open+0xc0> <== ALWAYS TAKEN
4001e160: 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);
4001e164: 10 80 00 34 b 4001e234 <rtems_rfs_file_open+0x188> <== NOT EXECUTED
4001e168: 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));
4001e16c: 40 00 10 ef call 40022528 <memset>
4001e170: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4001e174: a2 07 20 0c add %i4, 0xc, %l1
4001e178: 90 10 00 18 mov %i0, %o0
4001e17c: 92 10 00 19 mov %i1, %o1
4001e180: 94 10 00 11 mov %l1, %o2
4001e184: 7f ff d0 18 call 400121e4 <rtems_rfs_inode_open>
4001e188: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001e18c: a0 92 20 00 orcc %o0, 0, %l0
4001e190: 04 80 00 0f ble 4001e1cc <rtems_rfs_file_open+0x120> <== ALWAYS TAKEN
4001e194: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e198: 7f ff d6 9c call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e19c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e1a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e1a4: 02 80 00 21 be 4001e228 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
4001e1a8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
4001e1ac: 40 00 15 c9 call 400238d0 <strerror> <== NOT EXECUTED
4001e1b0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001e1b4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001e1b8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e1bc: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e1c0: 40 00 11 58 call 40022720 <printf> <== NOT EXECUTED
4001e1c4: 90 12 20 48 or %o0, 0x48, %o0 ! 40036448 <CSWTCH.2+0x1008><== NOT EXECUTED
4001e1c8: 30 80 00 18 b,a 4001e228 <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);
4001e1cc: 90 10 00 18 mov %i0, %o0
4001e1d0: 92 10 00 11 mov %l1, %o1
4001e1d4: 7f ff f2 78 call 4001abb4 <rtems_rfs_block_map_open>
4001e1d8: 94 07 20 34 add %i4, 0x34, %o2
if (rc > 0)
4001e1dc: a0 92 20 00 orcc %o0, 0, %l0
4001e1e0: 04 80 00 1e ble 4001e258 <rtems_rfs_file_open+0x1ac> <== ALWAYS TAKEN
4001e1e4: 82 10 20 01 mov 1, %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e1e8: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
4001e1ec: 7f ff d6 87 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e1f0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e1f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e1f8: 22 80 00 0a be,a 4001e220 <rtems_rfs_file_open+0x174> <== NOT EXECUTED
4001e1fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001e200: 40 00 15 b4 call 400238d0 <strerror> <== NOT EXECUTED
4001e204: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001e208: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001e20c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e210: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e214: 40 00 11 43 call 40022720 <printf> <== NOT EXECUTED
4001e218: 90 12 20 80 or %o0, 0x80, %o0 ! 40036480 <CSWTCH.2+0x1040><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
4001e21c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e220: 7f ff d0 63 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001e224: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
free (shared);
4001e228: 7f ff a9 5d call 4000879c <free> <== NOT EXECUTED
4001e22c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001e230: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e234: 7f ff f5 d9 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e238: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
4001e23c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e240: c0 2f 60 04 clrb [ %i5 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001e244: c0 27 60 08 clr [ %i5 + 8 ] <== NOT EXECUTED
4001e248: 7f ff a9 55 call 4000879c <free> <== NOT EXECUTED
4001e24c: c0 27 60 0c clr [ %i5 + 0xc ] <== NOT EXECUTED
return rc;
4001e250: 81 c7 e0 08 ret <== NOT EXECUTED
4001e254: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
shared->references = 1;
4001e258: 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);
4001e25c: 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 );
4001e260: 90 06 20 74 add %i0, 0x74, %o0
4001e264: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
4001e268: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
4001e26c: 87 28 e0 18 sll %g3, 0x18, %g3
4001e270: 85 28 a0 10 sll %g2, 0x10, %g2
4001e274: 84 10 c0 02 or %g3, %g2, %g2
4001e278: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
4001e27c: 92 10 00 1c mov %i4, %o1
4001e280: 84 10 80 03 or %g2, %g3, %g2
4001e284: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
4001e288: 87 28 e0 08 sll %g3, 8, %g3
4001e28c: 84 10 80 03 or %g2, %g3, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001e290: c4 27 20 84 st %g2, [ %i4 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001e294: 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);
4001e298: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001e29c: 85 28 a0 08 sll %g2, 8, %g2
4001e2a0: 84 10 c0 02 or %g3, %g2, %g2
4001e2a4: 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);
4001e2a8: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
4001e2ac: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
4001e2b0: 87 28 e0 18 sll %g3, 0x18, %g3
4001e2b4: 85 28 a0 10 sll %g2, 0x10, %g2
4001e2b8: 84 10 c0 02 or %g3, %g2, %g2
4001e2bc: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
4001e2c0: 84 10 80 03 or %g2, %g3, %g2
4001e2c4: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
4001e2c8: 87 28 e0 08 sll %g3, 8, %g3
4001e2cc: 84 10 80 03 or %g2, %g3, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001e2d0: 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);
4001e2d4: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
4001e2d8: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
4001e2dc: 87 28 e0 18 sll %g3, 0x18, %g3
4001e2e0: 85 28 a0 10 sll %g2, 0x10, %g2
4001e2e4: 84 10 c0 02 or %g3, %g2, %g2
4001e2e8: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
4001e2ec: 84 10 80 03 or %g2, %g3, %g2
4001e2f0: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
4001e2f4: 87 28 e0 08 sll %g3, 8, %g3
4001e2f8: 84 10 80 03 or %g2, %g3, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
4001e2fc: 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);
4001e300: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
4001e304: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
4001e308: 85 28 a0 10 sll %g2, 0x10, %g2
4001e30c: 87 28 e0 18 sll %g3, 0x18, %g3
4001e310: 86 10 c0 02 or %g3, %g2, %g3
4001e314: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
4001e318: 86 10 c0 02 or %g3, %g2, %g3
4001e31c: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
4001e320: f0 27 20 98 st %i0, [ %i4 + 0x98 ]
4001e324: 85 28 a0 08 sll %g2, 8, %g2
4001e328: 82 10 c0 02 or %g3, %g2, %g1
4001e32c: 7f ff be 3b call 4000dc18 <_Chain_Append>
4001e330: c2 27 20 94 st %g1, [ %i4 + 0x94 ]
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001e334: 92 10 00 11 mov %l1, %o1
4001e338: 94 10 20 00 clr %o2
4001e33c: 7f ff cf e0 call 400122bc <rtems_rfs_inode_unload>
4001e340: 90 10 00 18 mov %i0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e344: 90 10 20 08 mov 8, %o0
4001e348: 7f ff d6 30 call 40013c08 <rtems_rfs_trace>
4001e34c: 92 10 20 00 clr %o1
4001e350: 80 8a 20 ff btst 0xff, %o0
4001e354: 22 80 00 07 be,a 4001e370 <rtems_rfs_file_open+0x2c4> <== ALWAYS TAKEN
4001e358: f4 27 40 00 st %i2, [ %i5 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001e35c: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e360: 90 12 20 b8 or %o0, 0xb8, %o0 ! 400364b8 <CSWTCH.2+0x1078><== NOT EXECUTED
4001e364: 40 00 10 ef call 40022720 <printf> <== NOT EXECUTED
4001e368: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
handle->flags = oflag;
4001e36c: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
handle->shared = shared;
4001e370: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
*file = handle;
4001e374: fa 26 c0 00 st %i5, [ %i3 ]
return 0;
4001e378: a0 10 20 00 clr %l0
}
4001e37c: b0 10 00 10 mov %l0, %i0
4001e380: 81 c7 e0 08 ret
4001e384: 81 e8 00 00 restore
4001dc54 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
4001dc54: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001dc58: 90 10 20 20 mov 0x20, %o0
4001dc5c: 7f ff d7 eb call 40013c08 <rtems_rfs_trace>
4001dc60: 92 10 20 00 clr %o1
4001dc64: 80 8a 20 ff btst 0xff, %o0
4001dc68: 22 80 00 08 be,a 4001dc88 <rtems_rfs_file_seek+0x34> <== ALWAYS TAKEN
4001dc6c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
4001dc70: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001dc74: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001dc78: 90 12 23 b8 or %o0, 0x3b8, %o0 <== NOT EXECUTED
4001dc7c: 40 00 12 a9 call 40022720 <printf> <== NOT EXECUTED
4001dc80: 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),
4001dc84: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
4001dc88: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001dc8c: 7f ff f3 b2 call 4001ab54 <rtems_rfs_block_get_size>
4001dc90: 92 02 60 84 add %o1, 0x84, %o1
4001dc94: 80 a6 40 08 cmp %i1, %o0
4001dc98: 18 80 00 23 bgu 4001dd24 <rtems_rfs_file_seek+0xd0> <== NEVER TAKEN
4001dc9c: 01 00 00 00 nop
4001dca0: 32 80 00 06 bne,a 4001dcb8 <rtems_rfs_file_seek+0x64> <== NEVER TAKEN
4001dca4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
4001dca8: 80 a6 80 09 cmp %i2, %o1
4001dcac: 18 80 00 1e bgu 4001dd24 <rtems_rfs_file_seek+0xd0>
4001dcb0: 01 00 00 00 nop
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
4001dcb4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001dcb8: b8 06 20 10 add %i0, 0x10, %i4
4001dcbc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001dcc0: 92 10 00 19 mov %i1, %o1
4001dcc4: 94 10 00 1a mov %i2, %o2
4001dcc8: 7f ff f3 73 call 4001aa94 <rtems_rfs_block_get_bpos>
4001dccc: 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))
4001dcd0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001dcd4: 80 a0 60 00 cmp %g1, 0
4001dcd8: 02 80 00 18 be 4001dd38 <rtems_rfs_file_seek+0xe4>
4001dcdc: 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),
4001dce0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
4001dce4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001dce8: 96 07 bf fc add %fp, -4, %o3
4001dcec: 7f ff f4 87 call 4001af08 <rtems_rfs_block_map_find>
4001dcf0: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001dcf4: 80 a2 20 00 cmp %o0, 0
4001dcf8: 14 80 00 13 bg 4001dd44 <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
4001dcfc: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
4001dd00: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001dd04: 80 a0 80 01 cmp %g2, %g1
4001dd08: 02 80 00 0c be 4001dd38 <rtems_rfs_file_seek+0xe4> <== ALWAYS TAKEN
4001dd0c: 92 06 20 04 add %i0, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001dd10: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
4001dd14: 7f ff f7 21 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001dd18: 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)
4001dd1c: 10 80 00 05 b 4001dd30 <rtems_rfs_file_seek+0xdc> <== NOT EXECUTED
4001dd20: 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);
4001dd24: 7f ff ff c0 call 4001dc24 <rtems_rfs_file_io_release>
4001dd28: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001dd2c: 80 a2 20 00 cmp %o0, 0
4001dd30: 14 80 00 05 bg 4001dd44 <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
4001dd34: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
4001dd38: f2 26 c0 00 st %i1, [ %i3 ]
4001dd3c: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
4001dd40: 90 10 20 00 clr %o0
}
4001dd44: 81 c7 e0 08 ret
4001dd48: 91 e8 00 08 restore %g0, %o0, %o0
4001dd4c <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4001dd4c: 9d e3 bf 90 save %sp, -112, %sp
4001dd50: ba 10 00 1a mov %i2, %i5
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001dd54: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4001dd58: 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))
4001dd5c: 90 10 20 20 mov 0x20, %o0
4001dd60: 92 10 20 00 clr %o1
4001dd64: 7f ff d7 a9 call 40013c08 <rtems_rfs_trace>
4001dd68: b8 10 00 19 mov %i1, %i4
4001dd6c: 80 8a 20 ff btst 0xff, %o0
4001dd70: 02 80 00 07 be 4001dd8c <rtems_rfs_file_set_size+0x40> <== ALWAYS TAKEN
4001dd74: b0 06 a0 34 add %i2, 0x34, %i0
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
4001dd78: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001dd7c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001dd80: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED
4001dd84: 40 00 12 67 call 40022720 <printf> <== NOT EXECUTED
4001dd88: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
4001dd8c: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
4001dd90: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001dd94: 7f ff f3 70 call 4001ab54 <rtems_rfs_block_get_size>
4001dd98: 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)
4001dd9c: 80 a2 00 1c cmp %o0, %i4
4001dda0: 12 80 00 07 bne 4001ddbc <rtems_rfs_file_set_size+0x70> <== NEVER TAKEN
4001dda4: 80 97 00 1d orcc %i4, %i5, %g0
4001dda8: 80 a2 40 1d cmp %o1, %i5
4001ddac: 12 80 00 04 bne 4001ddbc <rtems_rfs_file_set_size+0x70>
4001ddb0: 80 97 00 1d orcc %i4, %i5, %g0
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
4001ddb4: 10 80 00 ad b 4001e068 <rtems_rfs_file_set_size+0x31c>
4001ddb8: 90 10 20 00 clr %o0
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
4001ddbc: 12 80 00 0a bne 4001dde4 <rtems_rfs_file_set_size+0x98>
4001ddc0: f2 06 e0 1c ld [ %i3 + 0x1c ], %i1
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001ddc4: d0 06 60 98 ld [ %i1 + 0x98 ], %o0
4001ddc8: 7f ff f6 90 call 4001b808 <rtems_rfs_block_map_free_all>
4001ddcc: 92 10 00 18 mov %i0, %o1
if (rc > 0)
4001ddd0: 80 a2 20 00 cmp %o0, 0
4001ddd4: 14 80 00 a6 bg 4001e06c <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
4001ddd8: 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);
4001dddc: 10 80 00 97 b 4001e038 <rtems_rfs_file_set_size+0x2ec>
4001dde0: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
4001dde4: 80 a7 00 08 cmp %i4, %o0
4001dde8: 38 80 00 09 bgu,a 4001de0c <rtems_rfs_file_set_size+0xc0><== NEVER TAKEN
4001ddec: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 <== NOT EXECUTED
4001ddf0: 80 a7 00 08 cmp %i4, %o0
4001ddf4: 32 80 00 58 bne,a 4001df54 <rtems_rfs_file_set_size+0x208><== NEVER TAKEN
4001ddf8: e0 06 60 98 ld [ %i1 + 0x98 ], %l0 <== NOT EXECUTED
4001ddfc: 80 a7 40 09 cmp %i5, %o1
4001de00: 28 80 00 55 bleu,a 4001df54 <rtems_rfs_file_set_size+0x208>
4001de04: 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));
4001de08: c2 06 60 98 ld [ %i1 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
4001de0c: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001de10: f2 00 60 08 ld [ %g1 + 8 ], %i1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
4001de14: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
4001de18: a2 10 20 00 clr %l1
4001de1c: a0 10 20 01 mov 1, %l0
while (count)
4001de20: 10 80 00 48 b 4001df40 <rtems_rfs_file_set_size+0x1f4>
4001de24: 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);
4001de28: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001de2c: c4 27 bf f8 st %g2, [ %fp + -8 ]
4001de30: c2 27 bf f4 st %g1, [ %fp + -12 ]
4001de34: 80 a0 a0 00 cmp %g2, 0
4001de38: 02 80 00 04 be 4001de48 <rtems_rfs_file_set_size+0xfc>
4001de3c: c0 27 bf fc clr [ %fp + -4 ]
4001de40: 82 00 7f ff add %g1, -1, %g1
4001de44: c2 27 bf f4 st %g1, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001de48: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001de4c: 92 10 00 18 mov %i0, %o1
4001de50: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001de54: 94 07 bf f4 add %fp, -12, %o2
4001de58: 7f ff f4 2c call 4001af08 <rtems_rfs_block_map_find>
4001de5c: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
4001de60: 80 a2 20 00 cmp %o0, 0
4001de64: 14 80 00 0b bg 4001de90 <rtems_rfs_file_set_size+0x144>
4001de68: 80 a2 20 06 cmp %o0, 6
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
4001de6c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001de70: 80 a7 20 00 cmp %i4, 0
4001de74: 12 80 00 17 bne 4001ded0 <rtems_rfs_file_set_size+0x184> <== NEVER TAKEN
4001de78: 84 26 40 01 sub %i1, %g1, %g2
4001de7c: 80 a0 80 1d cmp %g2, %i5
4001de80: 38 80 00 10 bgu,a 4001dec0 <rtems_rfs_file_set_size+0x174>
4001de84: 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;
4001de88: 10 80 00 13 b 4001ded4 <rtems_rfs_file_set_size+0x188>
4001de8c: c0 26 a0 40 clr [ %i2 + 0x40 ]
if (rc > 0)
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
4001de90: 12 80 00 76 bne 4001e068 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001de94: 92 10 00 18 mov %i0, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001de98: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001de9c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001dea0: 94 10 20 01 mov 1, %o2
4001dea4: 7f ff f4 9f call 4001b120 <rtems_rfs_block_map_grow>
4001dea8: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
4001deac: 80 a2 20 00 cmp %o0, 0
4001deb0: 04 bf ff f0 ble 4001de70 <rtems_rfs_file_set_size+0x124> <== ALWAYS TAKEN
4001deb4: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
}
4001deb8: 81 c7 e0 08 ret <== NOT EXECUTED
4001debc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
map->dirty = true;
4001dec0: 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;
4001dec4: f2 26 a0 40 st %i1, [ %i2 + 0x40 ]
}
if (count < (length - bpos.boff))
{
length = count + bpos.boff;
read_block = true;
4001dec8: 10 80 00 04 b 4001ded8 <rtems_rfs_file_set_size+0x18c>
4001decc: a2 10 20 01 mov 1, %l1
4001ded0: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001ded4: 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),
4001ded8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001dedc: d4 07 bf f0 ld [ %fp + -16 ], %o2
4001dee0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001dee4: 92 10 00 12 mov %l2, %o1
4001dee8: 7f ff f7 20 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001deec: 96 0c 60 01 and %l1, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
4001def0: 80 a2 20 00 cmp %o0, 0
4001def4: 14 80 00 5d bg 4001e068 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001def8: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
4001defc: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
memset (dst + bpos.boff, 0, length - bpos.boff);
4001df00: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001df04: 92 10 20 00 clr %o1
4001df08: 90 02 00 0a add %o0, %o2, %o0
4001df0c: 40 00 11 87 call 40022528 <memset>
4001df10: 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),
4001df14: 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));
4001df18: e0 2e e0 04 stb %l0, [ %i3 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001df1c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001df20: 7f ff f6 9e call 4001b998 <rtems_rfs_buffer_handle_release>
4001df24: 92 10 00 12 mov %l2, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001df28: 80 a2 20 00 cmp %o0, 0
4001df2c: 14 80 00 4f bg 4001e068 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001df30: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
count -= length - bpos.boff;
4001df34: 82 26 40 01 sub %i1, %g1, %g1
4001df38: ba a7 40 01 subcc %i5, %g1, %i5
4001df3c: 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)
4001df40: 80 97 00 1d orcc %i4, %i5, %g0
4001df44: 32 bf ff b9 bne,a 4001de28 <rtems_rfs_file_set_size+0xdc>
4001df48: 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);
4001df4c: 10 80 00 3b b 4001e038 <rtems_rfs_file_set_size+0x2ec>
4001df50: 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) /
4001df54: 92 87 7f ff addcc %i5, -1, %o1
4001df58: e2 04 20 08 ld [ %l0 + 8 ], %l1
4001df5c: 90 47 3f ff addx %i4, -1, %o0
4001df60: 94 10 20 00 clr %o2
4001df64: 40 00 46 76 call 4002f93c <__udivdi3>
4001df68: 96 10 00 11 mov %l1, %o3
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4001df6c: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001df70: 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));
4001df74: 90 10 00 1c mov %i4, %o0
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4001df78: 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));
4001df7c: 94 10 20 00 clr %o2
4001df80: 92 10 00 1d mov %i5, %o1
4001df84: 40 00 47 42 call 4002fc8c <__umoddi3>
4001df88: 96 10 00 11 mov %l1, %o3
if (blocks)
4001df8c: 80 a6 20 00 cmp %i0, 0
4001df90: 12 80 00 0b bne 4001dfbc <rtems_rfs_file_set_size+0x270>
4001df94: 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),
4001df98: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
4001df9c: 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;
4001dfa0: fa 26 a0 40 st %i5, [ %i2 + 0x40 ]
map->dirty = true;
4001dfa4: c2 2e a0 34 stb %g1, [ %i2 + 0x34 ]
4001dfa8: 80 a0 a0 00 cmp %g2, 0
4001dfac: 12 80 00 0d bne 4001dfe0 <rtems_rfs_file_set_size+0x294>
4001dfb0: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001dfb4: 10 80 00 0f b 4001dff0 <rtems_rfs_file_set_size+0x2a4>
4001dfb8: 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),
4001dfbc: 90 10 00 10 mov %l0, %o0
4001dfc0: 92 06 60 34 add %i1, 0x34, %o1
4001dfc4: 7f ff f5 47 call 4001b4e0 <rtems_rfs_block_map_shrink>
4001dfc8: 94 10 00 18 mov %i0, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
4001dfcc: 80 a2 20 00 cmp %o0, 0
4001dfd0: 34 80 00 27 bg,a 4001e06c <rtems_rfs_file_set_size+0x320><== NEVER TAKEN
4001dfd4: 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),
4001dfd8: 10 bf ff f1 b 4001df9c <rtems_rfs_file_set_size+0x250>
4001dfdc: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
4001dfe0: 80 a0 60 00 cmp %g1, 0
4001dfe4: 22 80 00 0e be,a 4001e01c <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
4001dfe8: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
4001dfec: 80 a0 80 01 cmp %g2, %g1
4001dff0: 3a 80 00 0b bcc,a 4001e01c <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
4001dff4: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
4001dff8: 86 00 7f ff add %g1, -1, %g3
4001dffc: 80 a0 80 03 cmp %g2, %g3
4001e000: 32 80 00 0e bne,a 4001e038 <rtems_rfs_file_set_size+0x2ec><== NEVER TAKEN
4001e004: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5 <== NOT EXECUTED
4001e008: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
4001e00c: 80 a0 80 1d cmp %g2, %i5
4001e010: 28 80 00 0a bleu,a 4001e038 <rtems_rfs_file_set_size+0x2ec>
4001e014: 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),
4001e018: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
4001e01c: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
4001e020: 80 a7 60 00 cmp %i5, 0
4001e024: 02 80 00 04 be 4001e034 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
4001e028: c0 26 e0 18 clr [ %i3 + 0x18 ]
4001e02c: 82 00 7f ff add %g1, -1, %g1
4001e030: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001e034: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
4001e038: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
4001e03c: c2 27 60 84 st %g1, [ %i5 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
4001e040: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
4001e044: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
if (rtems_rfs_file_update_mtime (handle))
4001e048: c2 06 c0 00 ld [ %i3 ], %g1
4001e04c: 80 88 60 02 btst 2, %g1
4001e050: 12 80 00 06 bne 4001e068 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
4001e054: 90 10 20 00 clr %o0
handle->shared->mtime = time (NULL);
4001e058: 40 00 22 18 call 400268b8 <time>
4001e05c: 90 10 20 00 clr %o0
4001e060: d0 27 60 90 st %o0, [ %i5 + 0x90 ]
}
return 0;
4001e064: 90 10 20 00 clr %o0
}
4001e068: b0 10 00 08 mov %o0, %i0
4001e06c: 81 c7 e0 08 ret
4001e070: 81 e8 00 00 restore
40010cf0 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
40010cf0: 9d e3 be c0 save %sp, -320, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
40010cf4: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40010cf8: 80 a0 60 00 cmp %g1, 0
40010cfc: 22 80 00 07 be,a 40010d18 <rtems_rfs_format+0x28> <== ALWAYS TAKEN
40010d00: 92 10 20 00 clr %o1
printf ("rtems-rfs: format: %s\n", name);
40010d04: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40010d08: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40010d0c: 40 00 46 85 call 40022720 <printf> <== NOT EXECUTED
40010d10: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40010d14: 92 10 20 00 clr %o1 <== NOT EXECUTED
40010d18: 94 10 20 84 mov 0x84, %o2
40010d1c: 40 00 46 03 call 40022528 <memset>
40010d20: 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;
40010d24: 82 07 bf c4 add %fp, -60, %g1
40010d28: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
40010d2c: 82 07 bf c0 add %fp, -64, %g1
40010d30: 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;
40010d34: 82 07 bf d4 add %fp, -44, %g1
40010d38: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
40010d3c: 82 07 bf d0 add %fp, -48, %g1
40010d40: 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;
40010d44: 82 07 bf e4 add %fp, -28, %g1
40010d48: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
40010d4c: 82 07 bf e0 add %fp, -32, %g1
40010d50: 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;
40010d54: 82 07 bf f4 add %fp, -12, %g1
40010d58: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
40010d5c: 82 07 bf f0 add %fp, -16, %g1
40010d60: 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;
40010d64: 82 10 20 05 mov 5, %g1
40010d68: 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;
40010d6c: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40010d70: 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;
40010d74: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40010d78: 40 00 2c 22 call 4001be00 <rtems_rfs_buffer_open>
40010d7c: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
40010d80: ba 92 20 00 orcc %o0, 0, %i5
40010d84: 04 80 00 08 ble 40010da4 <rtems_rfs_format+0xb4> <== ALWAYS TAKEN
40010d88: c2 07 bf 8c ld [ %fp + -116 ], %g1
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
40010d8c: 40 00 4a d1 call 400238d0 <strerror> <== NOT EXECUTED
40010d90: 01 00 00 00 nop <== NOT EXECUTED
40010d94: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010d98: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40010d9c: 10 80 03 0e b 400119d4 <rtems_rfs_format+0xce4> <== NOT EXECUTED
40010da0: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 40033ad8 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40010da4: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40010da8: 80 a0 60 00 cmp %g1, 0
40010dac: 32 80 00 08 bne,a 40010dcc <rtems_rfs_format+0xdc> <== ALWAYS TAKEN
40010db0: c2 06 40 00 ld [ %i1 ], %g1
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
40010db4: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40010db8: 92 10 20 00 clr %o1 <== NOT EXECUTED
40010dbc: 40 00 46 59 call 40022720 <printf> <== NOT EXECUTED
40010dc0: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
40010dc4: 81 c7 e0 08 ret <== NOT EXECUTED
40010dc8: 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)
40010dcc: 80 a0 60 00 cmp %g1, 0
40010dd0: 12 80 00 2a bne 40010e78 <rtems_rfs_format+0x188>
40010dd4: c2 27 bf 84 st %g1, [ %fp + -124 ]
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
40010dd8: 40 00 35 7f call 4001e3d4 <rtems_rfs_fs_media_size>
40010ddc: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
40010de0: 80 a2 20 00 cmp %o0, 0
40010de4: 12 80 00 08 bne 40010e04 <rtems_rfs_format+0x114> <== NEVER TAKEN
40010de8: 37 00 04 00 sethi %hi(0x100000), %i3
40010dec: 03 00 03 ff sethi %hi(0xffc00), %g1
40010df0: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <PROM_START+0xfffff>
40010df4: 80 a2 40 01 cmp %o1, %g1
40010df8: 08 80 00 16 bleu 40010e50 <rtems_rfs_format+0x160> <== ALWAYS TAKEN
40010dfc: c2 07 bf 84 ld [ %fp + -124 ], %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40010e00: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
40010e04: ba 82 40 1b addcc %o1, %i3, %i5 <== NOT EXECUTED
40010e08: 83 37 60 14 srl %i5, 0x14, %g1 <== NOT EXECUTED
40010e0c: b4 10 20 00 clr %i2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
40010e10: 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);
40010e14: b8 42 00 1a addx %o0, %i2, %i4 <== NOT EXECUTED
40010e18: 85 2f 20 0c sll %i4, 0xc, %g2 <== NOT EXECUTED
40010e1c: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
40010e20: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
40010e24: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
40010e28: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
40010e2c: 32 80 00 06 bne,a 40010e44 <rtems_rfs_format+0x154> <== NOT EXECUTED
40010e30: 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--)
40010e34: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
40010e38: 12 bf ff fc bne 40010e28 <rtems_rfs_format+0x138> <== NOT EXECUTED
40010e3c: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
40010e40: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
40010e44: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
40010e48: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
}
if (fs->block_size < 512)
40010e4c: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
40010e50: 80 a0 61 ff cmp %g1, 0x1ff
40010e54: 18 80 00 05 bgu 40010e68 <rtems_rfs_format+0x178> <== NEVER TAKEN
40010e58: c4 07 bf 84 ld [ %fp + -124 ], %g2
fs->block_size = 512;
40010e5c: 82 10 22 00 mov 0x200, %g1
40010e60: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
40010e64: c4 07 bf 84 ld [ %fp + -124 ], %g2
40010e68: 03 00 00 04 sethi %hi(0x1000), %g1
40010e6c: 80 a0 80 01 cmp %g2, %g1
40010e70: 38 80 00 02 bgu,a 40010e78 <rtems_rfs_format+0x188> <== NEVER TAKEN
40010e74: 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)
40010e78: c2 07 bf 8c ld [ %fp + -116 ], %g1
40010e7c: fa 07 bf 84 ld [ %fp + -124 ], %i5
40010e80: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
40010e84: 90 10 00 1d mov %i5, %o0
40010e88: 40 00 77 de call 4002ee00 <.urem>
40010e8c: 92 10 00 1c mov %i4, %o1
40010e90: 80 a2 20 00 cmp %o0, 0
40010e94: 22 80 00 07 be,a 40010eb0 <rtems_rfs_format+0x1c0> <== ALWAYS TAKEN
40010e98: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
40010e9c: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40010ea0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010ea4: 90 12 23 30 or %o0, 0x330, %o0 <== NOT EXECUTED
40010ea8: 10 80 02 cc b 400119d8 <rtems_rfs_format+0xce8> <== NOT EXECUTED
40010eac: 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)
40010eb0: 80 a0 60 00 cmp %g1, 0
40010eb4: 02 80 00 04 be 40010ec4 <rtems_rfs_format+0x1d4> <== ALWAYS TAKEN
40010eb8: 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;
40010ebc: 10 80 00 03 b 40010ec8 <rtems_rfs_format+0x1d8> <== NOT EXECUTED
40010ec0: 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);
40010ec4: fa 27 bf a4 st %i5, [ %fp + -92 ]
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
40010ec8: c2 07 bf a4 ld [ %fp + -92 ], %g1
40010ecc: 80 a0 40 1d cmp %g1, %i5
40010ed0: 08 80 00 04 bleu 40010ee0 <rtems_rfs_format+0x1f0> <== ALWAYS TAKEN
40010ed4: 11 10 00 ce sethi %hi(0x40033800), %o0
{
printf ("group block count is higher than bits in block\n");
40010ed8: 10 80 01 2f b 40011394 <rtems_rfs_format+0x6a4> <== NOT EXECUTED
40010edc: 90 12 23 70 or %o0, 0x370, %o0 ! 40033b70 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
40010ee0: 40 00 35 3d call 4001e3d4 <rtems_rfs_fs_media_size>
40010ee4: 90 07 bf 7c add %fp, -132, %o0
40010ee8: fa 07 bf 84 ld [ %fp + -124 ], %i5
40010eec: 94 10 20 00 clr %o2
40010ef0: 40 00 7a 93 call 4002f93c <__udivdi3>
40010ef4: 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));
40010ef8: 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;
40010efc: 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),
40010f00: 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;
40010f04: 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),
40010f08: 7f ff ff 6f call 40010cc4 <rtems_rfs_rup_quotient>
40010f0c: 92 10 00 1c mov %i4, %o1
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
40010f10: 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),
40010f14: d0 27 bf a0 st %o0, [ %fp + -96 ]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
40010f18: c2 27 bf a8 st %g1, [ %fp + -88 ]
if (!fs->group_inodes)
40010f1c: 80 a0 60 00 cmp %g1, 0
40010f20: 12 80 00 14 bne 40010f70 <rtems_rfs_format+0x280> <== NEVER TAKEN
40010f24: 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)
40010f28: d0 06 60 0c ld [ %i1 + 0xc ], %o0
40010f2c: 80 a2 20 00 cmp %o0, 0
40010f30: 22 80 00 02 be,a 40010f38 <rtems_rfs_format+0x248> <== ALWAYS TAKEN
40010f34: 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;
40010f38: 7f ff c5 97 call 40002594 <.umul>
40010f3c: 92 06 ff ff add %i3, -1, %o1
40010f40: 7f ff c5 cf call 4000267c <.udiv>
40010f44: 92 10 20 64 mov 0x64, %o1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
40010f48: 7f ff ff 5f call 40010cc4 <rtems_rfs_rup_quotient>
40010f4c: 92 10 00 1a mov %i2, %o1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40010f50: 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);
40010f54: b6 10 00 08 mov %o0, %i3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40010f58: 7f ff c5 c9 call 4000267c <.udiv>
40010f5c: 90 10 00 1d mov %i5, %o0
40010f60: 92 10 00 08 mov %o0, %o1
40010f64: 7f ff c5 8c call 40002594 <.umul>
40010f68: 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);
40010f6c: 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;
40010f70: 90 10 00 1d mov %i5, %o0
40010f74: 7f ff c5 c2 call 4000267c <.udiv>
40010f78: 92 10 20 38 mov 0x38, %o1
40010f7c: ba 10 00 08 mov %o0, %i5
40010f80: d0 27 bf ac st %o0, [ %fp + -84 ]
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
40010f84: d0 07 bf a8 ld [ %fp + -88 ], %o0
40010f88: 7f ff ff 4f call 40010cc4 <rtems_rfs_rup_quotient>
40010f8c: 92 10 00 1d mov %i5, %o1
fs->inodes_per_block) * fs->inodes_per_block;
40010f90: 7f ff c5 81 call 40002594 <.umul>
40010f94: 92 10 00 1d mov %i5, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40010f98: 80 a2 00 1c cmp %o0, %i4
40010f9c: 38 80 00 03 bgu,a 40010fa8 <rtems_rfs_format+0x2b8> <== NEVER TAKEN
40010fa0: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
40010fa4: 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;
40010fa8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
40010fac: 80 a0 60 00 cmp %g1, 0
40010fb0: 22 80 02 90 be,a 400119f0 <rtems_rfs_format+0xd00> <== ALWAYS TAKEN
40010fb4: 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;
40010fb8: 10 80 02 8f b 400119f4 <rtems_rfs_format+0xd04> <== NOT EXECUTED
40010fbc: 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",
40010fc0: 40 00 35 05 call 4001e3d4 <rtems_rfs_fs_media_size> <== NOT EXECUTED
40010fc4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40010fc8: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
40010fcc: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
40010fd0: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40010fd4: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
40010fd8: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
40010fdc: 40 00 45 d1 call 40022720 <printf> <== NOT EXECUTED
40010fe0: 90 12 23 a0 or %o0, 0x3a0, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
40010fe4: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
40010fe8: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40010fec: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
40010ff0: 40 00 45 cc call 40022720 <printf> <== NOT EXECUTED
40010ff4: 90 12 23 c8 or %o0, 0x3c8, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
40010ff8: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
40010ffc: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED
40011000: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
40011004: 40 00 45 c7 call 40022720 <printf> <== NOT EXECUTED
40011008: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
4001100c: 40 00 34 e9 call 4001e3b0 <rtems_rfs_fs_size> <== NOT EXECUTED
40011010: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40011014: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
40011018: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
4001101c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011020: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
40011024: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
40011028: 40 00 45 be call 40022720 <printf> <== NOT EXECUTED
4001102c: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
40011030: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
40011034: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011038: 40 00 45 ba call 40022720 <printf> <== NOT EXECUTED
4001103c: 90 12 20 40 or %o0, 0x40, %o0 ! 40033c40 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
40011040: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
40011044: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011048: 40 00 45 b6 call 40022720 <printf> <== NOT EXECUTED
4001104c: 90 12 20 68 or %o0, 0x68, %o0 ! 40033c68 <_CPU_Trap_slot_template+0x1b8><== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
40011050: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
40011054: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011058: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
4001105c: 40 00 45 b1 call 40022720 <printf> <== NOT EXECUTED
40011060: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
40011064: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
40011068: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
4001106c: 40 00 45 ad call 40022720 <printf> <== NOT EXECUTED
40011070: 90 12 20 b8 or %o0, 0xb8, %o0 ! 40033cb8 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40011074: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
40011078: 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",
4001107c: 7f ff c5 46 call 40002594 <.umul> <== NOT EXECUTED
40011080: 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));
40011084: 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",
40011088: 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,
4001108c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40011090: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
40011094: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
40011098: 7f ff ff 0b call 40010cc4 <rtems_rfs_rup_quotient> <== NOT EXECUTED
4001109c: 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))
400110a0: 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));
400110a4: 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))
400110a8: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
400110ac: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
400110b0: 28 80 00 02 bleu,a 400110b8 <rtems_rfs_format+0x3c8> <== NOT EXECUTED
400110b4: 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;
400110b8: 84 02 20 01 add %o0, 1, %g2 <== NOT EXECUTED
400110bc: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
400110c0: 89 28 a0 07 sll %g2, 7, %g4 <== NOT EXECUTED
400110c4: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
400110c8: 90 00 c0 02 add %g3, %g2, %o0 <== NOT EXECUTED
400110cc: 7f ff c5 6e call 40002684 <.div> <== NOT EXECUTED
400110d0: 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",
400110d4: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
400110d8: 7f ff c5 6b call 40002684 <.div> <== NOT EXECUTED
400110dc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
400110e0: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
400110e4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
400110e8: 40 00 77 48 call 4002ee08 <.rem> <== NOT EXECUTED
400110ec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400110f0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400110f4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400110f8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400110fc: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011100: 40 00 45 88 call 40022720 <printf> <== NOT EXECUTED
40011104: 90 12 20 e0 or %o0, 0xe0, %o0 ! 40033ce0 <_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);
40011108: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
4001110c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011110: 40 00 45 84 call 40022720 <printf> <== NOT EXECUTED
40011114: 90 12 21 10 or %o0, 0x110, %o0 ! 40033d10 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
40011118: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
4001111c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011120: 40 00 45 80 call 40022720 <printf> <== NOT EXECUTED
40011124: 90 12 21 30 or %o0, 0x130, %o0 ! 40033d30 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
40011128: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
4001112c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011130: 40 00 45 7c call 40022720 <printf> <== NOT EXECUTED
40011134: 90 12 21 58 or %o0, 0x158, %o0 ! 40033d58 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
40011138: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
4001113c: 40 00 2b d1 call 4001c080 <rtems_rfs_buffer_setblksize>
40011140: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
40011144: ba 92 20 00 orcc %o0, 0, %i5
40011148: 24 80 00 08 ble,a 40011168 <rtems_rfs_format+0x478> <== ALWAYS TAKEN
4001114c: c0 2f bf 30 clrb [ %fp + -208 ]
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
40011150: 40 00 49 e0 call 400238d0 <strerror> <== NOT EXECUTED
40011154: 01 00 00 00 nop <== NOT EXECUTED
40011158: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001115c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011160: 10 80 02 1d b 400119d4 <rtems_rfs_format+0xce4> <== NOT EXECUTED
40011164: 90 12 21 80 or %o0, 0x180, %o0 ! 40033d80 <_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;
40011168: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
4001116c: 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);
40011170: 90 07 bf 7c add %fp, -132, %o0
40011174: 92 07 bf 30 add %fp, -208, %o1
40011178: 94 10 20 00 clr %o2
4001117c: 40 00 2a 7b call 4001bb68 <rtems_rfs_buffer_handle_request>
40011180: 96 10 20 00 clr %o3
if (rc > 0)
40011184: ba 92 20 00 orcc %o0, 0, %i5
40011188: 04 80 00 0a ble 400111b0 <rtems_rfs_format+0x4c0> <== ALWAYS TAKEN
4001118c: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
40011190: 7f ff fe c3 call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
40011194: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
40011198: 40 00 49 ce call 400238d0 <strerror> <== NOT EXECUTED
4001119c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400111a0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400111a4: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
400111a8: 10 80 00 73 b 40011374 <rtems_rfs_format+0x684> <== NOT EXECUTED
400111ac: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 40033db8 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
400111b0: 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));
400111b4: 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);
400111b8: 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));
400111bc: 92 10 20 ff mov 0xff, %o1
400111c0: 40 00 44 da call 40022528 <memset>
400111c4: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400111c8: 82 10 20 28 mov 0x28, %g1
400111cc: c2 2f 40 00 stb %g1, [ %i5 ]
400111d0: 82 10 20 09 mov 9, %g1
400111d4: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
400111d8: 82 10 20 20 mov 0x20, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400111dc: 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);
400111e0: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400111e4: c0 2f 60 05 clrb [ %i5 + 5 ]
400111e8: c0 2f 60 06 clrb [ %i5 + 6 ]
400111ec: 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);
400111f0: 84 10 20 01 mov 1, %g2
400111f4: 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));
400111f8: 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);
400111fc: 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));
40011200: 87 30 60 18 srl %g1, 0x18, %g3
40011204: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
40011208: 87 30 60 10 srl %g1, 0x10, %g3
4001120c: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
40011210: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
40011214: 87 30 60 08 srl %g1, 8, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40011218: 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));
4001121c: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40011220: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
40011224: 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);
40011228: 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));
4001122c: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
40011230: c2 07 bf 84 ld [ %fp + -124 ], %g1
40011234: 83 30 60 08 srl %g1, 8, %g1
40011238: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
4001123c: c2 07 bf 84 ld [ %fp + -124 ], %g1
40011240: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40011244: c2 0f bf 94 ldub [ %fp + -108 ], %g1
40011248: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
4001124c: c2 17 bf 94 lduh [ %fp + -108 ], %g1
40011250: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
40011254: c2 07 bf 94 ld [ %fp + -108 ], %g1
40011258: 83 30 60 08 srl %g1, 8, %g1
4001125c: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
40011260: c2 07 bf 94 ld [ %fp + -108 ], %g1
40011264: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40011268: c2 0f bf 98 ldub [ %fp + -104 ], %g1
4001126c: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
40011270: c2 17 bf 98 lduh [ %fp + -104 ], %g1
40011274: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
40011278: c2 07 bf 98 ld [ %fp + -104 ], %g1
4001127c: 83 30 60 08 srl %g1, 8, %g1
40011280: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
40011284: c2 07 bf 98 ld [ %fp + -104 ], %g1
40011288: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
4001128c: c2 0f bf a0 ldub [ %fp + -96 ], %g1
40011290: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
40011294: c2 17 bf a0 lduh [ %fp + -96 ], %g1
40011298: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
4001129c: c2 07 bf a0 ld [ %fp + -96 ], %g1
400112a0: 83 30 60 08 srl %g1, 8, %g1
400112a4: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
400112a8: c2 07 bf a0 ld [ %fp + -96 ], %g1
400112ac: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
400112b0: c2 0f bf a4 ldub [ %fp + -92 ], %g1
400112b4: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
400112b8: c2 17 bf a4 lduh [ %fp + -92 ], %g1
400112bc: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
400112c0: c2 07 bf a4 ld [ %fp + -92 ], %g1
400112c4: 83 30 60 08 srl %g1, 8, %g1
400112c8: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
400112cc: c2 07 bf a4 ld [ %fp + -92 ], %g1
400112d0: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
400112d4: c2 0f bf a8 ldub [ %fp + -88 ], %g1
400112d8: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
400112dc: c2 17 bf a8 lduh [ %fp + -88 ], %g1
400112e0: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
400112e4: c2 07 bf a8 ld [ %fp + -88 ], %g1
400112e8: 83 30 60 08 srl %g1, 8, %g1
400112ec: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
400112f0: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
400112f4: 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);
400112f8: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
400112fc: c0 2f 60 25 clrb [ %i5 + 0x25 ]
40011300: c0 2f 60 26 clrb [ %i5 + 0x26 ]
40011304: 82 10 20 38 mov 0x38, %g1
40011308: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
4001130c: 40 00 29 a3 call 4001b998 <rtems_rfs_buffer_handle_release>
40011310: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
40011314: 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);
40011318: ba 10 00 08 mov %o0, %i5
if (rc > 0)
4001131c: 80 a7 60 00 cmp %i5, 0
40011320: 04 80 00 0a ble 40011348 <rtems_rfs_format+0x658> <== ALWAYS TAKEN
40011324: 90 07 bf 7c add %fp, -132, %o0
{
rtems_rfs_buffer_handle_close (fs, &handle);
40011328: 7f ff fe 5d call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001132c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
40011330: 40 00 49 68 call 400238d0 <strerror> <== NOT EXECUTED
40011334: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011338: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001133c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011340: 10 80 00 0d b 40011374 <rtems_rfs_format+0x684> <== NOT EXECUTED
40011344: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 40033df0 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
40011348: 7f ff fe 55 call 40010c9c <rtems_rfs_buffer_handle_close>
4001134c: 01 00 00 00 nop
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
}
return true;
40011350: 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)
40011354: 80 a2 20 00 cmp %o0, 0
40011358: 04 80 00 0a ble 40011380 <rtems_rfs_format+0x690> <== ALWAYS TAKEN
4001135c: ba 10 00 08 mov %o0, %i5
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
40011360: 40 00 49 5c call 400238d0 <strerror> <== NOT EXECUTED
40011364: 01 00 00 00 nop <== NOT EXECUTED
40011368: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001136c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011370: 90 12 22 30 or %o0, 0x230, %o0 ! 40033e30 <_CPU_Trap_slot_template+0x380><== NOT EXECUTED
40011374: 40 00 44 eb call 40022720 <printf> <== NOT EXECUTED
40011378: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
return false;
4001137c: 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))
40011380: 80 88 60 ff btst 0xff, %g1
40011384: 12 80 00 f3 bne 40011750 <rtems_rfs_format+0xa60> <== ALWAYS TAKEN
40011388: ba 10 20 00 clr %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
4001138c: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011390: 90 12 22 78 or %o0, 0x278, %o0 ! 40033e78 <_CPU_Trap_slot_template+0x3c8><== NOT EXECUTED
40011394: 40 00 45 7b call 40022980 <puts> <== NOT EXECUTED
40011398: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001139c: 30 80 01 93 b,a 400119e8 <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);
400113a0: f8 07 bf a4 ld [ %fp + -92 ], %i4
400113a4: 90 10 00 1d mov %i5, %o0
400113a8: 7f ff c4 7b call 40002594 <.umul>
400113ac: 92 10 00 1c mov %i4, %o1
if (group_base > rtems_rfs_fs_blocks (fs))
400113b0: 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);
400113b4: 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,
400113b8: 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))
400113bc: 80 a4 00 01 cmp %l0, %g1
400113c0: 08 80 00 08 bleu 400113e0 <rtems_rfs_format+0x6f0> <== ALWAYS TAKEN
400113c4: b4 10 00 08 mov %o0, %i2
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
400113c8: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
400113cc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400113d0: 40 00 44 d4 call 40022720 <printf> <== NOT EXECUTED
400113d4: 90 12 22 a8 or %o0, 0x2a8, %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;
400113d8: 10 80 00 d9 b 4001173c <rtems_rfs_format+0xa4c> <== NOT EXECUTED
400113dc: 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))
400113e0: 84 04 00 1c add %l0, %i4, %g2
400113e4: 80 a0 80 01 cmp %g2, %g1
400113e8: 38 80 00 02 bgu,a 400113f0 <rtems_rfs_format+0x700> <== ALWAYS TAKEN
400113ec: b8 20 40 10 sub %g1, %l0, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
400113f0: 80 8d e0 ff btst 0xff, %l7
400113f4: 22 80 00 09 be,a 40011418 <rtems_rfs_format+0x728> <== ALWAYS TAKEN
400113f8: c0 2f bf 30 clrb [ %fp + -208 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400113fc: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011400: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011404: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
40011408: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001140c: 40 00 44 c5 call 40022720 <printf> <== NOT EXECUTED
40011410: 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;
40011414: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40011418: 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)
4001141c: 80 8d e0 ff btst 0xff, %l7
40011420: 02 80 00 05 be 40011434 <rtems_rfs_format+0x744> <== ALWAYS TAKEN
40011424: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
40011428: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
4001142c: 40 00 44 bd call 40022720 <printf> <== NOT EXECUTED
40011430: 90 12 23 20 or %o0, 0x320, %o0 ! 40033f20 <_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,
40011434: 98 10 00 10 mov %l0, %o4
40011438: b6 07 bf 3c add %fp, -196, %i3
4001143c: 92 07 bf 7c add %fp, -132, %o1
40011440: 90 10 00 1b mov %i3, %o0
40011444: 94 07 bf 30 add %fp, -208, %o2
40011448: 40 00 24 c4 call 4001a758 <rtems_rfs_bitmap_open>
4001144c: 96 10 00 1c mov %i4, %o3
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40011450: a0 92 20 00 orcc %o0, 0, %l0
40011454: 04 80 00 0a ble 4001147c <rtems_rfs_format+0x78c> <== ALWAYS TAKEN
40011458: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001145c: 7f ff fe 10 call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
40011460: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40011464: 40 00 49 1b call 400238d0 <strerror> <== NOT EXECUTED
40011468: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001146c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40011470: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011474: 10 80 00 17 b 400114d0 <rtems_rfs_format+0x7e0> <== NOT EXECUTED
40011478: 90 12 23 30 or %o0, 0x330, %o0 ! 40033f30 <_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));
4001147c: c2 07 bf 38 ld [ %fp + -200 ], %g1
40011480: d4 07 bf 84 ld [ %fp + -124 ], %o2
40011484: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40011488: 40 00 44 28 call 40022528 <memset>
4001148c: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40011490: 40 00 24 0b call 4001a4bc <rtems_rfs_bitmap_map_clear_all>
40011494: 90 10 00 1b mov %i3, %o0
40011498: a0 10 00 08 mov %o0, %l0
if (rc > 0)
4001149c: 80 a4 20 00 cmp %l0, 0
400114a0: 04 80 00 0f ble 400114dc <rtems_rfs_format+0x7ec> <== ALWAYS TAKEN
400114a4: 90 10 00 1b mov %i3, %o0
{
rtems_rfs_bitmap_close (&bitmap);
400114a8: 40 00 24 bd call 4001a79c <rtems_rfs_bitmap_close> <== NOT EXECUTED
400114ac: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
400114b0: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
400114b4: 7f ff fd fa call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400114b8: 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",
400114bc: 40 00 49 05 call 400238d0 <strerror> <== NOT EXECUTED
400114c0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400114c4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400114c8: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
400114cc: 90 12 23 78 or %o0, 0x378, %o0 ! 40033f78 <_CPU_Trap_slot_template+0x4c8><== NOT EXECUTED
400114d0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400114d4: 10 80 00 5e b 4001164c <rtems_rfs_format+0x95c> <== NOT EXECUTED
400114d8: 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);
400114dc: 40 00 23 74 call 4001a2ac <rtems_rfs_bitmap_map_set>
400114e0: 92 10 20 00 clr %o1
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
400114e4: 92 10 20 01 mov 1, %o1
400114e8: 40 00 23 71 call 4001a2ac <rtems_rfs_bitmap_map_set>
400114ec: 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);
400114f0: d0 07 bf a8 ld [ %fp + -88 ], %o0
400114f4: d2 07 bf ac ld [ %fp + -84 ], %o1
400114f8: 7f ff fd f3 call 40010cc4 <rtems_rfs_rup_quotient>
400114fc: a2 10 20 00 clr %l1
40011500: 10 80 00 05 b 40011514 <rtems_rfs_format+0x824>
40011504: 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);
40011508: 92 04 60 02 add %l1, 2, %o1
4001150c: 40 00 23 68 call 4001a2ac <rtems_rfs_bitmap_map_set>
40011510: 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++)
40011514: 80 a4 40 10 cmp %l1, %l0
40011518: 06 bf ff fc bl 40011508 <rtems_rfs_format+0x818>
4001151c: 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);
40011520: 40 00 24 9f call 4001a79c <rtems_rfs_bitmap_close>
40011524: 01 00 00 00 nop
if (rc > 0)
40011528: b6 92 20 00 orcc %o0, 0, %i3
4001152c: 24 80 00 0d ble,a 40011560 <rtems_rfs_format+0x870> <== ALWAYS TAKEN
40011530: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
40011534: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40011538: 7f ff fd d9 call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001153c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40011540: 40 00 48 e4 call 400238d0 <strerror> <== NOT EXECUTED
40011544: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40011548: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001154c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40011550: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40011554: 11 10 00 cf sethi %hi(0x40033c00), %o0 <== NOT EXECUTED
40011558: 10 80 00 3d b 4001164c <rtems_rfs_format+0x95c> <== NOT EXECUTED
4001155c: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40033fc8 <_CPU_Trap_slot_template+0x518><== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
40011560: 80 8d e0 ff btst 0xff, %l7
40011564: 02 80 00 05 be 40011578 <rtems_rfs_format+0x888> <== ALWAYS TAKEN
40011568: c2 2f bf 30 stb %g1, [ %fp + -208 ]
printf (", inodes");
4001156c: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40011570: 40 00 44 6c call 40022720 <printf> <== NOT EXECUTED
40011574: 90 12 20 10 or %o0, 0x10, %o0 ! 40034010 <_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,
40011578: 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,
4001157c: 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,
40011580: b6 07 bf 30 add %fp, -208, %i3
40011584: 90 07 bf 3c add %fp, -196, %o0
40011588: 92 10 00 17 mov %l7, %o1
4001158c: 94 10 00 1b mov %i3, %o2
40011590: 40 00 24 72 call 4001a758 <rtems_rfs_bitmap_open>
40011594: 98 06 a0 02 add %i2, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40011598: b8 92 20 00 orcc %o0, 0, %i4
4001159c: 04 80 00 09 ble 400115c0 <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
400115a0: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
400115a4: 7f ff fd be call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400115a8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400115ac: 40 00 48 c9 call 400238d0 <strerror> <== NOT EXECUTED
400115b0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400115b4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400115b8: 10 80 00 23 b 40011644 <rtems_rfs_format+0x954> <== NOT EXECUTED
400115bc: 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));
400115c0: c2 07 bf 38 ld [ %fp + -200 ], %g1
400115c4: d4 07 bf 84 ld [ %fp + -124 ], %o2
400115c8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400115cc: 40 00 43 d7 call 40022528 <memset>
400115d0: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
400115d4: 40 00 23 ba call 4001a4bc <rtems_rfs_bitmap_map_clear_all>
400115d8: 90 07 bf 3c add %fp, -196, %o0
400115dc: b8 10 00 08 mov %o0, %i4
if (rc > 0)
400115e0: 80 a7 20 00 cmp %i4, 0
400115e4: 04 80 00 0c ble 40011614 <rtems_rfs_format+0x924> <== ALWAYS TAKEN
400115e8: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
400115ec: 40 00 24 6c call 4001a79c <rtems_rfs_bitmap_close> <== NOT EXECUTED
400115f0: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
400115f4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400115f8: 7f ff fd a9 call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400115fc: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
40011600: 40 00 48 b4 call 400238d0 <strerror> <== NOT EXECUTED
40011604: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40011608: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001160c: 10 80 00 0e b 40011644 <rtems_rfs_format+0x954> <== NOT EXECUTED
40011610: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
40011614: 40 00 24 62 call 4001a79c <rtems_rfs_bitmap_close>
40011618: 01 00 00 00 nop
if (rc > 0)
4001161c: b8 92 20 00 orcc %o0, 0, %i4
40011620: 24 80 00 0f ble,a 4001165c <rtems_rfs_format+0x96c> <== ALWAYS TAKEN
40011624: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
40011628: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001162c: 7f ff fd 9c call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
40011630: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
40011634: 40 00 48 a7 call 400238d0 <strerror> <== NOT EXECUTED
40011638: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001163c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40011640: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40011644: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011648: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001164c: 40 00 44 35 call 40022720 <printf> <== NOT EXECUTED
40011650: 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;
40011654: 10 80 00 3a b 4001173c <rtems_rfs_format+0xa4c> <== NOT EXECUTED
40011658: 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);
4001165c: c2 2f bf 30 stb %g1, [ %fp + -208 ]
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
40011660: 80 8d a0 ff btst 0xff, %l6
40011664: 12 80 00 27 bne 40011700 <rtems_rfs_format+0xa10> <== NEVER TAKEN
40011668: a2 10 20 00 clr %l1
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4001166c: 90 07 bf 7c add %fp, -132, %o0
40011670: 7f ff fd 8b call 40010c9c <rtems_rfs_buffer_handle_close>
40011674: 92 07 bf 30 add %fp, -208, %o1
if (rc > 0)
40011678: b8 92 20 00 orcc %o0, 0, %i4
4001167c: 04 80 00 30 ble 4001173c <rtems_rfs_format+0xa4c> <== ALWAYS TAKEN
40011680: 82 10 20 01 mov 1, %g1
40011684: 30 80 00 27 b,a 40011720 <rtems_rfs_format+0xa30> <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40011688: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
4001168c: 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,
40011690: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40011694: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40011698: 40 00 29 34 call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001169c: 96 10 20 00 clr %o3 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
400116a0: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
400116a4: 04 80 00 10 ble 400116e4 <rtems_rfs_format+0x9f4> <== NOT EXECUTED
400116a8: c4 07 bf 38 ld [ %fp + -200 ], %g2 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
400116ac: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400116b0: 7f ff fd 7b call 40010c9c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
400116b4: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
400116b8: 40 00 48 86 call 400238d0 <strerror> <== NOT EXECUTED
400116bc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400116c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400116c4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
400116c8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400116cc: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400116d0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
400116d4: 40 00 44 13 call 40022720 <printf> <== NOT EXECUTED
400116d8: 90 12 21 00 or %o0, 0x100, %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;
400116dc: 10 80 00 18 b 4001173c <rtems_rfs_format+0xa4c> <== NOT EXECUTED
400116e0: 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));
400116e4: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
400116e8: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0 <== NOT EXECUTED
400116ec: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
400116f0: 40 00 43 8e call 40022528 <memset> <== NOT EXECUTED
400116f4: a2 04 60 01 inc %l1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
400116f8: 10 80 00 05 b 4001170c <rtems_rfs_format+0xa1c> <== NOT EXECUTED
400116fc: 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,
40011700: 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);
40011704: 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,
40011708: 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++)
4001170c: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
40011710: 06 bf ff de bl 40011688 <rtems_rfs_format+0x998> <== NOT EXECUTED
40011714: c2 07 bf 24 ld [ %fp + -220 ], %g1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
40011718: 10 bf ff d6 b 40011670 <rtems_rfs_format+0x980> <== NOT EXECUTED
4001171c: 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",
40011720: 40 00 48 6c call 400238d0 <strerror> <== NOT EXECUTED
40011724: 01 00 00 00 nop <== NOT EXECUTED
40011728: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001172c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011730: 40 00 43 fc call 40022720 <printf> <== NOT EXECUTED
40011734: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rc, strerror (rc));
return false;
40011738: 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,
4001173c: 80 88 60 ff btst 0xff, %g1
40011740: 02 80 00 a9 be 400119e4 <rtems_rfs_format+0xcf4> <== NEVER TAKEN
40011744: ba 07 60 01 inc %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
40011748: 10 80 00 0b b 40011774 <rtems_rfs_format+0xa84>
4001174c: 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",
40011750: 25 10 00 d0 sethi %hi(0x40034000), %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" \
40011754: 27 10 00 d0 sethi %hi(0x40034000), %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" \
40011758: 29 10 00 d0 sethi %hi(0x40034000), %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",
4001175c: 2b 10 00 d0 sethi %hi(0x40034000), %l5
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
40011760: a4 14 a1 48 or %l2, 0x148, %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" \
40011764: a6 14 e0 b8 or %l3, 0xb8, %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" \
40011768: a8 15 20 68 or %l4, 0x68, %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",
4001176c: aa 15 60 20 or %l5, 0x20, %l5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
40011770: c2 07 bf a0 ld [ %fp + -96 ], %g1
40011774: 80 a7 40 01 cmp %i5, %g1
40011778: 06 bf ff 0a bl 400113a0 <rtems_rfs_format+0x6b0>
4001177c: 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)
40011780: 80 8d e0 ff btst 0xff, %l7
40011784: 02 80 00 04 be 40011794 <rtems_rfs_format+0xaa4> <== ALWAYS TAKEN
40011788: 01 00 00 00 nop
printf ("\n");
4001178c: 40 00 44 4f call 400228c8 <putchar> <== NOT EXECUTED
40011790: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
40011794: 40 00 2a 76 call 4001c16c <rtems_rfs_buffer_close>
40011798: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
4001179c: ba 92 20 00 orcc %o0, 0, %i5
400117a0: 24 80 00 08 ble,a 400117c0 <rtems_rfs_format+0xad0> <== ALWAYS TAKEN
400117a4: 90 10 00 18 mov %i0, %o0
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
400117a8: 40 00 48 4a call 400238d0 <strerror> <== NOT EXECUTED
400117ac: 01 00 00 00 nop <== NOT EXECUTED
400117b0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400117b4: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400117b8: 10 80 00 87 b 400119d4 <rtems_rfs_format+0xce4> <== NOT EXECUTED
400117bc: 90 12 21 88 or %o0, 0x188, %o0 ! 40034188 <_CPU_Trap_slot_template+0x6d8><== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
400117c0: 92 10 20 00 clr %o1
400117c4: 94 10 20 06 mov 6, %o2
400117c8: 96 10 20 00 clr %o3
400117cc: 40 00 33 0c call 4001e3fc <rtems_rfs_fs_open>
400117d0: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
400117d4: 80 a2 20 00 cmp %o0, 0
400117d8: 36 80 00 0e bge,a 40011810 <rtems_rfs_format+0xb20> <== ALWAYS TAKEN
400117dc: d0 07 bf 28 ld [ %fp + -216 ], %o0
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
400117e0: 40 00 3e 77 call 400211bc <__errno> <== NOT EXECUTED
400117e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
400117e8: 40 00 3e 75 call 400211bc <__errno> <== NOT EXECUTED
400117ec: 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",
400117f0: 40 00 48 38 call 400238d0 <strerror> <== NOT EXECUTED
400117f4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400117f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400117fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011800: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40011804: 40 00 43 c7 call 40022720 <printf> <== NOT EXECUTED
40011808: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400341b8 <_CPU_Trap_slot_template+0x708><== NOT EXECUTED
4001180c: 30 80 00 77 b,a 400119e8 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
40011810: 92 10 20 01 mov 1, %o1
40011814: 40 00 02 38 call 400120f4 <rtems_rfs_inode_alloc>
40011818: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
4001181c: ba 92 20 00 orcc %o0, 0, %i5
40011820: 04 80 00 0a ble 40011848 <rtems_rfs_format+0xb58> <== ALWAYS TAKEN
40011824: d2 07 bf 2c ld [ %fp + -212 ], %o1
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
40011828: 40 00 48 2a call 400238d0 <strerror> <== NOT EXECUTED
4001182c: 01 00 00 00 nop <== NOT EXECUTED
40011830: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011834: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011838: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
4001183c: 40 00 43 b9 call 40022720 <printf> <== NOT EXECUTED
40011840: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400341f0 <_CPU_Trap_slot_template+0x740><== NOT EXECUTED
40011844: 30 80 00 06 b,a 4001185c <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
40011848: 80 a2 60 01 cmp %o1, 1
4001184c: 02 80 00 08 be 4001186c <rtems_rfs_format+0xb7c> <== ALWAYS TAKEN
40011850: 11 10 00 d0 sethi %hi(0x40034000), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40011854: 40 00 43 b3 call 40022720 <printf> <== NOT EXECUTED
40011858: 90 12 22 28 or %o0, 0x228, %o0 ! 40034228 <_CPU_Trap_slot_template+0x778><== NOT EXECUTED
rtems_rfs_fs_close (fs);
4001185c: 40 00 34 e3 call 4001ebe8 <rtems_rfs_fs_close> <== NOT EXECUTED
40011860: 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)
40011864: 10 80 00 55 b 400119b8 <rtems_rfs_format+0xcc8> <== NOT EXECUTED
40011868: 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);
4001186c: d0 07 bf 28 ld [ %fp + -216 ], %o0
40011870: 92 10 20 01 mov 1, %o1
40011874: 94 07 bf 54 add %fp, -172, %o2
40011878: 40 00 02 5b call 400121e4 <rtems_rfs_inode_open>
4001187c: 96 10 20 01 mov 1, %o3
if (rc > 0)
40011880: ba 92 20 00 orcc %o0, 0, %i5
40011884: 24 80 00 0e ble,a 400118bc <rtems_rfs_format+0xbcc> <== ALWAYS TAKEN
40011888: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
4001188c: 40 00 48 11 call 400238d0 <strerror> <== NOT EXECUTED
40011890: 01 00 00 00 nop <== NOT EXECUTED
40011894: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011898: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001189c: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400118a0: 40 00 43 a0 call 40022720 <printf> <== NOT EXECUTED
400118a4: 90 12 22 60 or %o0, 0x260, %o0 ! 40034260 <_CPU_Trap_slot_template+0x7b0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
400118a8: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
400118ac: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
400118b0: 40 00 01 7c call 40011ea0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
400118b4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
400118b8: 30 bf ff e9 b,a 4001185c <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
400118bc: 92 10 20 00 clr %o1
400118c0: 15 00 00 10 sethi %hi(0x4000), %o2
400118c4: 96 10 20 00 clr %o3
400118c8: 94 12 a1 c9 or %o2, 0x1c9, %o2
400118cc: 40 00 03 39 call 400125b0 <rtems_rfs_inode_initialise>
400118d0: 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)
400118d4: ba 92 20 00 orcc %o0, 0, %i5
400118d8: 24 80 00 0a ble,a 40011900 <rtems_rfs_format+0xc10> <== ALWAYS TAKEN
400118dc: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
400118e0: 40 00 47 fc call 400238d0 <strerror> <== NOT EXECUTED
400118e4: 01 00 00 00 nop <== NOT EXECUTED
400118e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400118ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400118f0: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400118f4: 40 00 43 8b call 40022720 <printf> <== NOT EXECUTED
400118f8: 90 12 22 90 or %o0, 0x290, %o0 ! 40034290 <_CPU_Trap_slot_template+0x7e0><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
400118fc: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40011900: d8 07 bf 2c ld [ %fp + -212 ], %o4
40011904: 92 07 bf 54 add %fp, -172, %o1
40011908: 15 10 00 c8 sethi %hi(0x40032000), %o2
4001190c: 96 10 20 01 mov 1, %o3
40011910: 40 00 2b 93 call 4001c75c <rtems_rfs_dir_add_entry>
40011914: 94 12 a3 d0 or %o2, 0x3d0, %o2
if (rc > 0)
40011918: ba 92 20 00 orcc %o0, 0, %i5
4001191c: 24 80 00 0a ble,a 40011944 <rtems_rfs_format+0xc54> <== ALWAYS TAKEN
40011920: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40011924: 40 00 47 eb call 400238d0 <strerror> <== NOT EXECUTED
40011928: 01 00 00 00 nop <== NOT EXECUTED
4001192c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011930: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011934: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40011938: 40 00 43 7a call 40022720 <printf> <== NOT EXECUTED
4001193c: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 400342c8 <_CPU_Trap_slot_template+0x818><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
40011940: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40011944: 40 00 02 9a call 400123ac <rtems_rfs_inode_close>
40011948: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
4001194c: ba 92 20 00 orcc %o0, 0, %i5
40011950: 04 80 00 09 ble 40011974 <rtems_rfs_format+0xc84> <== ALWAYS TAKEN
40011954: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40011958: 40 00 47 de call 400238d0 <strerror> <== NOT EXECUTED
4001195c: 01 00 00 00 nop <== NOT EXECUTED
40011960: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011964: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011968: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
4001196c: 40 00 43 6d call 40022720 <printf> <== NOT EXECUTED
40011970: 90 12 23 00 or %o0, 0x300, %o0 ! 40034300 <_CPU_Trap_slot_template+0x850><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
40011974: 40 00 34 9d call 4001ebe8 <rtems_rfs_fs_close>
40011978: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
4001197c: ba 92 20 00 orcc %o0, 0, %i5
40011980: 16 80 00 0e bge 400119b8 <rtems_rfs_format+0xcc8> <== ALWAYS TAKEN
40011984: 80 a7 60 00 cmp %i5, 0
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
40011988: 40 00 3e 0d call 400211bc <__errno> <== NOT EXECUTED
4001198c: 01 00 00 00 nop <== NOT EXECUTED
40011990: 40 00 3e 0b call 400211bc <__errno> <== NOT EXECUTED
40011994: 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",
40011998: 40 00 47 ce call 400238d0 <strerror> <== NOT EXECUTED
4001199c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400119a0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400119a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400119a8: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400119ac: 40 00 43 5d call 40022720 <printf> <== NOT EXECUTED
400119b0: 90 12 23 30 or %o0, 0x330, %o0 ! 40034330 <_CPU_Trap_slot_template+0x880><== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
400119b4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400119b8: 24 80 00 0c ble,a 400119e8 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
400119bc: b0 10 20 00 clr %i0
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
400119c0: 40 00 47 c4 call 400238d0 <strerror> <== NOT EXECUTED
400119c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400119c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400119cc: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
400119d0: 90 12 23 68 or %o0, 0x368, %o0 ! 40034368 <_CPU_Trap_slot_template+0x8b8><== NOT EXECUTED
400119d4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400119d8: 40 00 43 52 call 40022720 <printf> <== NOT EXECUTED
400119dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400119e0: 30 80 00 02 b,a 400119e8 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
400119e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400119e8: 81 c7 e0 08 ret
400119ec: 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;
400119f0: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
400119f4: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
400119f8: 80 a0 60 00 cmp %g1, 0
400119fc: 02 bf fd d0 be 4001113c <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
40011a00: d2 07 bf 84 ld [ %fp + -124 ], %o1
40011a04: 30 bf fd 6f b,a 40010fc0 <rtems_rfs_format+0x2d0> <== NOT EXECUTED
4001ebe8 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001ebe8: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
4001ebec: 90 10 20 00 clr %o0
4001ebf0: 7f ff d4 06 call 40013c08 <rtems_rfs_trace>
4001ebf4: 92 10 20 02 mov 2, %o1
4001ebf8: 80 8a 20 ff btst 0xff, %o0
4001ebfc: 22 80 00 06 be,a 4001ec14 <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
4001ec00: b8 10 20 00 clr %i4
printf ("rtems-rfs: close\n");
4001ec04: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001ec08: 40 00 0f 5e call 40022980 <puts> <== NOT EXECUTED
4001ec0c: 90 12 20 28 or %o0, 0x28, %o0 ! 40036828 <CSWTCH.2+0x13e8><== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001ec10: b8 10 20 00 clr %i4 <== NOT EXECUTED
4001ec14: 10 80 00 07 b 4001ec30 <rtems_rfs_fs_close+0x48>
4001ec18: 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]);
4001ec1c: 90 10 00 18 mov %i0, %o0
4001ec20: 92 02 40 1c add %o1, %i4, %o1
4001ec24: 7f ff cb f7 call 40011c00 <rtems_rfs_group_close>
4001ec28: ba 07 60 01 inc %i5
4001ec2c: 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++)
4001ec30: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001ec34: 80 a7 40 01 cmp %i5, %g1
4001ec38: 26 bf ff f9 bl,a 4001ec1c <rtems_rfs_fs_close+0x34>
4001ec3c: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
4001ec40: 7f ff f5 4b call 4001c16c <rtems_rfs_buffer_close>
4001ec44: 90 10 00 18 mov %i0, %o0
free (fs);
4001ec48: 90 10 00 18 mov %i0, %o0
4001ec4c: 7f ff a6 d4 call 4000879c <free>
4001ec50: b0 10 20 00 clr %i0
return 0;
}
4001ec54: 81 c7 e0 08 ret
4001ec58: 81 e8 00 00 restore
4001e3fc <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)
{
4001e3fc: 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))
4001e400: 90 10 20 00 clr %o0
4001e404: 7f ff d6 01 call 40013c08 <rtems_rfs_trace>
4001e408: 92 10 20 01 mov 1, %o1
4001e40c: 80 8a 20 ff btst 0xff, %o0
4001e410: 02 80 00 05 be 4001e424 <rtems_rfs_fs_open+0x28> <== ALWAYS TAKEN
4001e414: 11 10 00 d9 sethi %hi(0x40036400), %o0
printf ("rtems-rfs: open: %s\n", name);
4001e418: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001e41c: 40 00 10 c1 call 40022720 <printf> <== NOT EXECUTED
4001e420: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
4001e424: 7f ff aa 6f call 40008de0 <malloc>
4001e428: 90 10 20 84 mov 0x84, %o0
if (!*fs)
4001e42c: 80 a2 20 00 cmp %o0, 0
4001e430: 12 80 00 0f bne 4001e46c <rtems_rfs_fs_open+0x70> <== ALWAYS TAKEN
4001e434: d0 27 00 00 st %o0, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e438: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e43c: 7f ff d5 f3 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e440: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e444: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e448: 02 80 00 05 be 4001e45c <rtems_rfs_fs_open+0x60> <== NOT EXECUTED
4001e44c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
4001e450: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e454: 40 00 11 4b call 40022980 <puts> <== NOT EXECUTED
4001e458: 90 12 21 00 or %o0, 0x100, %o0 ! 40036500 <CSWTCH.2+0x10c0><== NOT EXECUTED
errno = ENOMEM;
4001e45c: 40 00 0b 58 call 400211bc <__errno> <== NOT EXECUTED
4001e460: 01 00 00 00 nop <== NOT EXECUTED
4001e464: 10 80 01 c5 b 4001eb78 <rtems_rfs_fs_open+0x77c> <== NOT EXECUTED
4001e468: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
4001e46c: 92 10 20 00 clr %o1
4001e470: 40 00 10 2e call 40022528 <memset>
4001e474: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
4001e478: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001e47c: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
4001e480: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
4001e484: 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;
4001e488: 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 );
4001e48c: 84 00 60 44 add %g1, 0x44, %g2
4001e490: 86 00 60 48 add %g1, 0x48, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001e494: 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;
4001e498: c6 20 60 44 st %g3, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
4001e49c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001e4a0: 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 );
4001e4a4: 84 00 60 54 add %g1, 0x54, %g2
4001e4a8: 86 00 60 58 add %g1, 0x58, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001e4ac: 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;
4001e4b0: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
4001e4b4: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001e4b8: 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 );
4001e4bc: 84 00 60 64 add %g1, 0x64, %g2
4001e4c0: 86 00 60 68 add %g1, 0x68, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001e4c4: 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;
4001e4c8: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
4001e4cc: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001e4d0: 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 );
4001e4d4: 84 00 60 74 add %g1, 0x74, %g2
4001e4d8: 86 00 60 78 add %g1, 0x78, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001e4dc: 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;
4001e4e0: c6 20 60 74 st %g3, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
4001e4e4: d2 07 00 00 ld [ %i4 ], %o1
4001e4e8: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
4001e4ec: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
4001e4f0: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
4001e4f4: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001e4f8: 7f ff f6 42 call 4001be00 <rtems_rfs_buffer_open>
4001e4fc: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
4001e500: ba 92 20 00 orcc %o0, 0, %i5
4001e504: 04 80 00 16 ble 4001e55c <rtems_rfs_fs_open+0x160> <== ALWAYS TAKEN
4001e508: f6 07 00 00 ld [ %i4 ], %i3
{
free (*fs);
4001e50c: 7f ff a8 a4 call 4000879c <free> <== NOT EXECUTED
4001e510: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e514: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e518: 7f ff d5 bc call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e51c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e520: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e524: 02 80 00 09 be 4001e548 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001e528: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
4001e52c: 40 00 14 e9 call 400238d0 <strerror> <== NOT EXECUTED
4001e530: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e534: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e538: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e53c: 90 12 21 30 or %o0, 0x130, %o0 ! 40036530 <CSWTCH.2+0x10f0><== NOT EXECUTED
4001e540: 40 00 10 78 call 40022720 <printf> <== NOT EXECUTED
4001e544: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
4001e548: 40 00 0b 1d call 400211bc <__errno> <== NOT EXECUTED
4001e54c: 01 00 00 00 nop <== NOT EXECUTED
4001e550: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
4001e554: 81 c7 e0 08 ret <== NOT EXECUTED
4001e558: 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;
4001e55c: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
4001e560: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
4001e564: 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);
4001e568: 90 10 00 1b mov %i3, %o0
4001e56c: 92 07 bf cc add %fp, -52, %o1
4001e570: 94 10 20 00 clr %o2
4001e574: 7f ff f5 7d call 4001bb68 <rtems_rfs_buffer_handle_request>
4001e578: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001e57c: ba 92 20 00 orcc %o0, 0, %i5
4001e580: 04 80 00 0d ble 4001e5b4 <rtems_rfs_fs_open+0x1b8> <== ALWAYS TAKEN
4001e584: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e588: 7f ff d5 a0 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e58c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e590: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e594: 22 80 01 2d be,a 4001ea48 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001e598: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
4001e59c: 40 00 14 cd call 400238d0 <strerror> <== NOT EXECUTED
4001e5a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e5a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e5a8: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e5ac: 10 80 00 de b 4001e924 <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
4001e5b0: 90 12 21 60 or %o0, 0x160, %o0 ! 40036560 <CSWTCH.2+0x1120><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
4001e5b4: c2 07 bf d4 ld [ %fp + -44 ], %g1
4001e5b8: 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)
4001e5bc: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001e5c0: c4 0f 40 00 ldub [ %i5 ], %g2
4001e5c4: 83 28 60 10 sll %g1, 0x10, %g1
4001e5c8: 85 28 a0 18 sll %g2, 0x18, %g2
4001e5cc: 84 10 80 01 or %g2, %g1, %g2
4001e5d0: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
4001e5d4: 84 10 80 01 or %g2, %g1, %g2
4001e5d8: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
4001e5dc: 83 28 60 08 sll %g1, 8, %g1
4001e5e0: 84 10 80 01 or %g2, %g1, %g2
4001e5e4: 03 0a 02 48 sethi %hi(0x28092000), %g1
4001e5e8: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_SIZE+0x27c92001>
4001e5ec: 80 a0 80 01 cmp %g2, %g1
4001e5f0: 22 80 00 0b be,a 4001e61c <rtems_rfs_fs_open+0x220> <== ALWAYS TAKEN
4001e5f4: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e5f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e5fc: 7f ff d5 83 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e600: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e604: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e608: 22 80 00 57 be,a 4001e764 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001e60c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
4001e610: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e614: 10 80 00 2f b 4001e6d0 <rtems_rfs_fs_open+0x2d4> <== NOT EXECUTED
4001e618: 90 12 21 98 or %o0, 0x198, %o0 ! 40036598 <CSWTCH.2+0x1158><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
4001e61c: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
4001e620: 83 28 60 10 sll %g1, 0x10, %g1
4001e624: 97 2a e0 18 sll %o3, 0x18, %o3
4001e628: 96 12 c0 01 or %o3, %g1, %o3
4001e62c: 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;
4001e630: 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);
4001e634: 96 12 c0 01 or %o3, %g1, %o3
4001e638: 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;
4001e63c: 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);
4001e640: 83 28 60 08 sll %g1, 8, %g1
4001e644: 96 12 c0 01 or %o3, %g1, %o3
4001e648: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001e64c: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
4001e650: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
4001e654: 83 28 60 10 sll %g1, 0x10, %g1
4001e658: b5 2e a0 18 sll %i2, 0x18, %i2
4001e65c: b4 16 80 01 or %i2, %g1, %i2
4001e660: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
4001e664: b4 16 80 01 or %i2, %g1, %i2
4001e668: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
4001e66c: 83 28 60 08 sll %g1, 8, %g1
4001e670: b4 16 80 01 or %i2, %g1, %i2
4001e674: 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;
4001e678: 40 00 42 8e call 4002f0b0 <__muldi3>
4001e67c: 92 10 00 1a mov %i2, %o1
4001e680: b2 10 00 08 mov %o0, %i1
4001e684: 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))
4001e688: 7f ff ff 53 call 4001e3d4 <rtems_rfs_fs_media_size>
4001e68c: 90 10 00 1b mov %i3, %o0
4001e690: 80 a6 40 08 cmp %i1, %o0
4001e694: 38 80 00 08 bgu,a 4001e6b4 <rtems_rfs_fs_open+0x2b8> <== NEVER TAKEN
4001e698: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e69c: 32 80 00 11 bne,a 4001e6e0 <rtems_rfs_fs_open+0x2e4> <== NEVER TAKEN
4001e6a0: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
4001e6a4: 80 a6 00 09 cmp %i0, %o1
4001e6a8: 28 80 00 0e bleu,a 4001e6e0 <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
4001e6ac: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e6b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e6b4: 7f ff d5 55 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e6b8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e6bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e6c0: 22 80 00 29 be,a 4001e764 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001e6c4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
4001e6c8: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e6cc: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400365d8 <CSWTCH.2+0x1198><== NOT EXECUTED
4001e6d0: 40 00 10 ac call 40022980 <puts> <== NOT EXECUTED
4001e6d4: 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);
4001e6d8: 10 80 00 23 b 4001e764 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001e6dc: 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)
4001e6e0: c2 0f 60 25 ldub [ %i5 + 0x25 ], %g1
4001e6e4: 85 28 a0 18 sll %g2, 0x18, %g2
4001e6e8: 83 28 60 10 sll %g1, 0x10, %g1
4001e6ec: 82 10 80 01 or %g2, %g1, %g1
4001e6f0: c4 0f 60 27 ldub [ %i5 + 0x27 ], %g2
4001e6f4: 82 10 40 02 or %g1, %g2, %g1
4001e6f8: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
4001e6fc: 85 28 a0 08 sll %g2, 8, %g2
4001e700: 82 10 40 02 or %g1, %g2, %g1
4001e704: 80 a0 60 38 cmp %g1, 0x38
4001e708: 22 80 00 1b be,a 4001e774 <rtems_rfs_fs_open+0x378> <== ALWAYS TAKEN
4001e70c: c4 0f 60 10 ldub [ %i5 + 0x10 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e710: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e714: 7f ff d5 3d call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e718: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e71c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e720: 22 80 00 11 be,a 4001e764 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
4001e724: 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);
4001e728: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
4001e72c: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
4001e730: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
4001e734: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
4001e738: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
4001e73c: 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",
4001e740: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001e744: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
4001e748: 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",
4001e74c: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001e750: 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",
4001e754: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001e758: 40 00 0f f2 call 40022720 <printf> <== NOT EXECUTED
4001e75c: 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);
4001e760: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001e764: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001e768: 7f ff ff 08 call 4001e388 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001e76c: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
4001e770: 30 80 00 b8 b,a 4001ea50 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
4001e774: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
4001e778: 85 28 a0 18 sll %g2, 0x18, %g2
4001e77c: 83 28 60 10 sll %g1, 0x10, %g1
4001e780: 82 10 80 01 or %g2, %g1, %g1
4001e784: 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);
4001e788: 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);
4001e78c: 82 10 40 02 or %g1, %g2, %g1
4001e790: 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;
4001e794: 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);
4001e798: 85 28 a0 08 sll %g2, 8, %g2
4001e79c: 82 10 40 02 or %g1, %g2, %g1
4001e7a0: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
4001e7a4: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
4001e7a8: c2 0f 60 15 ldub [ %i5 + 0x15 ], %g1
4001e7ac: 85 28 a0 18 sll %g2, 0x18, %g2
4001e7b0: 83 28 60 10 sll %g1, 0x10, %g1
4001e7b4: 82 10 80 01 or %g2, %g1, %g1
4001e7b8: c4 0f 60 17 ldub [ %i5 + 0x17 ], %g2
4001e7bc: 82 10 40 02 or %g1, %g2, %g1
4001e7c0: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
4001e7c4: 85 28 a0 08 sll %g2, 8, %g2
4001e7c8: 82 10 40 02 or %g1, %g2, %g1
4001e7cc: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
4001e7d0: c2 0f 60 19 ldub [ %i5 + 0x19 ], %g1
4001e7d4: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
4001e7d8: 83 28 60 10 sll %g1, 0x10, %g1
4001e7dc: b1 2e 20 18 sll %i0, 0x18, %i0
4001e7e0: b0 16 00 01 or %i0, %g1, %i0
4001e7e4: c2 0f 60 1b ldub [ %i5 + 0x1b ], %g1
4001e7e8: b0 16 00 01 or %i0, %g1, %i0
4001e7ec: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
4001e7f0: 83 28 60 08 sll %g1, 8, %g1
4001e7f4: b0 16 00 01 or %i0, %g1, %i0
4001e7f8: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
4001e7fc: c2 0f 60 1d ldub [ %i5 + 0x1d ], %g1
4001e800: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
4001e804: 83 28 60 10 sll %g1, 0x10, %g1
4001e808: b3 2e 60 18 sll %i1, 0x18, %i1
4001e80c: b2 16 40 01 or %i1, %g1, %i1
4001e810: c2 0f 60 1f ldub [ %i5 + 0x1f ], %g1
4001e814: b2 16 40 01 or %i1, %g1, %i1
4001e818: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
4001e81c: 83 28 60 08 sll %g1, 8, %g1
4001e820: b2 16 40 01 or %i1, %g1, %i1
4001e824: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001e828: c2 0f 60 21 ldub [ %i5 + 0x21 ], %g1
4001e82c: c4 0f 60 20 ldub [ %i5 + 0x20 ], %g2
4001e830: 83 28 60 10 sll %g1, 0x10, %g1
4001e834: 85 28 a0 18 sll %g2, 0x18, %g2
4001e838: 84 10 80 01 or %g2, %g1, %g2
4001e83c: c2 0f 60 23 ldub [ %i5 + 0x23 ], %g1
4001e840: 84 10 80 01 or %g2, %g1, %g2
4001e844: c2 0f 60 22 ldub [ %i5 + 0x22 ], %g1
fs->blocks_per_block =
4001e848: 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);
4001e84c: 83 28 60 08 sll %g1, 8, %g1
4001e850: 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;
4001e854: 85 2a 20 02 sll %o0, 2, %g2
4001e858: 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);
4001e85c: 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;
4001e860: 7f ff 8f 4d call 40002594 <.umul>
4001e864: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
4001e868: 83 2a 20 02 sll %o0, 2, %g1
4001e86c: 90 00 40 08 add %g1, %o0, %o0
fs->inodes = fs->group_count * fs->group_inodes;
4001e870: 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 =
4001e874: 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;
4001e878: 7f ff 8f 47 call 40002594 <.umul>
4001e87c: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001e880: 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;
4001e884: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001e888: 7f ff 8f 7d call 4000267c <.udiv>
4001e88c: 90 10 00 1a mov %i2, %o0
4001e890: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
4001e894: b5 2e a0 03 sll %i2, 3, %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001e898: 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 >
4001e89c: 80 a6 40 1a cmp %i1, %i2
4001e8a0: 08 80 00 0c bleu 4001e8d0 <rtems_rfs_fs_open+0x4d4> <== ALWAYS TAKEN
4001e8a4: 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);
4001e8a8: 7f ff fe b8 call 4001e388 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001e8ac: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e8b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e8b4: 7f ff d4 d5 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e8b8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e8bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e8c0: 02 80 00 64 be 4001ea50 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
4001e8c4: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
4001e8c8: 10 80 00 2e b 4001e980 <rtems_rfs_fs_open+0x584> <== NOT EXECUTED
4001e8cc: 90 12 22 60 or %o0, 0x260, %o0 ! 40036660 <CSWTCH.2+0x1220><== NOT EXECUTED
return EIO;
}
rtems_rfs_buffer_handle_close (fs, &handle);
4001e8d0: 7f ff fe ae call 4001e388 <rtems_rfs_buffer_handle_close>
4001e8d4: 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));
4001e8d8: d2 06 e0 08 ld [ %i3 + 8 ], %o1
4001e8dc: 7f ff f5 e9 call 4001c080 <rtems_rfs_buffer_setblksize>
4001e8e0: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001e8e4: ba 92 20 00 orcc %o0, 0, %i5
4001e8e8: 04 80 00 13 ble 4001e934 <rtems_rfs_fs_open+0x538> <== ALWAYS TAKEN
4001e8ec: 92 07 bf cc add %fp, -52, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001e8f0: 7f ff fe a6 call 4001e388 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001e8f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e8f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e8fc: 7f ff d4 c3 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e900: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e904: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e908: 22 80 00 50 be,a 4001ea48 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001e90c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
4001e910: 40 00 13 f0 call 400238d0 <strerror> <== NOT EXECUTED
4001e914: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e918: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e91c: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001e920: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 400366a8 <CSWTCH.2+0x1268><== NOT EXECUTED
4001e924: 40 00 0f 7f call 40022720 <printf> <== NOT EXECUTED
4001e928: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
4001e92c: 10 80 00 47 b 4001ea48 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001e930: 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));
4001e934: d0 06 e0 24 ld [ %i3 + 0x24 ], %o0
4001e938: 7f ff a7 35 call 4000860c <calloc>
4001e93c: 92 10 20 50 mov 0x50, %o1
4001e940: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if (!fs->groups)
4001e944: b2 10 20 00 clr %i1
4001e948: 80 a2 20 00 cmp %o0, 0
4001e94c: 12 80 00 39 bne 4001ea30 <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
4001e950: b4 10 20 00 clr %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
4001e954: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001e958: 7f ff fe 8c call 4001e388 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001e95c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e960: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e964: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001e968: 7f ff d4 a8 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001e96c: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
4001e970: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e974: 02 80 00 37 be 4001ea50 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
4001e978: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
4001e97c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 400366f0 <CSWTCH.2+0x12b0><== NOT EXECUTED
4001e980: 40 00 10 00 call 40022980 <puts> <== NOT EXECUTED
4001e984: 01 00 00 00 nop <== NOT EXECUTED
4001e988: 30 80 00 32 b,a 4001ea50 <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),
4001e98c: 90 10 00 1a mov %i2, %o0
4001e990: 7f ff 8f 01 call 40002594 <.umul>
4001e994: 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,
4001e998: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
4001e99c: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
4001e9a0: 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,
4001e9a4: 94 10 00 1d mov %i5, %o2
4001e9a8: 98 03 00 19 add %o4, %i1, %o4
4001e9ac: 90 10 00 1b mov %i3, %o0
4001e9b0: 7f ff cc 16 call 40011a08 <rtems_rfs_group_open>
4001e9b4: 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)
4001e9b8: 80 a2 20 00 cmp %o0, 0
4001e9bc: 04 80 00 1c ble 4001ea2c <rtems_rfs_fs_open+0x630> <== ALWAYS TAKEN
4001e9c0: ba 10 00 08 mov %o0, %i5
4001e9c4: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001e9c8: 10 80 00 07 b 4001e9e4 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
4001e9cc: b2 10 20 00 clr %i1 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
4001e9d0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001e9d4: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
4001e9d8: 7f ff cc 8a call 40011c00 <rtems_rfs_group_close> <== NOT EXECUTED
4001e9dc: b2 06 60 01 inc %i1 <== NOT EXECUTED
4001e9e0: 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++)
4001e9e4: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
4001e9e8: 26 bf ff fa bl,a 4001e9d0 <rtems_rfs_fs_open+0x5d4> <== NOT EXECUTED
4001e9ec: 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);
4001e9f0: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001e9f4: 7f ff fe 65 call 4001e388 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
4001e9f8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001e9fc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ea00: 7f ff d4 82 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001ea04: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001ea08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ea0c: 22 80 00 0f be,a 4001ea48 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
4001ea10: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
4001ea14: 40 00 13 af call 400238d0 <strerror> <== NOT EXECUTED
4001ea18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ea1c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ea20: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001ea24: 10 bf ff c0 b 4001e924 <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
4001ea28: 90 12 23 28 or %o0, 0x328, %o0 ! 40036728 <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++)
4001ea2c: b4 06 a0 01 inc %i2
4001ea30: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
4001ea34: 80 a6 80 01 cmp %i2, %g1
4001ea38: 26 bf ff d5 bl,a 4001e98c <rtems_rfs_fs_open+0x590>
4001ea3c: 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);
4001ea40: 10 80 00 14 b 4001ea90 <rtems_rfs_fs_open+0x694>
4001ea44: d0 07 00 00 ld [ %i4 ], %o0
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
4001ea48: 22 80 00 12 be,a 4001ea90 <rtems_rfs_fs_open+0x694> <== NOT EXECUTED
4001ea4c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
4001ea50: 7f ff f5 c7 call 4001c16c <rtems_rfs_buffer_close> <== NOT EXECUTED
4001ea54: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001ea58: 7f ff a7 51 call 4000879c <free> <== NOT EXECUTED
4001ea5c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ea60: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ea64: 7f ff d4 69 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001ea68: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001ea6c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ea70: 02 bf fe b6 be 4001e548 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001ea74: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
4001ea78: 40 00 13 96 call 400238d0 <strerror> <== NOT EXECUTED
4001ea7c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ea80: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ea84: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001ea88: 10 bf fe ae b 4001e540 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
4001ea8c: 90 12 23 68 or %o0, 0x368, %o0 ! 40036768 <CSWTCH.2+0x1328><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001ea90: 92 10 20 01 mov 1, %o1
4001ea94: 94 07 bf d8 add %fp, -40, %o2
4001ea98: 7f ff cd d3 call 400121e4 <rtems_rfs_inode_open>
4001ea9c: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001eaa0: ba 92 20 00 orcc %o0, 0, %i5
4001eaa4: 04 80 00 12 ble 4001eaec <rtems_rfs_fs_open+0x6f0> <== ALWAYS TAKEN
4001eaa8: d0 07 00 00 ld [ %i4 ], %o0
{
rtems_rfs_buffer_close (*fs);
4001eaac: 7f ff f5 b0 call 4001c16c <rtems_rfs_buffer_close> <== NOT EXECUTED
4001eab0: 01 00 00 00 nop <== NOT EXECUTED
free (*fs);
4001eab4: 7f ff a7 3a call 4000879c <free> <== NOT EXECUTED
4001eab8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001eabc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001eac0: 7f ff d4 52 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001eac4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001eac8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001eacc: 02 bf fe 9f be 4001e548 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001ead0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
4001ead4: 40 00 13 7f call 400238d0 <strerror> <== NOT EXECUTED
4001ead8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001eadc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001eae0: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001eae4: 10 bf fe 97 b 4001e540 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
4001eae8: 90 12 23 98 or %o0, 0x398, %o0 ! 40036798 <CSWTCH.2+0x1358><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
4001eaec: c2 02 00 00 ld [ %o0 ], %g1
4001eaf0: 80 88 60 04 btst 4, %g1
4001eaf4: 12 80 00 23 bne 4001eb80 <rtems_rfs_fs_open+0x784>
4001eaf8: 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);
4001eafc: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
4001eb00: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
4001eb04: 83 28 60 08 sll %g1, 8, %g1
4001eb08: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
4001eb0c: 05 3f ff c0 sethi %hi(0xffff0000), %g2
4001eb10: 87 28 60 10 sll %g1, 0x10, %g3
4001eb14: 80 a0 c0 02 cmp %g3, %g2
4001eb18: 02 80 00 07 be 4001eb34 <rtems_rfs_fs_open+0x738> <== NEVER TAKEN
4001eb1c: 05 00 00 3c sethi %hi(0xf000), %g2
4001eb20: 82 08 40 02 and %g1, %g2, %g1
4001eb24: 05 00 00 10 sethi %hi(0x4000), %g2
4001eb28: 80 a0 40 02 cmp %g1, %g2
4001eb2c: 02 80 00 15 be 4001eb80 <rtems_rfs_fs_open+0x784> <== ALWAYS TAKEN
4001eb30: 01 00 00 00 nop
{
rtems_rfs_inode_close (*fs, &inode);
4001eb34: 7f ff ce 1e call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001eb38: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001eb3c: 7f ff f5 8c call 4001c16c <rtems_rfs_buffer_close> <== NOT EXECUTED
4001eb40: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001eb44: 7f ff a7 16 call 4000879c <free> <== NOT EXECUTED
4001eb48: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001eb4c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001eb50: 7f ff d4 2e call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001eb54: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001eb58: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001eb5c: 02 80 00 04 be 4001eb6c <rtems_rfs_fs_open+0x770> <== NOT EXECUTED
4001eb60: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
4001eb64: 40 00 0f 87 call 40022980 <puts> <== NOT EXECUTED
4001eb68: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 400367c8 <CSWTCH.2+0x1388><== NOT EXECUTED
errno = EIO;
4001eb6c: 40 00 09 94 call 400211bc <__errno> <== NOT EXECUTED
4001eb70: 01 00 00 00 nop <== NOT EXECUTED
4001eb74: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
4001eb78: 10 bf fe 77 b 4001e554 <rtems_rfs_fs_open+0x158> <== NOT EXECUTED
4001eb7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
4001eb80: 7f ff ce 0b call 400123ac <rtems_rfs_inode_close>
4001eb84: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001eb88: ba 92 20 00 orcc %o0, 0, %i5
4001eb8c: 04 80 00 12 ble 4001ebd4 <rtems_rfs_fs_open+0x7d8> <== ALWAYS TAKEN
4001eb90: 01 00 00 00 nop
{
rtems_rfs_buffer_close (*fs);
4001eb94: 7f ff f5 76 call 4001c16c <rtems_rfs_buffer_close> <== NOT EXECUTED
4001eb98: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001eb9c: 7f ff a7 00 call 4000879c <free> <== NOT EXECUTED
4001eba0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001eba4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001eba8: 7f ff d4 18 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001ebac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001ebb0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ebb4: 02 bf fe 65 be 4001e548 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
4001ebb8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
4001ebbc: 40 00 13 45 call 400238d0 <strerror> <== NOT EXECUTED
4001ebc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ebc4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ebc8: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
4001ebcc: 10 bf fe 5d b 4001e540 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
4001ebd0: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 400367f8 <CSWTCH.2+0x13b8><== NOT EXECUTED
errno = rc;
return -1;
}
errno = 0;
4001ebd4: 40 00 09 7a call 400211bc <__errno>
4001ebd8: b0 10 20 00 clr %i0
4001ebdc: c0 22 00 00 clr [ %o0 ]
return 0;
}
4001ebe0: 81 c7 e0 08 ret
4001ebe4: 81 e8 00 00 restore
4001e3b0 <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)
{
4001e3b0: 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;
4001e3b4: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
4001e3b8: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
4001e3bc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001e3c0: 40 00 43 3c call 4002f0b0 <__muldi3> <== NOT EXECUTED
4001e3c4: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
4001e3c8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4001e3cc: 81 c7 e0 08 ret <== NOT EXECUTED
4001e3d0: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
40011c90 <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)
{
40011c90: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40011c94: 80 a6 a0 00 cmp %i2, 0
40011c98: 02 80 00 05 be 40011cac <rtems_rfs_group_bitmap_alloc+0x1c>
40011c9c: ba 10 00 18 mov %i0, %i5
{
size = fs->group_inodes;
40011ca0: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
40011ca4: 10 80 00 03 b 40011cb0 <rtems_rfs_group_bitmap_alloc+0x20>
40011ca8: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
40011cac: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
group_start = goal / size;
40011cb0: 92 10 00 11 mov %l1, %o1
40011cb4: 7f ff c2 72 call 4000267c <.udiv>
40011cb8: 90 10 00 19 mov %i1, %o0
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011cbc: 92 10 00 11 mov %l1, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
40011cc0: a8 10 00 08 mov %o0, %l4
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
40011cc4: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011cc8: 90 10 00 19 mov %i1, %o0
40011ccc: 40 00 74 4d call 4002ee00 <.urem>
40011cd0: a4 10 20 01 mov 1, %l2
offset = 0;
40011cd4: a0 10 20 00 clr %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011cd8: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40011cdc: 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);
40011ce0: 90 10 00 1c mov %i4, %o0
40011ce4: 7f ff c2 2c call 40002594 <.umul>
40011ce8: 92 10 00 10 mov %l0, %o1
if (offset)
40011cec: 80 a4 20 00 cmp %l0, 0
40011cf0: 02 80 00 07 be 40011d0c <rtems_rfs_group_bitmap_alloc+0x7c>
40011cf4: b2 05 00 08 add %l4, %o0, %i1
bit = direction > 0 ? 0 : size - 1;
40011cf8: 80 a7 20 00 cmp %i4, 0
40011cfc: 14 80 00 03 bg 40011d08 <rtems_rfs_group_bitmap_alloc+0x78>
40011d00: 82 10 20 00 clr %g1
40011d04: 82 04 7f ff add %l1, -1, %g1
40011d08: 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))
40011d0c: 80 a6 60 00 cmp %i1, 0
40011d10: 06 80 00 07 bl 40011d2c <rtems_rfs_group_bitmap_alloc+0x9c>
40011d14: 80 8c a0 ff btst 0xff, %l2
40011d18: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40011d1c: 80 a6 40 01 cmp %i1, %g1
40011d20: 26 80 00 0a bl,a 40011d48 <rtems_rfs_group_bitmap_alloc+0xb8>
40011d24: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
{
if (!updown)
40011d28: 80 8c a0 ff btst 0xff, %l2
40011d2c: 02 80 00 50 be 40011e6c <rtems_rfs_group_bitmap_alloc+0x1dc>
40011d30: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
40011d34: 24 80 00 03 ble,a 40011d40 <rtems_rfs_group_bitmap_alloc+0xb0><== ALWAYS TAKEN
40011d38: b8 10 20 01 mov 1, %i4
40011d3c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
updown = false;
40011d40: 10 bf ff e7 b 40011cdc <rtems_rfs_group_bitmap_alloc+0x4c>
40011d44: a4 10 20 00 clr %l2
40011d48: a7 2e 60 04 sll %i1, 4, %l3
40011d4c: 85 2e 60 06 sll %i1, 6, %g2
continue;
}
if (inode)
40011d50: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
40011d54: a6 04 c0 02 add %l3, %g2, %l3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
40011d58: 02 80 00 04 be 40011d68 <rtems_rfs_group_bitmap_alloc+0xd8>
40011d5c: a6 00 40 13 add %g1, %l3, %l3
bitmap = &fs->groups[group].inode_bitmap;
40011d60: 10 80 00 03 b 40011d6c <rtems_rfs_group_bitmap_alloc+0xdc>
40011d64: a6 04 e0 2c add %l3, 0x2c, %l3
else
bitmap = &fs->groups[group].block_bitmap;
40011d68: a6 04 e0 08 add %l3, 8, %l3
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
40011d6c: d2 07 bf fc ld [ %fp + -4 ], %o1
40011d70: 90 10 00 13 mov %l3, %o0
40011d74: 94 07 bf fb add %fp, -5, %o2
40011d78: 40 00 21 fe call 4001a570 <rtems_rfs_bitmap_map_alloc>
40011d7c: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
40011d80: b0 92 20 00 orcc %o0, 0, %i0
40011d84: 14 80 00 45 bg 40011e98 <rtems_rfs_group_bitmap_alloc+0x208><== NEVER TAKEN
40011d88: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
40011d8c: c2 07 40 00 ld [ %i5 ], %g1
40011d90: 80 88 60 01 btst 1, %g1
40011d94: 12 80 00 06 bne 40011dac <rtems_rfs_group_bitmap_alloc+0x11c><== NEVER TAKEN
40011d98: c2 0f bf fb ldub [ %fp + -5 ], %g1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40011d9c: d2 04 c0 00 ld [ %l3 ], %o1
40011da0: 40 00 26 fe call 4001b998 <rtems_rfs_buffer_handle_release>
40011da4: 90 10 00 1d mov %i5, %o0
if (allocated)
40011da8: c2 0f bf fb ldub [ %fp + -5 ], %g1
40011dac: 80 a0 60 00 cmp %g1, 0
40011db0: 02 80 00 27 be 40011e4c <rtems_rfs_group_bitmap_alloc+0x1bc>
40011db4: 80 8c a0 ff btst 0xff, %l2
{
if (inode)
40011db8: 80 a6 a0 00 cmp %i2, 0
40011dbc: 02 80 00 09 be 40011de0 <rtems_rfs_group_bitmap_alloc+0x150>
40011dc0: c2 07 bf fc ld [ %fp + -4 ], %g1
*result = rtems_rfs_group_inode (fs, group, bit);
40011dc4: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
40011dc8: b8 00 60 01 add %g1, 1, %i4
40011dcc: 7f ff c1 f2 call 40002594 <.umul>
40011dd0: 90 10 00 19 mov %i1, %o0
40011dd4: 90 07 00 08 add %i4, %o0, %o0
40011dd8: 10 80 00 09 b 40011dfc <rtems_rfs_group_bitmap_alloc+0x16c>
40011ddc: d0 26 c0 00 st %o0, [ %i3 ]
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
40011de0: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40011de4: 87 2e 60 04 sll %i1, 4, %g3
40011de8: b3 2e 60 06 sll %i1, 6, %i1
40011dec: b2 00 c0 19 add %g3, %i1, %i1
40011df0: c4 00 80 19 ld [ %g2 + %i1 ], %g2
40011df4: 82 00 40 02 add %g1, %g2, %g1
40011df8: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011dfc: 90 10 20 00 clr %o0
40011e00: 13 00 00 80 sethi %hi(0x20000), %o1
40011e04: 40 00 07 81 call 40013c08 <rtems_rfs_trace>
40011e08: b0 10 20 00 clr %i0
40011e0c: 80 8a 20 ff btst 0xff, %o0
40011e10: 02 80 00 0d be 40011e44 <rtems_rfs_group_bitmap_alloc+0x1b4><== ALWAYS TAKEN
40011e14: 80 a6 a0 00 cmp %i2, 0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40011e18: 22 80 00 05 be,a 40011e2c <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
40011e1c: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40011e20: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40011e24: 10 80 00 03 b 40011e30 <rtems_rfs_group_bitmap_alloc+0x1a0><== NOT EXECUTED
40011e28: 92 12 60 c0 or %o1, 0xc0, %o1 ! 400344c0 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
40011e2c: 92 12 60 c8 or %o1, 0xc8, %o1 <== NOT EXECUTED
40011e30: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
40011e34: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
40011e38: 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",
40011e3c: 40 00 42 39 call 40022720 <printf> <== NOT EXECUTED
40011e40: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED
40011e44: 81 c7 e0 08 ret
40011e48: 81 e8 00 00 restore
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
40011e4c: 22 bf ff a4 be,a 40011cdc <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
40011e50: a0 04 20 01 inc %l0 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40011e54: 80 a7 20 00 cmp %i4, 0
40011e58: 24 80 00 03 ble,a 40011e64 <rtems_rfs_group_bitmap_alloc+0x1d4><== NEVER TAKEN
40011e5c: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
40011e60: b8 10 3f ff mov -1, %i4
offset++;
40011e64: 10 bf ff 9e b 40011cdc <rtems_rfs_group_bitmap_alloc+0x4c>
40011e68: a0 04 20 01 inc %l0
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011e6c: 90 10 20 00 clr %o0
40011e70: 40 00 07 66 call 40013c08 <rtems_rfs_trace>
40011e74: 13 00 00 80 sethi %hi(0x20000), %o1
40011e78: 80 8a 20 ff btst 0xff, %o0
40011e7c: 12 80 00 04 bne 40011e8c <rtems_rfs_group_bitmap_alloc+0x1fc><== NEVER TAKEN
40011e80: 11 10 00 d1 sethi %hi(0x40034400), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
40011e84: 81 c7 e0 08 ret
40011e88: 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");
40011e8c: 40 00 42 bd call 40022980 <puts> <== NOT EXECUTED
40011e90: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
return ENOSPC;
40011e94: b0 10 20 1c mov 0x1c, %i0 <== NOT EXECUTED
}
40011e98: 81 c7 e0 08 ret <== NOT EXECUTED
40011e9c: 81 e8 00 00 restore <== NOT EXECUTED
40011ea0 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
40011ea0: 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))
40011ea4: 90 10 20 00 clr %o0
40011ea8: 13 00 00 80 sethi %hi(0x20000), %o1
40011eac: 40 00 07 57 call 40013c08 <rtems_rfs_trace>
40011eb0: ba 10 00 18 mov %i0, %i5
40011eb4: 80 8a 20 ff btst 0xff, %o0
40011eb8: 02 80 00 0d be 40011eec <rtems_rfs_group_bitmap_free+0x4c><== ALWAYS TAKEN
40011ebc: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40011ec0: 22 80 00 05 be,a 40011ed4 <rtems_rfs_group_bitmap_free+0x34><== NOT EXECUTED
40011ec4: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40011ec8: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40011ecc: 10 80 00 03 b 40011ed8 <rtems_rfs_group_bitmap_free+0x38> <== NOT EXECUTED
40011ed0: 92 12 60 c0 or %o1, 0xc0, %o1 ! 400344c0 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
40011ed4: 92 12 60 c8 or %o1, 0xc8, %o1 <== NOT EXECUTED
40011ed8: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40011edc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40011ee0: 40 00 42 10 call 40022720 <printf> <== NOT EXECUTED
40011ee4: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40011ee8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40011eec: 02 80 00 04 be 40011efc <rtems_rfs_group_bitmap_free+0x5c>
40011ef0: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
40011ef4: 10 80 00 03 b 40011f00 <rtems_rfs_group_bitmap_free+0x60>
40011ef8: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
40011efc: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
}
group = no / size;
40011f00: 92 10 00 1b mov %i3, %o1
40011f04: 7f ff c1 de call 4000267c <.udiv>
40011f08: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
40011f0c: 92 10 00 1b mov %i3, %o1
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
40011f10: b0 10 00 08 mov %o0, %i0
bit = (rtems_rfs_bitmap_bit) (no % size);
40011f14: 40 00 73 bb call 4002ee00 <.urem>
40011f18: 90 10 00 1a mov %i2, %o0
40011f1c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40011f20: b9 2e 20 04 sll %i0, 4, %i4
40011f24: 92 10 00 08 mov %o0, %o1
40011f28: b1 2e 20 06 sll %i0, 6, %i0
if (inode)
40011f2c: 80 a6 60 00 cmp %i1, 0
bitmap = &fs->groups[group].inode_bitmap;
40011f30: b8 07 00 18 add %i4, %i0, %i4
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
40011f34: 02 80 00 04 be 40011f44 <rtems_rfs_group_bitmap_free+0xa4>
40011f38: b8 00 40 1c add %g1, %i4, %i4
bitmap = &fs->groups[group].inode_bitmap;
40011f3c: 10 80 00 03 b 40011f48 <rtems_rfs_group_bitmap_free+0xa8>
40011f40: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
40011f44: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40011f48: 40 00 20 fe call 4001a340 <rtems_rfs_bitmap_map_clear>
40011f4c: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40011f50: 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);
40011f54: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40011f58: 40 00 26 90 call 4001b998 <rtems_rfs_buffer_handle_release>
40011f5c: 90 10 00 1d mov %i5, %o0
return rc;
}
40011f60: 81 c7 e0 08 ret
40011f64: 81 e8 00 00 restore
40011f68 <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)
{
40011f68: 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))
40011f6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011f70: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
40011f74: 40 00 07 25 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
40011f78: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
40011f7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011f80: 02 80 00 0d be 40011fb4 <rtems_rfs_group_bitmap_test+0x4c><== NOT EXECUTED
40011f84: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
40011f88: 22 80 00 05 be,a 40011f9c <rtems_rfs_group_bitmap_test+0x34><== NOT EXECUTED
40011f8c: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40011f90: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40011f94: 10 80 00 03 b 40011fa0 <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
40011f98: 92 12 60 c0 or %o1, 0xc0, %o1 ! 400344c0 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
40011f9c: 92 12 60 c8 or %o1, 0xc8, %o1 <== NOT EXECUTED
40011fa0: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40011fa4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40011fa8: 40 00 41 de call 40022720 <printf> <== NOT EXECUTED
40011fac: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40011fb0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40011fb4: 22 80 00 0b be,a 40011fe0 <rtems_rfs_group_bitmap_test+0x78><== NOT EXECUTED
40011fb8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
40011fbc: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40011fc0: 04 80 00 25 ble 40012054 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
40011fc4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
40011fc8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
40011fcc: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
40011fd0: 18 80 00 21 bgu 40012054 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
40011fd4: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
40011fd8: 10 80 00 06 b 40011ff0 <rtems_rfs_group_bitmap_test+0x88> <== NOT EXECUTED
40011fdc: f0 07 60 2c ld [ %i5 + 0x2c ], %i0 <== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
40011fe0: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
40011fe4: 1a 80 00 1c bcc 40012054 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
40011fe8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
40011fec: f0 07 60 28 ld [ %i5 + 0x28 ], %i0 <== NOT EXECUTED
}
group = no / size;
40011ff0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40011ff4: 7f ff c1 a2 call 4000267c <.udiv> <== NOT EXECUTED
40011ff8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
40011ffc: 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;
40012000: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
40012004: 40 00 73 7f call 4002ee00 <.urem> <== NOT EXECUTED
40012008: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001200c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
40012010: b9 2c 20 04 sll %l0, 4, %i4 <== NOT EXECUTED
40012014: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40012018: a1 2c 20 06 sll %l0, 6, %l0 <== NOT EXECUTED
if (inode)
4001201c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
40012020: b8 07 00 10 add %i4, %l0, %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
40012024: 02 80 00 04 be 40012034 <rtems_rfs_group_bitmap_test+0xcc><== NOT EXECUTED
40012028: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
4001202c: 10 80 00 03 b 40012038 <rtems_rfs_group_bitmap_test+0xd0> <== NOT EXECUTED
40012030: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
40012034: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
40012038: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001203c: 40 00 20 e4 call 4001a3cc <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
40012040: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40012044: 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);
40012048: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4001204c: 40 00 26 53 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012050: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
40012054: 81 c7 e0 08 ret <== NOT EXECUTED
40012058: 81 e8 00 00 restore <== NOT EXECUTED
40011c00 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40011c00: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
40011c04: 90 10 20 00 clr %o0
40011c08: 13 00 00 40 sethi %hi(0x10000), %o1
40011c0c: 40 00 07 ff call 40013c08 <rtems_rfs_trace>
40011c10: ba 10 00 18 mov %i0, %i5
40011c14: 80 8a 20 ff btst 0xff, %o0
40011c18: 02 80 00 06 be 40011c30 <rtems_rfs_group_close+0x30> <== ALWAYS TAKEN
40011c1c: 01 00 00 00 nop
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
40011c20: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40011c24: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40011c28: 40 00 42 be call 40022720 <printf> <== NOT EXECUTED
40011c2c: 90 12 20 98 or %o0, 0x98, %o0 ! 40034498 <_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);
40011c30: 40 00 22 db call 4001a79c <rtems_rfs_bitmap_close>
40011c34: 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);
40011c38: 92 06 60 44 add %i1, 0x44, %o1
40011c3c: b8 10 00 08 mov %o0, %i4
40011c40: 40 00 27 56 call 4001b998 <rtems_rfs_buffer_handle_release>
40011c44: 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);
40011c48: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
40011c4c: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
40011c50: c0 26 60 48 clr [ %i1 + 0x48 ]
40011c54: 40 00 22 d2 call 4001a79c <rtems_rfs_bitmap_close>
40011c58: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
40011c5c: b0 92 20 00 orcc %o0, 0, %i0
40011c60: 14 80 00 05 bg 40011c74 <rtems_rfs_group_close+0x74> <== NEVER TAKEN
40011c64: 90 10 00 1d mov %i5, %o0
40011c68: b0 38 00 1c xnor %g0, %i4, %i0
40011c6c: b1 3e 20 1f sra %i0, 0x1f, %i0
40011c70: 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);
40011c74: 40 00 27 49 call 4001b998 <rtems_rfs_buffer_handle_release>
40011c78: 92 06 60 20 add %i1, 0x20, %o1
handle->dirty = false;
40011c7c: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40011c80: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
40011c84: 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;
}
40011c88: 81 c7 e0 08 ret
40011c8c: 81 e8 00 00 restore
40011a08 <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)
{
40011a08: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40011a0c: c2 06 20 04 ld [ %i0 + 4 ], %g1
40011a10: 80 a6 40 01 cmp %i1, %g1
40011a14: 0a 80 00 10 bcs 40011a54 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
40011a18: 84 06 80 19 add %i2, %i1, %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40011a1c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011a20: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40011a24: 40 00 08 79 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
40011a28: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
40011a2c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011a30: 22 80 00 72 be,a 40011bf8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
40011a34: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
40011a38: 40 00 47 a6 call 400238d0 <strerror> <== NOT EXECUTED
40011a3c: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
40011a40: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
40011a44: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011a48: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40011a4c: 10 80 00 36 b 40011b24 <rtems_rfs_group_open+0x11c> <== NOT EXECUTED
40011a50: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 400343a0 <_CPU_Trap_slot_template+0x8f0><== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
40011a54: 80 a0 80 01 cmp %g2, %g1
40011a58: 3a 80 00 02 bcc,a 40011a60 <rtems_rfs_group_open+0x58> <== ALWAYS TAKEN
40011a5c: b4 20 40 19 sub %g1, %i1, %i2
40011a60: 80 a6 80 1b cmp %i2, %i3
40011a64: 08 80 00 03 bleu 40011a70 <rtems_rfs_group_open+0x68> <== NEVER TAKEN
40011a68: a0 10 00 1a mov %i2, %l0
40011a6c: 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))
40011a70: 90 10 20 00 clr %o0
40011a74: 40 00 08 65 call 40013c08 <rtems_rfs_trace>
40011a78: 13 00 00 20 sethi %hi(0x8000), %o1
40011a7c: 80 8a 20 ff btst 0xff, %o0
40011a80: 22 80 00 09 be,a 40011aa4 <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
40011a84: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40011a88: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40011a8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40011a90: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED
40011a94: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40011a98: 40 00 43 22 call 40022720 <printf> <== NOT EXECUTED
40011a9c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
base, size, inodes);
group->base = base;
40011aa0: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
40011aa4: 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;
40011aa8: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
40011aac: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
40011ab0: 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,
40011ab4: a2 07 20 08 add %i4, 8, %l1
40011ab8: b6 07 20 20 add %i4, 0x20, %i3
40011abc: 90 10 00 11 mov %l1, %o0
40011ac0: 92 10 00 18 mov %i0, %o1
40011ac4: 94 10 00 1b mov %i3, %o2
40011ac8: 96 10 00 1a mov %i2, %o3
40011acc: 40 00 23 23 call 4001a758 <rtems_rfs_bitmap_open>
40011ad0: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40011ad4: ba 92 20 00 orcc %o0, 0, %i5
40011ad8: 04 80 00 16 ble 40011b30 <rtems_rfs_group_open+0x128> <== ALWAYS TAKEN
40011adc: 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);
40011ae0: 40 00 27 ae call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011ae4: 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))
40011ae8: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40011aec: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40011af0: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
40011af4: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40011af8: 40 00 08 44 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
40011afc: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40011b00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011b04: 22 80 00 3d be,a 40011bf8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
40011b08: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40011b0c: 40 00 47 71 call 400238d0 <strerror> <== NOT EXECUTED
40011b10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011b14: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011b18: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40011b1c: 90 12 20 18 or %o0, 0x18, %o0 ! 40034418 <_CPU_Trap_slot_template+0x968><== NOT EXECUTED
40011b20: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011b24: 40 00 42 ff call 40022720 <printf> <== NOT EXECUTED
40011b28: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40011b2c: 30 80 00 33 b,a 40011bf8 <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,
40011b30: 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;
40011b34: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
40011b38: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
40011b3c: c0 27 20 4c clr [ %i4 + 0x4c ]
40011b40: b4 07 20 44 add %i4, 0x44, %i2
40011b44: 90 07 20 2c add %i4, 0x2c, %o0
40011b48: 92 10 00 18 mov %i0, %o1
40011b4c: 94 10 00 1a mov %i2, %o2
40011b50: 96 10 00 10 mov %l0, %o3
40011b54: 40 00 23 01 call 4001a758 <rtems_rfs_bitmap_open>
40011b58: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40011b5c: ba 92 20 00 orcc %o0, 0, %i5
40011b60: 04 80 00 1b ble 40011bcc <rtems_rfs_group_open+0x1c4> <== ALWAYS TAKEN
40011b64: 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);
40011b68: 40 00 27 8c call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011b6c: 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);
40011b70: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
40011b74: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
40011b78: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
40011b7c: 40 00 23 08 call 4001a79c <rtems_rfs_bitmap_close> <== NOT EXECUTED
40011b80: 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);
40011b84: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40011b88: 40 00 27 84 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011b8c: 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))
40011b90: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40011b94: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40011b98: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
40011b9c: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40011ba0: 40 00 08 1a call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
40011ba4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40011ba8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011bac: 22 80 00 13 be,a 40011bf8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
40011bb0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40011bb4: 40 00 47 47 call 400238d0 <strerror> <== NOT EXECUTED
40011bb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011bbc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011bc0: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40011bc4: 10 bf ff d7 b 40011b20 <rtems_rfs_group_open+0x118> <== NOT EXECUTED
40011bc8: 90 12 20 58 or %o0, 0x58, %o0 ! 40034458 <_CPU_Trap_slot_template+0x9a8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
40011bcc: c2 06 00 00 ld [ %i0 ], %g1
40011bd0: 80 88 60 01 btst 1, %g1
40011bd4: 12 80 00 08 bne 40011bf4 <rtems_rfs_group_open+0x1ec> <== NEVER TAKEN
40011bd8: ba 10 20 00 clr %i5
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40011bdc: d2 07 20 08 ld [ %i4 + 8 ], %o1
40011be0: 40 00 27 6e call 4001b998 <rtems_rfs_buffer_handle_release>
40011be4: 90 10 00 18 mov %i0, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40011be8: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40011bec: 40 00 27 6b call 4001b998 <rtems_rfs_buffer_handle_release>
40011bf0: 90 10 00 18 mov %i0, %o0
}
return 0;
}
40011bf4: b0 10 00 1d mov %i5, %i0
40011bf8: 81 c7 e0 08 ret
40011bfc: 81 e8 00 00 restore
4001205c <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
4001205c: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
40012060: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40012064: 86 10 20 00 clr %g3 <== NOT EXECUTED
40012068: 10 80 00 11 b 400120ac <rtems_rfs_group_usage+0x50> <== NOT EXECUTED
4001206c: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
40012070: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
40012074: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
40012078: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
4001207c: d8 00 60 14 ld [ %g1 + 0x14 ], %o4 <== NOT EXECUTED
40012080: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
40012084: 86 00 e0 50 add %g3, 0x50, %g3 <== NOT EXECUTED
40012088: 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 +=
4001208c: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
40012090: 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) -
40012094: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 <== NOT EXECUTED
40012098: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED
4001209c: 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 +=
400120a0: c8 02 80 00 ld [ %o2 ], %g4 <== NOT EXECUTED
400120a4: 82 01 00 01 add %g4, %g1, %g1 <== NOT EXECUTED
400120a8: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
400120ac: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
400120b0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
400120b4: 06 bf ff ef bl 40012070 <rtems_rfs_group_usage+0x14> <== NOT EXECUTED
400120b8: 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))
400120bc: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
400120c0: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
400120c4: 08 80 00 03 bleu 400120d0 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
400120c8: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
400120cc: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
400120d0: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
400120d4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
400120d8: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
400120dc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400120e0: 38 80 00 02 bgu,a 400120e8 <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
400120e4: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
400120e8: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
400120ec: 81 c3 e0 08 retl <== NOT EXECUTED
400120f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
400123ac <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400123ac: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
400123b0: 90 10 20 00 clr %o0
400123b4: 40 00 06 15 call 40013c08 <rtems_rfs_trace>
400123b8: 13 00 02 00 sethi %hi(0x80000), %o1
400123bc: 80 8a 20 ff btst 0xff, %o0
400123c0: 22 80 00 07 be,a 400123dc <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
400123c4: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
400123c8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400123cc: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400123d0: 40 00 40 d4 call 40022720 <printf> <== NOT EXECUTED
400123d4: 90 12 22 40 or %o0, 0x240, %o0 ! 40034640 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
400123d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400123dc: 92 10 00 19 mov %i1, %o1
400123e0: 7f ff ff b7 call 400122bc <rtems_rfs_inode_unload>
400123e4: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
400123e8: b0 92 20 00 orcc %o0, 0, %i0
400123ec: 32 80 00 11 bne,a 40012430 <rtems_rfs_inode_close+0x84> <== NEVER TAKEN
400123f0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
400123f4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
400123f8: 80 a0 60 00 cmp %g1, 0
400123fc: 04 80 00 0c ble 4001242c <rtems_rfs_inode_close+0x80> <== ALWAYS TAKEN
40012400: 13 00 02 00 sethi %hi(0x80000), %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40012404: 90 10 20 00 clr %o0 <== NOT EXECUTED
40012408: 40 00 06 00 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001240c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40012410: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012414: 22 80 00 07 be,a 40012430 <rtems_rfs_inode_close+0x84> <== NOT EXECUTED
40012418: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
4001241c: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
40012420: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40012424: 40 00 40 bf call 40022720 <printf> <== NOT EXECUTED
40012428: 90 12 22 68 or %o0, 0x268, %o0 ! 40034668 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
4001242c: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
40012430: 81 c7 e0 08 ret
40012434: 81 e8 00 00 restore
40012700 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40012700: 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))
40012704: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40012708: e2 07 a0 64 ld [ %fp + 0x64 ], %l1
4001270c: e8 17 a0 5e lduh [ %fp + 0x5e ], %l4
40012710: 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))
40012714: 40 00 05 3d call 40013c08 <rtems_rfs_trace>
40012718: 13 00 10 00 sethi %hi(0x400000), %o1
4001271c: 80 8a 20 ff btst 0xff, %o0
40012720: 02 80 00 36 be 400127f8 <rtems_rfs_inode_create+0xf8> <== ALWAYS TAKEN
40012724: a4 0f 30 00 and %i4, -4096, %l2
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
40012728: 82 0f 30 00 and %i4, -4096, %g1 <== NOT EXECUTED
4001272c: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
40012730: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40012734: 02 80 00 11 be 40012778 <rtems_rfs_inode_create+0x78> <== NOT EXECUTED
40012738: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
4001273c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40012740: 02 80 00 11 be 40012784 <rtems_rfs_inode_create+0x84> <== NOT EXECUTED
40012744: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
40012748: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001274c: 02 80 00 11 be 40012790 <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
40012750: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
40012754: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40012758: 02 80 00 11 be 4001279c <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
4001275c: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
40012760: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40012764: 22 80 00 11 be,a 400127a8 <rtems_rfs_inode_create+0xa8> <== NOT EXECUTED
40012768: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
4001276c: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED
40012770: 10 80 00 0f b 400127ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
40012774: a0 14 22 e0 or %l0, 0x2e0, %l0 ! 400346e0 <_CPU_Trap_slot_template+0xc30><== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
40012778: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED
4001277c: 10 80 00 0c b 400127ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
40012780: a0 14 22 c8 or %l0, 0x2c8, %l0 ! 400346c8 <_CPU_Trap_slot_template+0xc18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
40012784: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED
40012788: 10 80 00 09 b 400127ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
4001278c: a0 14 22 d0 or %l0, 0x2d0, %l0 ! 400346d0 <_CPU_Trap_slot_template+0xc20><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
40012790: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED
40012794: 10 80 00 06 b 400127ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
40012798: a0 14 20 c8 or %l0, 0xc8, %l0 ! 400344c8 <_CPU_Trap_slot_template+0xa18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
4001279c: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED
400127a0: 10 80 00 03 b 400127ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
400127a4: a0 14 22 d8 or %l0, 0x2d8, %l0 ! 400346d8 <_CPU_Trap_slot_template+0xc28><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
400127a8: a0 14 22 e8 or %l0, 0x2e8, %l0 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
400127ac: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400127b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400127b4: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
400127b8: 40 00 3f da call 40022720 <printf> <== NOT EXECUTED
400127bc: a4 10 00 1a mov %i2, %l2 <== NOT EXECUTED
for (c = 0; c < length; c++)
400127c0: 10 80 00 04 b 400127d0 <rtems_rfs_inode_create+0xd0> <== NOT EXECUTED
400127c4: aa 06 80 1b add %i2, %i3, %l5 <== NOT EXECUTED
printf ("%c", name[c]);
400127c8: 40 00 40 40 call 400228c8 <putchar> <== NOT EXECUTED
400127cc: 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++)
400127d0: 80 a4 80 15 cmp %l2, %l5 <== NOT EXECUTED
400127d4: 32 bf ff fd bne,a 400127c8 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
400127d8: 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));
400127dc: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400127e0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400127e4: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
400127e8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400127ec: 40 00 3f cd call 40022720 <printf> <== NOT EXECUTED
400127f0: 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)
400127f4: a4 0f 30 00 and %i4, -4096, %l2 <== NOT EXECUTED
400127f8: 05 00 00 18 sethi %hi(0x6000), %g2
400127fc: 80 a4 80 02 cmp %l2, %g2
40012800: 02 80 00 11 be 40012844 <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
40012804: 82 10 00 12 mov %l2, %g1
40012808: 80 a4 80 02 cmp %l2, %g2
4001280c: 18 80 00 08 bgu 4001282c <rtems_rfs_inode_create+0x12c>
40012810: 05 00 00 20 sethi %hi(0x8000), %g2
40012814: 05 00 00 08 sethi %hi(0x2000), %g2
40012818: 80 a4 80 02 cmp %l2, %g2
4001281c: 02 80 00 0a be 40012844 <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
40012820: 05 00 00 10 sethi %hi(0x4000), %g2
40012824: 10 80 00 06 b 4001283c <rtems_rfs_inode_create+0x13c>
40012828: 80 a0 40 02 cmp %g1, %g2
4001282c: 80 a4 80 02 cmp %l2, %g2
40012830: 02 80 00 05 be 40012844 <rtems_rfs_inode_create+0x144>
40012834: 05 00 00 28 sethi %hi(0xa000), %g2
40012838: 80 a0 40 02 cmp %g1, %g2
4001283c: 12 80 00 81 bne 40012a40 <rtems_rfs_inode_create+0x340> <== NEVER TAKEN
40012840: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
40012844: 90 10 00 18 mov %i0, %o0
40012848: 92 10 00 19 mov %i1, %o1
4001284c: 7f ff fe 2a call 400120f4 <rtems_rfs_inode_alloc>
40012850: 94 10 00 11 mov %l1, %o2
if (rc > 0)
40012854: a0 92 20 00 orcc %o0, 0, %l0
40012858: 34 80 00 7b bg,a 40012a44 <rtems_rfs_inode_create+0x344>
4001285c: b0 10 00 10 mov %l0, %i0
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
40012860: d2 04 40 00 ld [ %l1 ], %o1
40012864: 90 10 00 18 mov %i0, %o0
40012868: 94 07 bf d8 add %fp, -40, %o2
4001286c: 7f ff fe 5e call 400121e4 <rtems_rfs_inode_open>
40012870: 96 10 20 01 mov 1, %o3
if (rc > 0)
40012874: a0 92 20 00 orcc %o0, 0, %l0
40012878: 04 80 00 04 ble 40012888 <rtems_rfs_inode_create+0x188> <== ALWAYS TAKEN
4001287c: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
40012880: 10 80 00 6c b 40012a30 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
40012884: 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);
40012888: 92 10 00 1d mov %i5, %o1
4001288c: 94 10 00 1c mov %i4, %o2
40012890: 96 10 00 14 mov %l4, %o3
40012894: 7f ff ff 47 call 400125b0 <rtems_rfs_inode_initialise>
40012898: 98 10 00 13 mov %l3, %o4
if (rc > 0)
4001289c: a0 92 20 00 orcc %o0, 0, %l0
400128a0: 04 80 00 07 ble 400128bc <rtems_rfs_inode_create+0x1bc> <== ALWAYS TAKEN
400128a4: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_close (fs, &inode);
400128a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400128ac: 7f ff fe c0 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
400128b0: 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);
400128b4: 10 80 00 5f b 40012a30 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
400128b8: 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))
400128bc: 80 a4 80 01 cmp %l2, %g1
400128c0: 12 80 00 17 bne 4001291c <rtems_rfs_inode_create+0x21c>
400128c4: 90 10 00 18 mov %i0, %o0
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
400128c8: d8 04 40 00 ld [ %l1 ], %o4
400128cc: 92 07 bf d8 add %fp, -40, %o1
400128d0: 15 10 00 c8 sethi %hi(0x40032000), %o2
400128d4: 96 10 20 01 mov 1, %o3
400128d8: 40 00 27 a1 call 4001c75c <rtems_rfs_dir_add_entry>
400128dc: 94 12 a3 d0 or %o2, 0x3d0, %o2
if (rc == 0)
400128e0: a0 92 20 00 orcc %o0, 0, %l0
400128e4: 12 80 00 0b bne 40012910 <rtems_rfs_inode_create+0x210> <== NEVER TAKEN
400128e8: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
400128ec: 90 10 00 18 mov %i0, %o0
400128f0: 92 07 bf d8 add %fp, -40, %o1
400128f4: 15 10 00 c8 sethi %hi(0x40032000), %o2
400128f8: 96 10 20 02 mov 2, %o3
400128fc: 94 12 a3 d8 or %o2, 0x3d8, %o2
40012900: 40 00 27 97 call 4001c75c <rtems_rfs_dir_add_entry>
40012904: 98 10 00 19 mov %i1, %o4
40012908: a0 10 00 08 mov %o0, %l0
if (rc > 0)
4001290c: 80 a4 20 00 cmp %l0, 0
40012910: 14 80 00 0b bg 4001293c <rtems_rfs_inode_create+0x23c> <== NEVER TAKEN
40012914: 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);
40012918: 90 10 00 18 mov %i0, %o0
4001291c: 92 10 00 19 mov %i1, %o1
40012920: 94 07 bf b0 add %fp, -80, %o2
40012924: 7f ff fe 30 call 400121e4 <rtems_rfs_inode_open>
40012928: 96 10 20 01 mov 1, %o3
4001292c: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40012930: 80 a4 20 00 cmp %l0, 0
40012934: 04 80 00 04 ble 40012944 <rtems_rfs_inode_create+0x244> <== ALWAYS TAKEN
40012938: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
4001293c: 10 80 00 30 b 400129fc <rtems_rfs_inode_create+0x2fc> <== NOT EXECUTED
40012940: 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);
40012944: d8 04 40 00 ld [ %l1 ], %o4
40012948: 92 07 bf b0 add %fp, -80, %o1
4001294c: 94 10 00 1a mov %i2, %o2
40012950: 40 00 27 83 call 4001c75c <rtems_rfs_dir_add_entry>
40012954: 96 10 00 1b mov %i3, %o3
if (rc > 0)
40012958: a0 92 20 00 orcc %o0, 0, %l0
4001295c: 04 80 00 0b ble 40012988 <rtems_rfs_inode_create+0x288> <== ALWAYS TAKEN
40012960: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_delete (fs, &inode);
40012964: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012968: 7f ff fe b4 call 40012438 <rtems_rfs_inode_delete> <== NOT EXECUTED
4001296c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012970: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012974: 7f ff fe 8e call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
40012978: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001297c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012980: 10 80 00 23 b 40012a0c <rtems_rfs_inode_create+0x30c> <== NOT EXECUTED
40012984: 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))
40012988: 80 a4 80 01 cmp %l2, %g1
4001298c: 12 80 00 15 bne 400129e0 <rtems_rfs_inode_create+0x2e0>
40012990: 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);
40012994: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
40012998: 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);
4001299c: c6 08 60 01 ldub [ %g1 + 1 ], %g3
400129a0: c4 08 40 00 ldub [ %g1 ], %g2
400129a4: 85 28 a0 08 sll %g2, 8, %g2
400129a8: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
400129ac: 87 28 a0 10 sll %g2, 0x10, %g3
400129b0: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
400129b4: 86 39 00 03 xnor %g4, %g3, %g3
400129b8: 80 a0 00 03 cmp %g0, %g3
400129bc: 86 60 20 00 subx %g0, 0, %g3
400129c0: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
400129c4: 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);
400129c8: 87 30 a0 08 srl %g2, 8, %g3
400129cc: c6 28 40 00 stb %g3, [ %g1 ]
400129d0: c2 07 bf bc ld [ %fp + -68 ], %g1
400129d4: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400129d8: 82 10 20 01 mov 1, %g1
400129dc: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
400129e0: 7f ff fe 73 call 400123ac <rtems_rfs_inode_close>
400129e4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
400129e8: 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);
400129ec: a0 10 00 08 mov %o0, %l0
if (rc > 0)
400129f0: 80 a4 20 00 cmp %l0, 0
400129f4: 04 80 00 09 ble 40012a18 <rtems_rfs_inode_create+0x318> <== ALWAYS TAKEN
400129f8: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
400129fc: 7f ff fe 8f call 40012438 <rtems_rfs_inode_delete> <== NOT EXECUTED
40012a00: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012a04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012a08: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012a0c: 7f ff fe 68 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
40012a10: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
40012a14: 30 80 00 0c b,a 40012a44 <rtems_rfs_inode_create+0x344> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
40012a18: 7f ff fe 65 call 400123ac <rtems_rfs_inode_close>
40012a1c: 01 00 00 00 nop
if (rc > 0)
40012a20: a0 92 20 00 orcc %o0, 0, %l0
40012a24: 24 80 00 07 ble,a 40012a40 <rtems_rfs_inode_create+0x340><== ALWAYS TAKEN
40012a28: a0 10 20 00 clr %l0
{
rtems_rfs_inode_free (fs, *ino);
40012a2c: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
40012a30: 7f ff fd bb call 4001211c <rtems_rfs_inode_free> <== NOT EXECUTED
40012a34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
return 0;
}
40012a38: 81 c7 e0 08 ret <== NOT EXECUTED
40012a3c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
40012a40: b0 10 00 10 mov %l0, %i0
40012a44: 81 c7 e0 08 ret
40012a48: 81 e8 00 00 restore
40012438 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40012438: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4001243c: 90 10 20 00 clr %o0
40012440: 40 00 05 f2 call 40013c08 <rtems_rfs_trace>
40012444: 13 00 20 00 sethi %hi(0x800000), %o1
40012448: 80 8a 20 ff btst 0xff, %o0
4001244c: 22 80 00 0f be,a 40012488 <rtems_rfs_inode_delete+0x50> <== ALWAYS TAKEN
40012450: c4 06 60 0c ld [ %i1 + 0xc ], %g2
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
40012454: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40012458: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001245c: 02 80 00 05 be 40012470 <rtems_rfs_inode_delete+0x38> <== NOT EXECUTED
40012460: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40012464: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED
40012468: 10 80 00 04 b 40012478 <rtems_rfs_inode_delete+0x40> <== NOT EXECUTED
4001246c: 94 12 a1 a0 or %o2, 0x1a0, %o2 ! 400345a0 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
40012470: 15 10 00 ca sethi %hi(0x40032800), %o2 <== NOT EXECUTED
40012474: 94 12 a1 e8 or %o2, 0x1e8, %o2 ! 400329e8 <Callbacks.6428+0x1d0><== NOT EXECUTED
40012478: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001247c: 40 00 40 a9 call 40022720 <printf> <== NOT EXECUTED
40012480: 90 12 22 98 or %o0, 0x298, %o0 ! 40034698 <_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))
40012484: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
40012488: 80 a0 a0 00 cmp %g2, 0
4001248c: 02 80 00 1e be 40012504 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
40012490: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
40012494: d2 06 60 08 ld [ %i1 + 8 ], %o1
40012498: 7f ff ff 21 call 4001211c <rtems_rfs_inode_free>
4001249c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400124a0: 80 a2 20 00 cmp %o0, 0
400124a4: 14 80 00 18 bg 40012504 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
400124a8: 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);
400124ac: 90 10 00 18 mov %i0, %o0
400124b0: 40 00 21 c1 call 4001abb4 <rtems_rfs_block_map_open>
400124b4: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
400124b8: 80 a2 20 00 cmp %o0, 0
400124bc: 12 80 00 12 bne 40012504 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
400124c0: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
400124c4: 40 00 24 d1 call 4001b808 <rtems_rfs_block_map_free_all>
400124c8: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
400124cc: 92 07 bf b0 add %fp, -80, %o1
400124d0: 40 00 22 1a call 4001ad38 <rtems_rfs_block_map_close>
400124d4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
400124d8: d0 06 60 0c ld [ %i1 + 0xc ], %o0
400124dc: 92 10 20 ff mov 0xff, %o1
400124e0: 40 00 40 12 call 40022528 <memset>
400124e4: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400124e8: 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);
400124ec: 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);
400124f0: 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);
400124f4: 40 00 25 29 call 4001b998 <rtems_rfs_buffer_handle_release>
400124f8: 92 06 60 10 add %i1, 0x10, %o1
handle->loads = 0;
400124fc: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
40012500: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
40012504: 81 c7 e0 08 ret
40012508: 91 e8 00 08 restore %g0, %o0, %o0
40012acc <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]);
40012acc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40012ad0: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
40012ad4: 85 2a 60 02 sll %o1, 2, %g2 <== NOT EXECUTED
40012ad8: 84 00 40 02 add %g1, %g2, %g2 <== NOT EXECUTED
40012adc: 82 00 a0 04 add %g2, 4, %g1 <== NOT EXECUTED
40012ae0: d0 08 a0 04 ldub [ %g2 + 4 ], %o0 <== NOT EXECUTED
40012ae4: c4 08 a0 05 ldub [ %g2 + 5 ], %g2 <== NOT EXECUTED
40012ae8: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
40012aec: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
40012af0: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
40012af4: c4 08 60 03 ldub [ %g1 + 3 ], %g2 <== NOT EXECUTED
40012af8: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
40012afc: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
40012b00: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
40012b04: 81 c3 e0 08 retl <== NOT EXECUTED
40012b08: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
40012130 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40012130: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
40012134: 90 10 20 00 clr %o0
40012138: 40 00 06 b4 call 40013c08 <rtems_rfs_trace>
4001213c: 13 00 04 00 sethi %hi(0x100000), %o1
40012140: 80 8a 20 ff btst 0xff, %o0
40012144: 02 80 00 0f be 40012180 <rtems_rfs_inode_load+0x50> <== ALWAYS TAKEN
40012148: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
4001214c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40012150: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40012154: 02 80 00 05 be 40012168 <rtems_rfs_inode_load+0x38> <== NOT EXECUTED
40012158: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
4001215c: 17 10 00 d1 sethi %hi(0x40034400), %o3 <== NOT EXECUTED
40012160: 10 80 00 04 b 40012170 <rtems_rfs_inode_load+0x40> <== NOT EXECUTED
40012164: 96 12 e1 a0 or %o3, 0x1a0, %o3 ! 400345a0 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
40012168: 17 10 00 ca sethi %hi(0x40032800), %o3 <== NOT EXECUTED
4001216c: 96 12 e1 e8 or %o3, 0x1e8, %o3 ! 400329e8 <Callbacks.6428+0x1d0><== NOT EXECUTED
40012170: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40012174: 40 00 41 6b call 40022720 <printf> <== NOT EXECUTED
40012178: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400345a8 <_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))
4001217c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40012180: 80 a0 60 00 cmp %g1, 0
40012184: 32 80 00 13 bne,a 400121d0 <rtems_rfs_inode_load+0xa0>
40012188: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
4001218c: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
40012190: 90 10 00 18 mov %i0, %o0
40012194: 92 06 60 10 add %i1, 0x10, %o1
40012198: 40 00 26 74 call 4001bb68 <rtems_rfs_buffer_handle_request>
4001219c: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
400121a0: b0 92 20 00 orcc %o0, 0, %i0
400121a4: 14 80 00 0e bg 400121dc <rtems_rfs_inode_load+0xac> <== NEVER TAKEN
400121a8: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
400121ac: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
400121b0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400121b4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400121b8: 87 28 60 03 sll %g1, 3, %g3
400121bc: 83 28 60 06 sll %g1, 6, %g1
400121c0: 82 20 40 03 sub %g1, %g3, %g1
400121c4: 82 00 80 01 add %g2, %g1, %g1
400121c8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
handle->loads++;
400121cc: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
400121d0: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400121d4: 82 00 60 01 inc %g1
400121d8: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
400121dc: 81 c7 e0 08 ret
400121e0: 81 e8 00 00 restore
400121e4 <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)
{
400121e4: 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))
400121e8: 90 10 20 00 clr %o0
400121ec: 40 00 06 87 call 40013c08 <rtems_rfs_trace>
400121f0: 13 00 01 00 sethi %hi(0x40000), %o1
400121f4: 80 8a 20 ff btst 0xff, %o0
400121f8: 02 80 00 07 be 40012214 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
400121fc: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
40012200: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40012204: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40012208: 40 00 41 46 call 40022720 <printf> <== NOT EXECUTED
4001220c: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
40012210: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40012214: 02 80 00 28 be 400122b4 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
40012218: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
4001221c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
40012220: ba 06 7f ff add %i1, -1, %i5
40012224: 80 a7 40 02 cmp %i5, %g2
40012228: 18 80 00 23 bgu 400122b4 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
4001222c: 90 10 00 1d mov %i5, %o0
return EINVAL;
handle->ino = ino;
40012230: 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;
40012234: f2 06 20 2c ld [ %i0 + 0x2c ], %i1
gino = gino % fs->group_inodes;
40012238: 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;
4001223c: 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;
40012240: 40 00 72 f0 call 4002ee00 <.urem>
40012244: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40012248: 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;
4001224c: 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;
40012250: 40 00 72 ec call 4002ee00 <.urem>
40012254: 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;
40012258: 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;
4001225c: 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;
40012260: 7f ff c1 07 call 4000267c <.udiv>
40012264: 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);
40012268: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
4001226c: 87 2a 20 04 sll %o0, 4, %g3
40012270: 83 2a 20 06 sll %o0, 6, %g1
40012274: 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;
40012278: fa 00 80 01 ld [ %g2 + %g1 ], %i5
4001227c: 90 10 00 10 mov %l0, %o0
40012280: ba 07 60 02 add %i5, 2, %i5
40012284: 7f ff c0 fe call 4000267c <.udiv>
40012288: 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;
4001228c: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40012290: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
40012294: c0 26 a0 14 clr [ %i2 + 0x14 ]
40012298: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
4001229c: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
400122a0: 80 a6 e0 00 cmp %i3, 0
400122a4: 02 80 00 04 be 400122b4 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
400122a8: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
400122ac: 7f ff ff a1 call 40012130 <rtems_rfs_inode_load>
400122b0: 93 e8 00 1a restore %g0, %i2, %o1
return rc;
}
400122b4: 81 c7 e0 08 ret <== NOT EXECUTED
400122b8: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
40012b0c <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);
40012b0c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40012b10: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
40012b14: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
40012b18: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
40012b1c: 85 32 a0 18 srl %o2, 0x18, %g2 <== NOT EXECUTED
40012b20: c4 28 60 04 stb %g2, [ %g1 + 4 ] <== NOT EXECUTED
40012b24: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40012b28: 85 32 a0 10 srl %o2, 0x10, %g2 <== NOT EXECUTED
40012b2c: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
40012b30: c4 28 60 05 stb %g2, [ %g1 + 5 ] <== NOT EXECUTED
40012b34: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40012b38: 85 32 a0 08 srl %o2, 8, %g2 <== NOT EXECUTED
40012b3c: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
40012b40: c4 28 60 06 stb %g2, [ %g1 + 6 ] <== NOT EXECUTED
40012b44: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40012b48: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
40012b4c: d4 2a 60 07 stb %o2, [ %o1 + 7 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012b50: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40012b54: 81 c3 e0 08 retl <== NOT EXECUTED
40012b58: c2 2a 20 10 stb %g1, [ %o0 + 0x10 ] <== NOT EXECUTED
4001250c <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
4001250c: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40012510: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40012514: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40012518: 80 a0 60 00 cmp %g1, 0
4001251c: 02 80 00 23 be 400125a8 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
40012520: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
40012524: 40 00 50 e5 call 400268b8 <time>
40012528: 90 10 20 00 clr %o0
if (atime)
4001252c: 80 a6 60 00 cmp %i1, 0
40012530: 02 80 00 0f be 4001256c <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
40012534: 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);
40012538: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001253c: 85 32 20 18 srl %o0, 0x18, %g2
40012540: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
40012544: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012548: 85 32 20 10 srl %o0, 0x10, %g2
4001254c: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
40012550: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012554: 85 32 20 08 srl %o0, 8, %g2
40012558: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
4001255c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012560: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012564: 82 10 20 01 mov 1, %g1
40012568: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
4001256c: 02 80 00 0f be 400125a8 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
40012570: 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);
40012574: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012578: 85 32 20 18 srl %o0, 0x18, %g2
4001257c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
40012580: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012584: 85 32 20 10 srl %o0, 0x10, %g2
40012588: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
4001258c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012590: 85 32 20 08 srl %o0, 8, %g2
40012594: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40012598: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001259c: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400125a0: 82 10 20 01 mov 1, %g1
400125a4: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
400125a8: 81 c7 e0 08 ret
400125ac: 81 e8 00 00 restore
400122bc <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
400122bc: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
400122c0: 90 10 20 00 clr %o0
400122c4: 40 00 06 51 call 40013c08 <rtems_rfs_trace>
400122c8: 13 00 08 00 sethi %hi(0x200000), %o1
400122cc: 80 8a 20 ff btst 0xff, %o0
400122d0: 02 80 00 0f be 4001230c <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
400122d4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
400122d8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400122dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400122e0: 02 80 00 05 be 400122f4 <rtems_rfs_inode_unload+0x38> <== NOT EXECUTED
400122e4: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
400122e8: 17 10 00 d1 sethi %hi(0x40034400), %o3 <== NOT EXECUTED
400122ec: 10 80 00 04 b 400122fc <rtems_rfs_inode_unload+0x40> <== NOT EXECUTED
400122f0: 96 12 e1 a0 or %o3, 0x1a0, %o3 ! 400345a0 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
400122f4: 17 10 00 ca sethi %hi(0x40032800), %o3 <== NOT EXECUTED
400122f8: 96 12 e1 e8 or %o3, 0x1e8, %o3 ! 400329e8 <Callbacks.6428+0x1d0><== NOT EXECUTED
400122fc: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40012300: 40 00 41 08 call 40022720 <printf> <== NOT EXECUTED
40012304: 90 12 22 08 or %o0, 0x208, %o0 ! 40034608 <_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))
40012308: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
4001230c: 80 a0 60 00 cmp %g1, 0
40012310: 32 80 00 04 bne,a 40012320 <rtems_rfs_inode_unload+0x64>
40012314: 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;
40012318: 10 80 00 23 b 400123a4 <rtems_rfs_inode_unload+0xe8>
4001231c: 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)
40012320: 80 a0 a0 00 cmp %g2, 0
40012324: 02 80 00 20 be 400123a4 <rtems_rfs_inode_unload+0xe8> <== NEVER TAKEN
40012328: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
4001232c: 82 00 bf ff add %g2, -1, %g1
if (handle->loads == 0)
40012330: 80 a0 60 00 cmp %g1, 0
40012334: 12 bf ff f9 bne 40012318 <rtems_rfs_inode_unload+0x5c>
40012338: 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)
4001233c: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
40012340: 80 a0 60 00 cmp %g1, 0
40012344: 02 80 00 15 be 40012398 <rtems_rfs_inode_unload+0xdc>
40012348: 90 10 00 18 mov %i0, %o0
4001234c: 80 a6 a0 00 cmp %i2, 0
40012350: 02 80 00 12 be 40012398 <rtems_rfs_inode_unload+0xdc> <== NEVER TAKEN
40012354: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
40012358: 40 00 51 58 call 400268b8 <time>
4001235c: 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);
40012360: c4 06 60 0c ld [ %i1 + 0xc ], %g2
40012364: 87 32 20 18 srl %o0, 0x18, %g3
40012368: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ]
4001236c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
40012370: 87 32 20 10 srl %o0, 0x10, %g3
40012374: c6 28 a0 19 stb %g3, [ %g2 + 0x19 ]
40012378: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001237c: 87 32 20 08 srl %o0, 8, %g3
40012380: c6 28 a0 1a stb %g3, [ %g2 + 0x1a ]
40012384: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012388: 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);
4001238c: d0 28 a0 1b stb %o0, [ %g2 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012390: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40012394: 90 10 00 18 mov %i0, %o0
40012398: 40 00 25 80 call 4001b998 <rtems_rfs_buffer_handle_release>
4001239c: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
400123a0: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
400123a4: 81 c7 e0 08 ret
400123a8: 91 e8 00 08 restore %g0, %o0, %o0
4001ec98 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
4001ec98: 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))
4001ec9c: 90 10 20 00 clr %o0
4001eca0: 7f ff d3 da call 40013c08 <rtems_rfs_trace>
4001eca4: 13 00 40 00 sethi %hi(0x1000000), %o1
4001eca8: 80 8a 20 ff btst 0xff, %o0
4001ecac: 02 80 00 13 be 4001ecf8 <rtems_rfs_link+0x60> <== ALWAYS TAKEN
4001ecb0: 90 10 00 18 mov %i0, %o0
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
4001ecb4: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001ecb8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001ecbc: 90 12 20 40 or %o0, 0x40, %o0 <== NOT EXECUTED
4001ecc0: 40 00 0e 98 call 40022720 <printf> <== NOT EXECUTED
4001ecc4: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
4001ecc8: 10 80 00 05 b 4001ecdc <rtems_rfs_link+0x44> <== NOT EXECUTED
4001eccc: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
4001ecd0: 40 00 0e fe call 400228c8 <putchar> <== NOT EXECUTED
4001ecd4: 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++)
4001ecd8: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
4001ecdc: 26 bf ff fd bl,a 4001ecd0 <rtems_rfs_link+0x38> <== NOT EXECUTED
4001ece0: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
4001ece4: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001ece8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001ecec: 40 00 0e 8d call 40022720 <printf> <== NOT EXECUTED
4001ecf0: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001ecf4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ecf8: 92 10 00 1c mov %i4, %o1
4001ecfc: 94 07 bf d8 add %fp, -40, %o2
4001ed00: 7f ff cd 39 call 400121e4 <rtems_rfs_inode_open>
4001ed04: 96 10 20 01 mov 1, %o3
if (rc)
4001ed08: a0 92 20 00 orcc %o0, 0, %l0
4001ed0c: 12 80 00 49 bne 4001ee30 <rtems_rfs_link+0x198> <== NEVER TAKEN
4001ed10: 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)))
4001ed14: 12 80 00 10 bne 4001ed54 <rtems_rfs_link+0xbc> <== NEVER TAKEN
4001ed18: 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);
4001ed1c: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001ed20: c4 08 60 02 ldub [ %g1 + 2 ], %g2
4001ed24: 03 00 00 3c sethi %hi(0xf000), %g1
4001ed28: 85 28 a0 08 sll %g2, 8, %g2
4001ed2c: 84 08 80 01 and %g2, %g1, %g2
4001ed30: 03 00 00 10 sethi %hi(0x4000), %g1
4001ed34: 80 a0 80 01 cmp %g2, %g1
4001ed38: 12 80 00 08 bne 4001ed58 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
4001ed3c: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
4001ed40: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001ed44: 7f ff cd 9a call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001ed48: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
4001ed4c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ed50: 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);
4001ed54: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001ed58: 94 07 bf b0 add %fp, -80, %o2
4001ed5c: 7f ff cd 22 call 400121e4 <rtems_rfs_inode_open>
4001ed60: 96 10 20 01 mov 1, %o3
4001ed64: a0 10 00 08 mov %o0, %l0
if (rc)
4001ed68: 80 a4 20 00 cmp %l0, 0
4001ed6c: 02 80 00 04 be 4001ed7c <rtems_rfs_link+0xe4> <== ALWAYS TAKEN
4001ed70: 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);
4001ed74: 10 80 00 0f b 4001edb0 <rtems_rfs_link+0x118> <== NOT EXECUTED
4001ed78: 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);
4001ed7c: 92 07 bf b0 add %fp, -80, %o1
4001ed80: 94 10 00 19 mov %i1, %o2
4001ed84: 96 10 00 1a mov %i2, %o3
4001ed88: 7f ff f6 75 call 4001c75c <rtems_rfs_dir_add_entry>
4001ed8c: 98 10 00 1c mov %i4, %o4
if (rc > 0)
4001ed90: a0 92 20 00 orcc %o0, 0, %l0
4001ed94: 04 80 00 0a ble 4001edbc <rtems_rfs_link+0x124> <== ALWAYS TAKEN
4001ed98: 92 07 bf b0 add %fp, -80, %o1
{
rtems_rfs_inode_close (fs, &parent_inode);
4001ed9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001eda0: 7f ff cd 83 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001eda4: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001eda8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001edac: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001edb0: 7f ff cd 7f call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001edb4: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
4001edb8: 30 80 00 1f b,a 4001ee34 <rtems_rfs_link+0x19c> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
4001edbc: 7f ff ff a8 call 4001ec5c <rtems_rfs_inode_get_links>
4001edc0: 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);
4001edc4: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001edc8: 90 02 20 01 inc %o0
4001edcc: 85 32 20 08 srl %o0, 8, %g2
4001edd0: c4 28 40 00 stb %g2, [ %g1 ]
4001edd4: 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);
4001edd8: 92 10 20 01 mov 1, %o1
4001eddc: d0 28 60 01 stb %o0, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ede0: 82 10 20 01 mov 1, %g1
4001ede4: 90 07 bf b0 add %fp, -80, %o0
4001ede8: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4001edec: 7f ff cd c8 call 4001250c <rtems_rfs_inode_time_stamp_now>
4001edf0: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
4001edf4: 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);
4001edf8: a0 10 00 08 mov %o0, %l0
if (rc > 0)
4001edfc: 80 a4 20 00 cmp %l0, 0
4001ee00: 14 bf ff e8 bg 4001eda0 <rtems_rfs_link+0x108> <== NEVER TAKEN
4001ee04: 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);
4001ee08: 7f ff cd 69 call 400123ac <rtems_rfs_inode_close>
4001ee0c: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
4001ee10: 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);
4001ee14: a0 10 00 08 mov %o0, %l0
if (rc > 0)
4001ee18: 80 a4 20 00 cmp %l0, 0
4001ee1c: 14 bf ff e5 bg 4001edb0 <rtems_rfs_link+0x118> <== NEVER TAKEN
4001ee20: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
4001ee24: 7f ff cd 62 call 400123ac <rtems_rfs_inode_close>
4001ee28: 01 00 00 00 nop
4001ee2c: a0 10 00 08 mov %o0, %l0
return rc;
}
4001ee30: b0 10 00 10 mov %l0, %i0
4001ee34: 81 c7 e0 08 ret
4001ee38: 81 e8 00 00 restore
4001f614 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
4001f614: 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'),
4001f618: 11 14 91 94 sethi %hi(0x52465000), %o0
4001f61c: 98 10 00 18 mov %i0, %o4
4001f620: 90 12 23 6d or %o0, 0x36d, %o0
4001f624: 92 10 20 01 mov 1, %o1
4001f628: 94 10 20 54 mov 0x54, %o2
4001f62c: 96 10 20 00 clr %o3
4001f630: 7f ff b6 25 call 4000cec4 <rtems_semaphore_create>
4001f634: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
4001f638: 80 a2 20 00 cmp %o0, 0
4001f63c: 02 80 00 0f be 4001f678 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
4001f640: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001f644: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f648: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001f64c: 7f ff d1 6f call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f650: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001f654: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f658: 02 80 00 08 be 4001f678 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
4001f65c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
4001f660: 7f ff de b0 call 40017120 <rtems_status_text> <== NOT EXECUTED
4001f664: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f668: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001f66c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f670: 40 00 0c 2c call 40022720 <printf> <== NOT EXECUTED
4001f674: 90 12 22 98 or %o0, 0x298, %o0 ! 40036a98 <CSWTCH.2+0x1658><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
4001f678: 81 c7 e0 08 ret
4001f67c: 81 e8 00 00 restore
4001f680 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
4001f680: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
4001f684: d0 06 00 00 ld [ %i0 ], %o0
4001f688: 7f ff b6 7d call 4000d07c <rtems_semaphore_delete>
4001f68c: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001f690: 80 a2 20 00 cmp %o0, 0
4001f694: 02 80 00 0f be 4001f6d0 <rtems_rfs_mutex_destroy+0x50> <== ALWAYS TAKEN
4001f698: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001f69c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f6a0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001f6a4: 7f ff d1 59 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f6a8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001f6ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f6b0: 02 80 00 08 be 4001f6d0 <rtems_rfs_mutex_destroy+0x50> <== NOT EXECUTED
4001f6b4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
4001f6b8: 7f ff de 9a call 40017120 <rtems_status_text> <== NOT EXECUTED
4001f6bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f6c0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001f6c4: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f6c8: 40 00 0c 16 call 40022720 <printf> <== NOT EXECUTED
4001f6cc: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 40036ac0 <CSWTCH.2+0x1680><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
4001f6d0: 81 c7 e0 08 ret
4001f6d4: 81 e8 00 00 restore
4001f8f0 <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)
4001f8f0: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4001f8f4: 92 10 20 00 clr %o1
4001f8f8: 90 10 00 18 mov %i0, %o0
4001f8fc: 94 10 20 00 clr %o2
4001f900: 7f ff b6 0e call 4000d138 <rtems_semaphore_obtain>
4001f904: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001f908: 80 a2 20 00 cmp %o0, 0
4001f90c: 02 80 00 0f be 4001f948 <rtems_rfs_mutex_lock.isra.0+0x58><== ALWAYS TAKEN
4001f910: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001f914: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f918: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001f91c: 7f ff d0 bb call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f920: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001f924: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f928: 02 80 00 08 be 4001f948 <rtems_rfs_mutex_lock.isra.0+0x58><== NOT EXECUTED
4001f92c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001f930: 7f ff dd fc call 40017120 <rtems_status_text> <== NOT EXECUTED
4001f934: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f938: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001f93c: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001f940: 40 00 0b 78 call 40022720 <printf> <== NOT EXECUTED
4001f944: 90 12 23 68 or %o0, 0x368, %o0 ! 40034768 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
4001f948: 81 c7 e0 08 ret
4001f94c: 81 e8 00 00 restore
400131cc <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)
400131cc: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
400131d0: 92 10 20 00 clr %o1
400131d4: 90 10 00 18 mov %i0, %o0
400131d8: 94 10 20 00 clr %o2
400131dc: 7f ff e7 d7 call 4000d138 <rtems_semaphore_obtain>
400131e0: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
400131e4: 80 a2 20 00 cmp %o0, 0
400131e8: 02 80 00 0f be 40013224 <rtems_rfs_mutex_lock.isra.2+0x58><== ALWAYS TAKEN
400131ec: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400131f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
400131f4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400131f8: 40 00 02 84 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
400131fc: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40013200: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013204: 02 80 00 08 be 40013224 <rtems_rfs_mutex_lock.isra.2+0x58><== NOT EXECUTED
40013208: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001320c: 40 00 0f c5 call 40017120 <rtems_status_text> <== NOT EXECUTED
40013210: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40013214: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40013218: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001321c: 40 00 3d 41 call 40022720 <printf> <== NOT EXECUTED
40013220: 90 12 23 68 or %o0, 0x368, %o0 ! 40034768 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
40013224: 81 c7 e0 08 ret
40013228: 81 e8 00 00 restore
40013174 <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)
40013174: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40013178: 90 10 00 18 mov %i0, %o0
4001317c: 7f ff e8 38 call 4000d25c <rtems_semaphore_release>
40013180: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
40013184: 80 a2 20 00 cmp %o0, 0
40013188: 02 80 00 0f be 400131c4 <rtems_rfs_mutex_unlock.isra.1+0x50><== ALWAYS TAKEN
4001318c: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40013190: 90 10 20 00 clr %o0 <== NOT EXECUTED
40013194: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40013198: 40 00 02 9c call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001319c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
400131a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400131a4: 02 80 00 08 be 400131c4 <rtems_rfs_mutex_unlock.isra.1+0x50><== NOT EXECUTED
400131a8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400131ac: 40 00 0f dd call 40017120 <rtems_status_text> <== NOT EXECUTED
400131b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400131b4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400131b8: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400131bc: 40 00 3d 59 call 40022720 <printf> <== NOT EXECUTED
400131c0: 90 12 23 40 or %o0, 0x340, %o0 ! 40034740 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
400131c4: 81 c7 e0 08 ret
400131c8: 81 e8 00 00 restore
4001b818 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
4001b818: 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))
4001b81c: 90 10 20 00 clr %o0
4001b820: 92 10 20 80 mov 0x80, %o1
4001b824: 7f ff e0 f9 call 40013c08 <rtems_rfs_trace>
4001b828: ba 10 00 18 mov %i0, %i5
4001b82c: 80 8a 20 ff btst 0xff, %o0
4001b830: 22 80 00 07 be,a 4001b84c <rtems_rfs_release_chain+0x34> <== ALWAYS TAKEN
4001b834: b0 10 20 00 clr %i0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
4001b838: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001b83c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001b840: 40 00 1b b8 call 40022720 <printf> <== NOT EXECUTED
4001b844: 90 12 21 48 or %o0, 0x148, %o0 ! 40035548 <CSWTCH.2+0x108><== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
4001b848: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001b84c: 10 80 00 10 b 4001b88c <rtems_rfs_release_chain+0x74>
4001b850: 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 );
4001b854: 7f ff c8 fd call 4000dc48 <_Chain_Get>
4001b858: 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)--;
4001b85c: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001b860: 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)--;
4001b864: 82 00 7f ff add %g1, -1, %g1
4001b868: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001b86c: 40 00 15 39 call 40020d50 <rtems_rfs_buffer_bdbuf_release>
4001b870: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
4001b874: 80 a2 20 00 cmp %o0, 0
4001b878: 24 80 00 06 ble,a 4001b890 <rtems_rfs_release_chain+0x78><== ALWAYS TAKEN
4001b87c: c2 07 40 00 ld [ %i5 ], %g1
4001b880: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001b884: 22 80 00 02 be,a 4001b88c <rtems_rfs_release_chain+0x74> <== NOT EXECUTED
4001b888: 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))
4001b88c: c2 07 40 00 ld [ %i5 ], %g1
4001b890: 80 a0 40 1c cmp %g1, %i4
4001b894: 12 bf ff f0 bne 4001b854 <rtems_rfs_release_chain+0x3c>
4001b898: 01 00 00 00 nop
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
4001b89c: 81 c7 e0 08 ret
4001b8a0: 81 e8 00 00 restore
40012e78 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
40012e78: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012e7c: 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);
40012e80: 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);
40012e84: 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);
40012e88: 94 07 bf d8 add %fp, -40, %o2
40012e8c: 90 10 00 1d mov %i5, %o0
40012e90: 7f ff fc d5 call 400121e4 <rtems_rfs_inode_open>
40012e94: 96 10 20 01 mov 1, %o3
if (rc > 0)
40012e98: b8 92 20 00 orcc %o0, 0, %i4
40012e9c: 04 80 00 07 ble 40012eb8 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
40012ea0: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
40012ea4: 40 00 38 c6 call 400211bc <__errno> <== NOT EXECUTED
40012ea8: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40012eac: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40012eb0: 81 c7 e0 08 ret <== NOT EXECUTED
40012eb4: 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();
40012eb8: 40 00 11 71 call 4001747c <geteuid>
40012ebc: 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;
40012ec0: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
40012ec4: 91 2a 20 10 sll %o0, 0x10, %o0
40012ec8: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40012ecc: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40012ed0: 85 28 a0 08 sll %g2, 8, %g2
40012ed4: 84 10 80 03 or %g2, %g3, %g2
40012ed8: 85 28 a0 10 sll %g2, 0x10, %g2
40012edc: 80 a0 80 08 cmp %g2, %o0
40012ee0: 02 80 00 0e be 40012f18 <rtems_rfs_rtems_chown+0xa0> <== ALWAYS TAKEN
40012ee4: 87 32 20 10 srl %o0, 0x10, %g3
40012ee8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40012eec: 22 80 00 0c be,a 40012f1c <rtems_rfs_rtems_chown+0xa4> <== NOT EXECUTED
40012ef0: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
40012ef4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012ef8: 7f ff fd 2d call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
40012efc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
40012f00: 40 00 38 af call 400211bc <__errno> <== NOT EXECUTED
40012f04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012f08: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40012f0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012f10: 81 c7 e0 08 ret <== NOT EXECUTED
40012f14: 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);
40012f18: b5 2e a0 10 sll %i2, 0x10, %i2
40012f1c: b4 16 80 19 or %i2, %i1, %i2
40012f20: 85 36 a0 18 srl %i2, 0x18, %g2
40012f24: c4 28 60 04 stb %g2, [ %g1 + 4 ]
40012f28: c2 07 bf e4 ld [ %fp + -28 ], %g1
40012f2c: 85 36 a0 10 srl %i2, 0x10, %g2
40012f30: c4 28 60 05 stb %g2, [ %g1 + 5 ]
40012f34: c2 07 bf e4 ld [ %fp + -28 ], %g1
40012f38: b5 36 a0 08 srl %i2, 8, %i2
40012f3c: f4 28 60 06 stb %i2, [ %g1 + 6 ]
40012f40: 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);
40012f44: 90 10 00 1d mov %i5, %o0
40012f48: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012f4c: 82 10 20 01 mov 1, %g1
40012f50: 92 07 bf d8 add %fp, -40, %o1
40012f54: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40012f58: 7f ff fd 15 call 400123ac <rtems_rfs_inode_close>
40012f5c: b0 10 20 00 clr %i0
if (rc)
40012f60: 80 a2 20 00 cmp %o0, 0
40012f64: 02 80 00 05 be 40012f78 <rtems_rfs_rtems_chown+0x100> <== ALWAYS TAKEN
40012f68: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
40012f6c: 40 00 38 94 call 400211bc <__errno> <== NOT EXECUTED
40012f70: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012f74: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012f78: 81 c7 e0 08 ret
40012f7c: 81 e8 00 00 restore
4001f75c <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);
4001f75c: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
4001f760: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
4001f764: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001f768: 40 00 03 4d call 4002049c <rtems_deviceio_close> <== NOT EXECUTED
4001f76c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001f718 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
4001f718: 81 c3 e0 08 retl <== NOT EXECUTED
4001f71c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f720 <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);
4001f720: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
4001f724: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4001f728: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001f72c: 40 00 03 9c call 4002059c <rtems_deviceio_control> <== NOT EXECUTED
4001f730: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001f7c4 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
4001f7c4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001f7c8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
4001f7cc: 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);
4001f7d0: 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);
4001f7d4: 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
};
4001f7d8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
4001f7dc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001f7e0: 7f ff b6 56 call 4000d138 <rtems_semaphore_obtain> <== NOT EXECUTED
4001f7e4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4001f7e8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001f7ec: 02 80 00 0f be 4001f828 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
4001f7f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001f7f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f7f8: 7f ff d1 04 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f7fc: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001f800: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f804: 22 80 00 09 be,a 4001f828 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
4001f808: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001f80c: 7f ff de 45 call 40017120 <rtems_status_text> <== NOT EXECUTED
4001f810: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001f814: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001f818: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
4001f81c: 40 00 0b c1 call 40022720 <printf> <== NOT EXECUTED
4001f820: 90 12 23 68 or %o0, 0x368, %o0 ! 40034768 <_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);
4001f824: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f828: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001f82c: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
4001f830: 7f ff ca 6d call 400121e4 <rtems_rfs_inode_open> <== NOT EXECUTED
4001f834: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
4001f838: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001f83c: 04 80 00 09 ble 4001f860 <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
4001f840: 92 10 20 00 clr %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4001f844: 7f ff ff cb call 4001f770 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001f848: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
4001f84c: 40 00 06 5c call 400211bc <__errno> <== NOT EXECUTED
4001f850: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001f854: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001f858: 81 c7 e0 08 ret <== NOT EXECUTED
4001f85c: 81 e8 00 00 restore <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
4001f860: 7f ff ff 9e call 4001f6d8 <rtems_rfs_inode_get_block> <== NOT EXECUTED
4001f864: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
4001f868: 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);
4001f86c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
4001f870: 7f ff ff 9a call 4001f6d8 <rtems_rfs_inode_get_block> <== NOT EXECUTED
4001f874: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4001f878: 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);
4001f87c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4001f880: 7f ff ca cb call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001f884: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f888: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
if (rc > 0)
4001f88c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4001f890: 04 80 00 09 ble 4001f8b4 <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
4001f894: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4001f898: 7f ff ff b6 call 4001f770 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001f89c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
4001f8a0: 40 00 06 47 call 400211bc <__errno> <== NOT EXECUTED
4001f8a4: 01 00 00 00 nop <== NOT EXECUTED
4001f8a8: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
4001f8ac: 81 c7 e0 08 ret <== NOT EXECUTED
4001f8b0: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4001f8b4: 7f ff ff af call 4001f770 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001f8b8: 01 00 00 00 nop <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
4001f8bc: 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;
4001f8c0: f8 26 20 2c st %i4, [ %i0 + 0x2c ] <== NOT EXECUTED
iop->data1 = (void *) minor;
4001f8c4: e0 26 20 30 st %l0, [ %i0 + 0x30 ] <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
4001f8c8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001f8cc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001f8d0: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001f8d4: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
4001f8d8: 40 00 02 e4 call 40020468 <rtems_deviceio_open> <== NOT EXECUTED
4001f8dc: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
4001f8e0: 81 c7 e0 08 ret <== NOT EXECUTED
4001f8e4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4001f748 <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);
4001f748: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
4001f74c: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4001f750: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001f754: 40 00 03 5e call 400204cc <rtems_deviceio_read> <== NOT EXECUTED
4001f758: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001f734 <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);
4001f734: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
4001f738: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4001f73c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001f740: 40 00 03 7d call 40020534 <rtems_deviceio_write> <== NOT EXECUTED
4001f744: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001fa94 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
4001fa94: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001fa98: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
4001fa9c: 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);
4001faa0: 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
};
4001faa4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
4001faa8: 7f ff ff 92 call 4001f8f0 <rtems_rfs_mutex_lock.isra.0>
4001faac: 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);
4001fab0: 92 10 00 1c mov %i4, %o1
4001fab4: 90 10 00 1d mov %i5, %o0
4001fab8: 94 07 bf d8 add %fp, -40, %o2
4001fabc: 7f ff c9 ca call 400121e4 <rtems_rfs_inode_open>
4001fac0: 96 10 20 01 mov 1, %o3
if (rc)
4001fac4: b8 92 20 00 orcc %o0, 0, %i4
4001fac8: 02 80 00 09 be 4001faec <rtems_rfs_rtems_dir_open+0x58> <== ALWAYS TAKEN
4001facc: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_rfs_rtems_unlock (fs);
4001fad0: 7f ff ff a0 call 4001f950 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001fad4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
4001fad8: 40 00 05 b9 call 400211bc <__errno> <== NOT EXECUTED
4001fadc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001fae0: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001fae4: 81 c7 e0 08 ret <== NOT EXECUTED
4001fae8: 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);
4001faec: c4 08 60 02 ldub [ %g1 + 2 ], %g2
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
4001faf0: 03 00 00 3c sethi %hi(0xf000), %g1
4001faf4: 85 28 a0 08 sll %g2, 8, %g2
4001faf8: 84 08 80 01 and %g2, %g1, %g2
4001fafc: 03 00 00 10 sethi %hi(0x4000), %g1
4001fb00: 80 a0 80 01 cmp %g2, %g1
4001fb04: 02 80 00 0c be 4001fb34 <rtems_rfs_rtems_dir_open+0xa0> <== ALWAYS TAKEN
4001fb08: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &inode);
4001fb0c: 7f ff ca 28 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001fb10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4001fb14: 7f ff ff 8f call 4001f950 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001fb18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
4001fb1c: 40 00 05 a8 call 400211bc <__errno> <== NOT EXECUTED
4001fb20: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001fb24: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
4001fb28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001fb2c: 81 c7 e0 08 ret <== NOT EXECUTED
4001fb30: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
4001fb34: c0 26 20 08 clr [ %i0 + 8 ]
4001fb38: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_rfs_inode_close (fs, &inode);
4001fb3c: 7f ff ca 1c call 400123ac <rtems_rfs_inode_close>
4001fb40: 90 10 00 1d mov %i5, %o0
rtems_rfs_rtems_unlock (fs);
4001fb44: 90 10 00 1d mov %i5, %o0
4001fb48: 7f ff ff 82 call 4001f950 <rtems_rfs_rtems_unlock>
4001fb4c: b0 10 20 00 clr %i0
return 0;
}
4001fb50: 81 c7 e0 08 ret
4001fb54: 81 e8 00 00 restore
4001f9a4 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
4001f9a4: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001f9a8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
4001f9ac: 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);
4001f9b0: 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);
4001f9b4: 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
};
4001f9b8: 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);
4001f9bc: 7f ff ff cd call 4001f8f0 <rtems_rfs_mutex_lock.isra.0>
4001f9c0: 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);
4001f9c4: 92 10 00 1c mov %i4, %o1
4001f9c8: 90 10 00 1d mov %i5, %o0
4001f9cc: 94 10 00 10 mov %l0, %o2
4001f9d0: 7f ff ca 05 call 400121e4 <rtems_rfs_inode_open>
4001f9d4: 96 10 20 01 mov 1, %o3
if (rc)
4001f9d8: b8 92 20 00 orcc %o0, 0, %i4
4001f9dc: 02 80 00 1f be 4001fa58 <rtems_rfs_rtems_dir_read+0xb4> <== ALWAYS TAKEN
4001f9e0: 90 10 00 1a mov %i2, %o0
{
rtems_rfs_rtems_unlock (fs);
4001f9e4: 7f ff ff db call 4001f950 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001f9e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
4001f9ec: 40 00 05 f4 call 400211bc <__errno> <== NOT EXECUTED
4001f9f0: 01 00 00 00 nop <== NOT EXECUTED
4001f9f4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001f9f8: 10 80 00 25 b 4001fa8c <rtems_rfs_rtems_dir_read+0xe8> <== NOT EXECUTED
4001f9fc: 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);
4001fa00: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
4001fa04: 90 10 00 1d mov %i5, %o0
4001fa08: 92 10 00 10 mov %l0, %o1
4001fa0c: 7f ff f5 35 call 4001cee0 <rtems_rfs_dir_read>
4001fa10: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
4001fa14: 80 a2 20 02 cmp %o0, 2
4001fa18: 02 80 00 18 be 4001fa78 <rtems_rfs_rtems_dir_read+0xd4>
4001fa1c: b4 10 00 08 mov %o0, %i2
{
rc = 0;
break;
}
if (rc > 0)
4001fa20: 80 a2 20 00 cmp %o0, 0
4001fa24: 24 80 00 06 ble,a 4001fa3c <rtems_rfs_rtems_dir_read+0x98><== ALWAYS TAKEN
4001fa28: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
4001fa2c: 40 00 05 e4 call 400211bc <__errno> <== NOT EXECUTED
4001fa30: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
4001fa34: 10 80 00 11 b 4001fa78 <rtems_rfs_rtems_dir_read+0xd4> <== NOT EXECUTED
4001fa38: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
break;
}
iop->offset += size;
4001fa3c: 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,
4001fa40: 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;
4001fa44: 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++)
4001fa48: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
4001fa4c: 84 40 a0 00 addx %g2, 0, %g2
4001fa50: 10 80 00 07 b 4001fa6c <rtems_rfs_rtems_dir_read+0xc8>
4001fa54: c4 3e 20 08 std %g2, [ %i0 + 8 ]
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
4001fa58: 92 10 21 18 mov 0x118, %o1
4001fa5c: 7f ff 8b 08 call 4000267c <.udiv>
4001fa60: 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,
4001fa64: b8 10 20 00 clr %i4
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
4001fa68: 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++)
4001fa6c: 80 a6 c0 11 cmp %i3, %l1
4001fa70: 12 bf ff e4 bne 4001fa00 <rtems_rfs_rtems_dir_read+0x5c>
4001fa74: 98 06 40 1c add %i1, %i4, %o4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
4001fa78: 90 10 00 1d mov %i5, %o0
4001fa7c: 7f ff ca 4c call 400123ac <rtems_rfs_inode_close>
4001fa80: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_rtems_unlock (fs);
4001fa84: 7f ff ff b3 call 4001f950 <rtems_rfs_rtems_unlock>
4001fa88: 90 10 00 1d mov %i5, %o0
return bytes_transferred;
}
4001fa8c: 81 c7 e0 08 ret
4001fa90: 91 e8 00 1c restore %g0, %i4, %o0
400130d0 <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)
{
400130d0: 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);
400130d4: 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);
400130d8: 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);
400130dc: 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);
400130e0: 94 07 bf d8 add %fp, -40, %o2
400130e4: 90 10 00 1d mov %i5, %o0
400130e8: 7f ff fc 3f call 400121e4 <rtems_rfs_inode_open>
400130ec: 96 10 20 01 mov 1, %o3
if (rc == 0) {
400130f0: b8 92 20 00 orcc %o0, 0, %i4
400130f4: 12 80 00 10 bne 40013134 <rtems_rfs_rtems_eval_path+0x64> <== NEVER TAKEN
400130f8: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_generic (
400130fc: 92 07 bf d8 add %fp, -40, %o1
40013100: 15 10 00 d2 sethi %hi(0x40034800), %o2
40013104: 40 00 12 03 call 40017910 <rtems_filesystem_eval_path_generic>
40013108: 94 12 a0 50 or %o2, 0x50, %o2 ! 40034850 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
4001310c: 90 10 00 1d mov %i5, %o0
40013110: 7f ff fc a7 call 400123ac <rtems_rfs_inode_close>
40013114: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
40013118: ba 92 20 00 orcc %o0, 0, %i5
4001311c: 02 80 00 0c be 4001314c <rtems_rfs_rtems_eval_path+0x7c> <== ALWAYS TAKEN
40013120: 01 00 00 00 nop
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
40013124: 40 00 38 26 call 400211bc <__errno> <== NOT EXECUTED
40013128: 01 00 00 00 nop <== NOT EXECUTED
4001312c: 10 80 00 05 b 40013140 <rtems_rfs_rtems_eval_path+0x70> <== NOT EXECUTED
40013130: 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)
40013134: 40 00 38 22 call 400211bc <__errno> <== NOT EXECUTED
40013138: 01 00 00 00 nop <== NOT EXECUTED
4001313c: 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 (
40013140: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013144: 7f ff db 1f call 40009dc0 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013148: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
4001314c: 81 c7 e0 08 ret
40013150: 81 e8 00 00 restore
40013528 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40013528: 9d e3 bf 90 save %sp, -112, %sp
4001352c: f8 06 60 0c ld [ %i1 + 0xc ], %i4
40013530: 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;
40013534: c2 0f 20 07 ldub [ %i4 + 7 ], %g1
40013538: 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(
4001353c: 90 10 00 19 mov %i1, %o0
40013540: b1 2e 20 08 sll %i0, 8, %i0
40013544: 7f ff fd 5a call 40012aac <rtems_rfs_inode_get_gid>
40013548: 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);
4001354c: c2 0f 20 02 ldub [ %i4 + 2 ], %g1
40013550: d4 0f 20 03 ldub [ %i4 + 3 ], %o2
40013554: 83 28 60 08 sll %g1, 8, %g1
40013558: 97 2e 20 10 sll %i0, 0x10, %o3
4001355c: 99 2a 20 10 sll %o0, 0x10, %o4
40013560: 92 10 20 01 mov 1, %o1
40013564: 90 10 00 1d mov %i5, %o0
40013568: 94 12 80 01 or %o2, %g1, %o2
4001356c: 97 32 e0 10 srl %o3, 0x10, %o3
40013570: 99 33 20 10 srl %o4, 0x10, %o4
40013574: 40 00 10 d9 call 400178d8 <rtems_filesystem_eval_path_check_access>
40013578: 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) {
4001357c: 80 8a 20 ff btst 0xff, %o0
40013580: 02 80 00 71 be 40013744 <rtems_rfs_rtems_eval_token+0x21c>
40013584: 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] == '.';
40013588: 12 80 00 06 bne 400135a0 <rtems_rfs_rtems_eval_token+0x78>
4001358c: 82 10 20 00 clr %g1
40013590: c2 4e 80 00 ldsb [ %i2 ], %g1
40013594: 82 18 60 2e xor %g1, 0x2e, %g1
40013598: 80 a0 00 01 cmp %g0, %g1
4001359c: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
400135a0: 80 a0 60 00 cmp %g1, 0
400135a4: 22 80 00 04 be,a 400135b4 <rtems_rfs_rtems_eval_token+0x8c>
400135a8: 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;
400135ac: 10 80 00 44 b 400136bc <rtems_rfs_rtems_eval_token+0x194>
400135b0: 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 (
400135b4: 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);
400135b8: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
400135bc: 94 10 00 1a mov %i2, %o2
400135c0: 90 10 00 1c mov %i4, %o0
400135c4: 96 10 00 1b mov %i3, %o3
400135c8: 98 07 bf f4 add %fp, -12, %o4
400135cc: 9a 07 bf f8 add %fp, -8, %o5
400135d0: 40 00 23 25 call 4001c264 <rtems_rfs_dir_lookup_ino>
400135d4: b0 10 20 02 mov 2, %i0
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
400135d8: 80 a2 20 00 cmp %o0, 0
400135dc: 12 80 00 5a bne 40013744 <rtems_rfs_rtems_eval_token+0x21c>
400135e0: 90 10 00 1c mov %i4, %o0
rc = rtems_rfs_inode_close (fs, inode);
400135e4: 7f ff fb 72 call 400123ac <rtems_rfs_inode_close>
400135e8: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
400135ec: 80 a2 20 00 cmp %o0, 0
400135f0: 02 80 00 07 be 4001360c <rtems_rfs_rtems_eval_token+0xe4> <== ALWAYS TAKEN
400135f4: 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));
400135f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400135fc: 40 00 3b cb call 40022528 <memset> <== NOT EXECUTED
40013600: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40013604: 81 c7 e0 08 ret <== NOT EXECUTED
40013608: 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);
4001360c: d2 07 bf f4 ld [ %fp + -12 ], %o1
40013610: 90 10 00 1c mov %i4, %o0
40013614: 94 10 00 19 mov %i1, %o2
40013618: 7f ff fa f3 call 400121e4 <rtems_rfs_inode_open>
4001361c: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
40013620: 80 a2 20 00 cmp %o0, 0
40013624: 02 80 00 2f be 400136e0 <rtems_rfs_rtems_eval_token+0x1b8><== ALWAYS TAKEN
40013628: 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));
4001362c: 10 bf ff f4 b 400135fc <rtems_rfs_rtems_eval_token+0xd4> <== NOT EXECUTED
40013630: 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)) {
40013634: 02 80 00 04 be 40013644 <rtems_rfs_rtems_eval_token+0x11c>
40013638: 80 88 a0 ff btst 0xff, %g2
4001363c: 02 80 00 23 be 400136c8 <rtems_rfs_rtems_eval_token+0x1a0>
40013640: 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;
40013644: 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);
40013648: 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;
4001364c: c2 27 bf fc st %g1, [ %fp + -4 ]
char *link = malloc(len + 1);
40013650: 7f ff d5 e4 call 40008de0 <malloc>
40013654: 90 10 24 01 mov 0x401, %o0
if (link != NULL) {
40013658: b6 92 20 00 orcc %o0, 0, %i3
4001365c: 02 80 00 14 be 400136ac <rtems_rfs_rtems_eval_token+0x184><== NEVER TAKEN
40013660: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
40013664: 92 10 00 1a mov %i2, %o1
40013668: 94 10 00 1b mov %i3, %o2
4001366c: 96 10 24 00 mov 0x400, %o3
40013670: 40 00 2f 78 call 4001f450 <rtems_rfs_symlink_read>
40013674: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
40013678: 80 a2 20 00 cmp %o0, 0
4001367c: 12 80 00 06 bne 40013694 <rtems_rfs_rtems_eval_token+0x16c><== NEVER TAKEN
40013680: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
40013684: d4 07 bf fc ld [ %fp + -4 ], %o2
40013688: 7f ff da cc call 4000a1b8 <rtems_filesystem_eval_path_recursive>
4001368c: 92 10 00 1b mov %i3, %o1
40013690: 30 80 00 03 b,a 4001369c <rtems_rfs_rtems_eval_token+0x174>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
40013694: 7f ff d9 cb call 40009dc0 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013698: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
free(link);
4001369c: 7f ff d4 40 call 4000879c <free>
400136a0: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
400136a4: 81 c7 e0 08 ret
400136a8: 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);
400136ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400136b0: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
400136b4: 7f ff d9 c3 call 40009dc0 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400136b8: 01 00 00 00 nop <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
400136bc: 81 c7 e0 08 ret
400136c0: 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;
400136c4: 90 07 60 18 add %i5, 0x18, %o0
400136c8: 40 00 01 1d call 40013b3c <rtems_rfs_rtems_set_handlers>
400136cc: 92 10 00 19 mov %i1, %o1
400136d0: 80 8a 20 ff btst 0xff, %o0
400136d4: 12 80 00 18 bne 40013734 <rtems_rfs_rtems_eval_token+0x20c><== ALWAYS TAKEN
400136d8: c2 07 bf f4 ld [ %fp + -12 ], %g1
400136dc: 30 80 00 0f b,a 40013718 <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)
400136e0: 7f ff ff 53 call 4001342c <rtems_rfs_rtems_node_type_by_inode>
400136e4: 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);
400136e8: 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;
400136ec: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
400136f0: 80 a0 00 01 cmp %g0, %g1
400136f4: c0 27 60 0c clr [ %i5 + 0xc ]
400136f8: 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;
400136fc: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40013700: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
40013704: 80 a2 20 03 cmp %o0, 3
40013708: 12 bf ff ef bne 400136c4 <rtems_rfs_rtems_eval_token+0x19c>
4001370c: 84 08 a0 01 and %g2, 1, %g2
40013710: 10 bf ff c9 b 40013634 <rtems_rfs_rtems_eval_token+0x10c>
40013714: 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)
40013718: 40 00 36 a9 call 400211bc <__errno> <== NOT EXECUTED
4001371c: 01 00 00 00 nop <== NOT EXECUTED
40013720: 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 (
40013724: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
40013728: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
4001372c: 10 bf ff e2 b 400136b4 <rtems_rfs_rtems_eval_token+0x18c> <== NOT EXECUTED
40013730: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40013734: 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);
40013738: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
4001373c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40013740: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
40013744: 81 c7 e0 08 ret
40013748: 81 e8 00 00 restore
400139ec <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
400139ec: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400139f0: 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);
400139f4: 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);
400139f8: 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);
400139fc: 94 07 bf d8 add %fp, -40, %o2
40013a00: 90 10 00 1d mov %i5, %o0
40013a04: 7f ff f9 f8 call 400121e4 <rtems_rfs_inode_open>
40013a08: 96 10 20 01 mov 1, %o3
if (rc)
40013a0c: b8 92 20 00 orcc %o0, 0, %i4
40013a10: 02 80 00 07 be 40013a2c <rtems_rfs_rtems_fchmod+0x40> <== ALWAYS TAKEN
40013a14: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
40013a18: 40 00 35 e9 call 400211bc <__errno> <== NOT EXECUTED
40013a1c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013a20: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40013a24: 81 c7 e0 08 ret <== NOT EXECUTED
40013a28: 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);
40013a2c: f8 08 60 02 ldub [ %g1 + 2 ], %i4
40013a30: c2 08 60 03 ldub [ %g1 + 3 ], %g1
40013a34: 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();
40013a38: 40 00 0e 91 call 4001747c <geteuid>
40013a3c: 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;
40013a40: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
40013a44: 91 2a 20 10 sll %o0, 0x10, %o0
40013a48: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40013a4c: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40013a50: 85 28 a0 08 sll %g2, 8, %g2
40013a54: 84 10 80 03 or %g2, %g3, %g2
40013a58: 85 28 a0 10 sll %g2, 0x10, %g2
40013a5c: 80 a0 80 08 cmp %g2, %o0
40013a60: 02 80 00 0e be 40013a98 <rtems_rfs_rtems_fchmod+0xac> <== ALWAYS TAKEN
40013a64: 87 32 20 10 srl %o0, 0x10, %g3
40013a68: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40013a6c: 22 80 00 0c be,a 40013a9c <rtems_rfs_rtems_fchmod+0xb0> <== NOT EXECUTED
40013a70: b8 0f 30 00 and %i4, -4096, %i4 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
40013a74: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013a78: 7f ff fa 4d call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
40013a7c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
40013a80: 40 00 35 cf call 400211bc <__errno> <== NOT EXECUTED
40013a84: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013a88: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40013a8c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013a90: 81 c7 e0 08 ret <== NOT EXECUTED
40013a94: 81 e8 00 00 restore <== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40013a98: b8 0f 30 00 and %i4, -4096, %i4
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40013a9c: b2 0e 6f ff and %i1, 0xfff, %i1
40013aa0: 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);
40013aa4: 85 36 60 08 srl %i1, 8, %g2
40013aa8: c4 28 60 02 stb %g2, [ %g1 + 2 ]
40013aac: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
40013ab0: 90 10 00 1d mov %i5, %o0
40013ab4: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013ab8: 82 10 20 01 mov 1, %g1
40013abc: 92 07 bf d8 add %fp, -40, %o1
40013ac0: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40013ac4: 7f ff fa 3a call 400123ac <rtems_rfs_inode_close>
40013ac8: b0 10 20 00 clr %i0
if (rc > 0)
40013acc: 80 a2 20 00 cmp %o0, 0
40013ad0: 04 80 00 05 ble 40013ae4 <rtems_rfs_rtems_fchmod+0xf8> <== ALWAYS TAKEN
40013ad4: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
40013ad8: 40 00 35 b9 call 400211bc <__errno> <== NOT EXECUTED
40013adc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013ae0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40013ae4: 81 c7 e0 08 ret
40013ae8: 81 e8 00 00 restore
40013b08 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
40013b08: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40013b0c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
40013b10: 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));
40013b14: 40 00 21 19 call 4001bf78 <rtems_rfs_buffer_sync> <== NOT EXECUTED
40013b18: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
40013b1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013b20: 02 80 00 05 be 40013b34 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
40013b24: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
40013b28: 40 00 35 a5 call 400211bc <__errno> <== NOT EXECUTED
40013b2c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013b30: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
40013b34: 81 c7 e0 08 ret <== NOT EXECUTED
40013b38: 81 e8 00 00 restore <== NOT EXECUTED
4001fec8 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
4001fec8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001fecc: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
4001fed0: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
4001fed4: 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);
4001fed8: 7f ff ff 20 call 4001fb58 <rtems_rfs_rtems_lock>
4001fedc: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_file_close (fs, file);
4001fee0: 90 10 00 1d mov %i5, %o0
4001fee4: 7f ff f5 7a call 4001d4cc <rtems_rfs_file_close>
4001fee8: 92 10 00 1c mov %i4, %o1
if (rc > 0)
4001feec: b0 92 20 00 orcc %o0, 0, %i0
4001fef0: 04 80 00 06 ble 4001ff08 <rtems_rfs_rtems_file_close+0x40><== ALWAYS TAKEN
4001fef4: 01 00 00 00 nop
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
4001fef8: 40 00 04 b1 call 400211bc <__errno> <== NOT EXECUTED
4001fefc: 01 00 00 00 nop <== NOT EXECUTED
4001ff00: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
4001ff04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4001ff08: 7f ff ff 29 call 4001fbac <rtems_rfs_rtems_unlock>
4001ff0c: 90 10 00 1d mov %i5, %o0
return rc;
}
4001ff10: 81 c7 e0 08 ret
4001ff14: 81 e8 00 00 restore
4001fc00 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
4001fc00: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001fc04: 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));
4001fc08: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4001fc0c: 7f ff ff d3 call 4001fb58 <rtems_rfs_rtems_lock>
4001fc10: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rc = rtems_rfs_file_set_size (file, length);
4001fc14: 90 10 00 1b mov %i3, %o0
4001fc18: 92 10 00 19 mov %i1, %o1
4001fc1c: 7f ff f8 4c call 4001dd4c <rtems_rfs_file_set_size>
4001fc20: 94 10 00 1a mov %i2, %o2
if (rc)
4001fc24: b0 92 20 00 orcc %o0, 0, %i0
4001fc28: 22 80 00 07 be,a 4001fc44 <rtems_rfs_rtems_file_ftruncate+0x44><== ALWAYS TAKEN
4001fc2c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
4001fc30: 40 00 05 63 call 400211bc <__errno> <== NOT EXECUTED
4001fc34: 01 00 00 00 nop <== NOT EXECUTED
4001fc38: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
4001fc3c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001fc40: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
4001fc44: 7f ff ff da call 4001fbac <rtems_rfs_rtems_unlock>
4001fc48: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return rc;
}
4001fc4c: 81 c7 e0 08 ret
4001fc50: 81 e8 00 00 restore
4001fc54 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
4001fc54: 9d e3 bf 98 save %sp, -104, %sp
4001fc58: b8 10 00 19 mov %i1, %i4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001fc5c: 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)
{
4001fc60: 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));
4001fc64: 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)
{
4001fc68: 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));
4001fc6c: 7f ff ff bb call 4001fb58 <rtems_rfs_rtems_lock>
4001fc70: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
4001fc74: 92 10 00 1c mov %i4, %o1
4001fc78: 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;
4001fc7c: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
4001fc80: 90 10 00 18 mov %i0, %o0
4001fc84: 40 00 01 26 call 4002011c <rtems_filesystem_default_lseek_file>
4001fc88: 96 10 00 10 mov %l0, %o3
4001fc8c: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
4001fc90: 80 a7 3f ff cmp %i4, -1
4001fc94: 12 80 00 05 bne 4001fca8 <rtems_rfs_rtems_file_lseek+0x54>
4001fc98: ba 10 00 09 mov %o1, %i5
4001fc9c: 80 a2 7f ff cmp %o1, -1
4001fca0: 22 80 00 13 be,a 4001fcec <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
4001fca4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
4001fca8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
4001fcac: 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;
4001fcb0: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
4001fcb4: 92 10 00 02 mov %g2, %o1
4001fcb8: 94 10 00 03 mov %g3, %o2
4001fcbc: 7f ff f7 e6 call 4001dc54 <rtems_rfs_file_seek>
4001fcc0: 96 07 bf f8 add %fp, -8, %o3
if (rc)
4001fcc4: a0 92 20 00 orcc %o0, 0, %l0
4001fcc8: 22 80 00 09 be,a 4001fcec <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
4001fccc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
4001fcd0: 40 00 05 3b call 400211bc <__errno> <== NOT EXECUTED
4001fcd4: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
4001fcd8: e0 22 00 00 st %l0, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
4001fcdc: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
new_offset = -1;
4001fce0: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
4001fce4: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001fce8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
return new_offset;
}
4001fcec: b0 10 00 1c mov %i4, %i0
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001fcf0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001fcf4: 7f ff ff ae call 4001fbac <rtems_rfs_rtems_unlock>
4001fcf8: b2 10 00 1d mov %i5, %i1
return new_offset;
}
4001fcfc: 81 c7 e0 08 ret
4001fd00: 81 e8 00 00 restore
4001ff18 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
4001ff18: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
4001ff1c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4001ff20: 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);
4001ff24: 7f ff ff 0d call 4001fb58 <rtems_rfs_rtems_lock>
4001ff28: 90 10 00 1d mov %i5, %o0
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
4001ff2c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
4001ff30: 90 10 00 1d mov %i5, %o0
4001ff34: 94 10 20 00 clr %o2
4001ff38: 7f ff f8 5d call 4001e0ac <rtems_rfs_file_open>
4001ff3c: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
4001ff40: b8 92 20 00 orcc %o0, 0, %i4
4001ff44: 04 80 00 09 ble 4001ff68 <rtems_rfs_rtems_file_open+0x50> <== ALWAYS TAKEN
4001ff48: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rtems_rfs_rtems_unlock (fs);
4001ff4c: 7f ff ff 18 call 4001fbac <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001ff50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
4001ff54: 40 00 04 9a call 400211bc <__errno> <== NOT EXECUTED
4001ff58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001ff5c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
4001ff60: 81 c7 e0 08 ret <== NOT EXECUTED
4001ff64: 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);
4001ff68: 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);
4001ff6c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_rfs_rtems_unlock (fs);
4001ff70: 7f ff ff 0f call 4001fbac <rtems_rfs_rtems_unlock>
4001ff74: b0 10 20 00 clr %i0
return 0;
}
4001ff78: 81 c7 e0 08 ret
4001ff7c: 81 e8 00 00 restore
4001ff80 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
4001ff80: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001ff84: 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)
{
4001ff88: 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));
4001ff8c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001ff90: 7f ff fe f2 call 4001fb58 <rtems_rfs_rtems_lock>
4001ff94: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
4001ff98: 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;
4001ff9c: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
4001ffa0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ffa4: 7f ff ea ec call 4001ab54 <rtems_rfs_block_get_size>
4001ffa8: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
4001ffac: 80 a2 00 1c cmp %o0, %i4
4001ffb0: 38 80 00 2b bgu,a 4002005c <rtems_rfs_rtems_file_read+0xdc><== NEVER TAKEN
4001ffb4: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001ffb8: 80 a2 00 1c cmp %o0, %i4
4001ffbc: 12 80 00 2e bne 40020074 <rtems_rfs_rtems_file_read+0xf4> <== NEVER TAKEN
4001ffc0: b0 10 20 00 clr %i0
4001ffc4: 80 a2 40 1d cmp %o1, %i5
4001ffc8: 18 80 00 25 bgu 4002005c <rtems_rfs_rtems_file_read+0xdc>
4001ffcc: 01 00 00 00 nop
}
}
}
if (read >= 0)
iop->offset = pos + read;
4001ffd0: 10 80 00 2a b 40020078 <rtems_rfs_rtems_file_read+0xf8>
4001ffd4: b6 86 00 1d addcc %i0, %i5, %i3
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
4001ffd8: 92 07 bf fc add %fp, -4, %o1
4001ffdc: 7f ff f5 e8 call 4001d77c <rtems_rfs_file_io_start>
4001ffe0: 94 10 20 01 mov 1, %o2
if (rc > 0)
4001ffe4: b6 92 20 00 orcc %o0, 0, %i3
4001ffe8: 14 80 00 19 bg 4002004c <rtems_rfs_rtems_file_read+0xcc> <== NEVER TAKEN
4001ffec: c2 07 bf fc ld [ %fp + -4 ], %g1
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
4001fff0: 80 a0 60 00 cmp %g1, 0
4001fff4: 02 80 00 1d be 40020068 <rtems_rfs_rtems_file_read+0xe8>
4001fff8: 80 a0 40 1a cmp %g1, %i2
break;
if (size > count)
4001fffc: 38 80 00 02 bgu,a 40020004 <rtems_rfs_rtems_file_read+0x84>
40020000: f4 27 bf fc st %i2, [ %fp + -4 ]
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
40020004: c2 04 20 0c ld [ %l0 + 0xc ], %g1
40020008: f6 07 bf fc ld [ %fp + -4 ], %i3
4002000c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
40020010: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
40020014: 94 10 00 1b mov %i3, %o2
40020018: 92 02 40 01 add %o1, %g1, %o1
4002001c: 40 00 08 b4 call 400222ec <memcpy>
40020020: 90 10 00 19 mov %i1, %o0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
40020024: 92 10 00 1b mov %i3, %o1
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
40020028: b2 06 40 1b add %i1, %i3, %i1
count -= size;
4002002c: b4 26 80 1b sub %i2, %i3, %i2
read += size;
40020030: b0 06 00 1b add %i0, %i3, %i0
rc = rtems_rfs_file_io_end (file, size, true);
40020034: 90 10 00 10 mov %l0, %o0
40020038: 7f ff f6 5a call 4001d9a0 <rtems_rfs_file_io_end>
4002003c: 94 10 20 01 mov 1, %o2
if (rc > 0)
40020040: b6 92 20 00 orcc %o0, 0, %i3
40020044: 04 80 00 07 ble 40020060 <rtems_rfs_rtems_file_read+0xe0> <== ALWAYS TAKEN
40020048: 80 a6 a0 00 cmp %i2, 0
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
4002004c: 40 00 04 5c call 400211bc <__errno> <== NOT EXECUTED
40020050: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020054: 10 80 00 0c b 40020084 <rtems_rfs_rtems_file_read+0x104> <== NOT EXECUTED
40020058: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
4002005c: 80 a6 a0 00 cmp %i2, 0
40020060: 12 bf ff de bne 4001ffd8 <rtems_rfs_rtems_file_read+0x58>
40020064: 90 10 00 10 mov %l0, %o0
break;
}
}
}
if (read >= 0)
40020068: 80 a6 20 00 cmp %i0, 0
4002006c: 26 80 00 07 bl,a 40020088 <rtems_rfs_rtems_file_read+0x108><== NEVER TAKEN
40020070: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
iop->offset = pos + read;
40020074: b6 86 00 1d addcc %i0, %i5, %i3
40020078: 85 3e 20 1f sra %i0, 0x1f, %g2
4002007c: b4 40 80 1c addx %g2, %i4, %i2
40020080: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40020084: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40020088: 7f ff fe c9 call 4001fbac <rtems_rfs_rtems_unlock>
4002008c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return read;
}
40020090: 81 c7 e0 08 ret
40020094: 81 e8 00 00 restore
4001fd04 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
4001fd04: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
4001fd08: 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)
{
4001fd0c: 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));
4001fd10: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001fd14: 7f ff ff 91 call 4001fb58 <rtems_rfs_rtems_lock>
4001fd18: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
4001fd1c: 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;
4001fd20: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4001fd24: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001fd28: c4 3f bf f8 std %g2, [ %fp + -8 ]
4001fd2c: 7f ff eb 8a call 4001ab54 <rtems_rfs_block_get_size>
4001fd30: 92 02 60 84 add %o1, 0x84, %o1
4001fd34: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
4001fd38: d2 07 bf f8 ld [ %fp + -8 ], %o1
4001fd3c: 82 10 00 08 mov %o0, %g1
4001fd40: 80 a2 40 01 cmp %o1, %g1
4001fd44: 18 80 00 08 bgu 4001fd64 <rtems_rfs_rtems_file_write+0x60><== NEVER TAKEN
4001fd48: d4 07 bf fc ld [ %fp + -4 ], %o2
4001fd4c: 80 a2 40 01 cmp %o1, %g1
4001fd50: 12 80 00 11 bne 4001fd94 <rtems_rfs_rtems_file_write+0x90><== NEVER TAKEN
4001fd54: 80 a0 40 09 cmp %g1, %o1
4001fd58: 80 a2 80 03 cmp %o2, %g3
4001fd5c: 08 80 00 0e bleu 4001fd94 <rtems_rfs_rtems_file_write+0x90>
4001fd60: 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);
4001fd64: 7f ff f7 fa call 4001dd4c <rtems_rfs_file_set_size>
4001fd68: 90 10 00 10 mov %l0, %o0
4001fd6c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
if (rc)
4001fd70: ba 92 20 00 orcc %o0, 0, %i5
4001fd74: 12 80 00 20 bne 4001fdf4 <rtems_rfs_rtems_file_write+0xf0><== NEVER TAKEN
4001fd78: 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);
4001fd7c: d2 07 bf f8 ld [ %fp + -8 ], %o1
4001fd80: d4 07 bf fc ld [ %fp + -4 ], %o2
4001fd84: 7f ff eb 44 call 4001aa94 <rtems_rfs_block_get_bpos>
4001fd88: 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)
{
4001fd8c: 10 80 00 40 b 4001fe8c <rtems_rfs_rtems_file_write+0x188>
4001fd90: 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)
4001fd94: 38 80 00 09 bgu,a 4001fdb8 <rtems_rfs_rtems_file_write+0xb4><== NEVER TAKEN
4001fd98: c4 04 60 10 ld [ %l1 + 0x10 ], %g2 <== NOT EXECUTED
4001fd9c: 80 a0 40 09 cmp %g1, %o1
4001fda0: 12 80 00 3b bne 4001fe8c <rtems_rfs_rtems_file_write+0x188><== NEVER TAKEN
4001fda4: b0 10 20 00 clr %i0
4001fda8: 80 a0 c0 0a cmp %g3, %o2
4001fdac: 08 80 00 39 bleu 4001fe90 <rtems_rfs_rtems_file_write+0x18c>
4001fdb0: 80 a6 a0 00 cmp %i2, 0
4001fdb4: c4 04 60 10 ld [ %l1 + 0x10 ], %g2
4001fdb8: 80 88 a2 00 btst 0x200, %g2
4001fdbc: 22 80 00 34 be,a 4001fe8c <rtems_rfs_rtems_file_write+0x188>
4001fdc0: b0 10 20 00 clr %i0
{
pos = file_size;
4001fdc4: c2 27 bf f8 st %g1, [ %fp + -8 ]
4001fdc8: c6 27 bf fc st %g3, [ %fp + -4 ]
rc = rtems_rfs_file_seek (file, pos, &pos);
4001fdcc: 90 10 00 10 mov %l0, %o0
4001fdd0: 92 10 00 01 mov %g1, %o1
4001fdd4: 94 10 00 03 mov %g3, %o2
4001fdd8: 7f ff f7 9f call 4001dc54 <rtems_rfs_file_seek>
4001fddc: 96 07 bf f8 add %fp, -8, %o3
if (rc)
4001fde0: ba 92 20 00 orcc %o0, 0, %i5
4001fde4: 22 80 00 2a be,a 4001fe8c <rtems_rfs_rtems_file_write+0x188><== ALWAYS TAKEN
4001fde8: b0 10 20 00 clr %i0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001fdec: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
4001fdf0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001fdf4: 7f ff ff 6e call 4001fbac <rtems_rfs_rtems_unlock> <== NOT EXECUTED
4001fdf8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
4001fdfc: 40 00 04 f0 call 400211bc <__errno> <== NOT EXECUTED
4001fe00: 01 00 00 00 nop <== NOT EXECUTED
4001fe04: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
4001fe08: 81 c7 e0 08 ret <== NOT EXECUTED
4001fe0c: 81 e8 00 00 restore <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
4001fe10: 90 10 00 10 mov %l0, %o0
4001fe14: 92 07 bf f4 add %fp, -12, %o1
4001fe18: 7f ff f6 59 call 4001d77c <rtems_rfs_file_io_start>
4001fe1c: 94 10 20 00 clr %o2
if (rc)
4001fe20: ba 92 20 00 orcc %o0, 0, %i5
4001fe24: 12 80 00 16 bne 4001fe7c <rtems_rfs_rtems_file_write+0x178>
4001fe28: c2 07 bf f4 ld [ %fp + -12 ], %g1
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
4001fe2c: 80 a0 40 1a cmp %g1, %i2
4001fe30: 38 80 00 02 bgu,a 4001fe38 <rtems_rfs_rtems_file_write+0x134>
4001fe34: f4 27 bf f4 st %i2, [ %fp + -12 ]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
4001fe38: c2 04 20 0c ld [ %l0 + 0xc ], %g1
4001fe3c: d4 07 bf f4 ld [ %fp + -12 ], %o2
4001fe40: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001fe44: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
4001fe48: 92 10 00 19 mov %i1, %o1
4001fe4c: 40 00 09 28 call 400222ec <memcpy>
4001fe50: 90 02 00 01 add %o0, %g1, %o0
data += size;
4001fe54: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
4001fe58: 90 10 00 10 mov %l0, %o0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
4001fe5c: b2 06 40 09 add %i1, %o1, %i1
count -= size;
4001fe60: b4 26 80 09 sub %i2, %o1, %i2
write += size;
4001fe64: b0 06 00 09 add %i0, %o1, %i0
rc = rtems_rfs_file_io_end (file, size, false);
4001fe68: 7f ff f6 ce call 4001d9a0 <rtems_rfs_file_io_end>
4001fe6c: 94 10 20 00 clr %o2
if (rc)
4001fe70: ba 92 20 00 orcc %o0, 0, %i5
4001fe74: 02 80 00 07 be 4001fe90 <rtems_rfs_rtems_file_write+0x18c><== ALWAYS TAKEN
4001fe78: 80 a6 a0 00 cmp %i2, 0
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
4001fe7c: 40 00 04 d0 call 400211bc <__errno>
4001fe80: b0 10 3f ff mov -1, %i0
4001fe84: 10 80 00 0c b 4001feb4 <rtems_rfs_rtems_file_write+0x1b0>
4001fe88: 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)
4001fe8c: 80 a6 a0 00 cmp %i2, 0
4001fe90: 32 bf ff e0 bne,a 4001fe10 <rtems_rfs_rtems_file_write+0x10c>
4001fe94: f4 27 bf f4 st %i2, [ %fp + -12 ]
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
4001fe98: 80 a6 20 00 cmp %i0, 0
4001fe9c: 06 80 00 06 bl 4001feb4 <rtems_rfs_rtems_file_write+0x1b0><== NEVER TAKEN
4001fea0: f8 1f bf f8 ldd [ %fp + -8 ], %i4
iop->offset = pos + write;
4001fea4: 85 3e 20 1f sra %i0, 0x1f, %g2
4001fea8: b6 86 00 1d addcc %i0, %i5, %i3
4001feac: b4 40 80 1c addx %g2, %i4, %i2
4001feb0: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4001feb4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
4001feb8: 7f ff ff 3d call 4001fbac <rtems_rfs_rtems_unlock>
4001febc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return write;
}
4001fec0: 81 c7 e0 08 ret
4001fec4: 81 e8 00 00 restore
4001374c <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4001374c: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40013750: 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);
40013754: 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);
40013758: 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);
4001375c: 94 07 bf d8 add %fp, -40, %o2
40013760: 90 10 00 1d mov %i5, %o0
40013764: 7f ff fa a0 call 400121e4 <rtems_rfs_inode_open>
40013768: 96 10 20 01 mov 1, %o3
if (rc)
4001376c: b8 92 20 00 orcc %o0, 0, %i4
40013770: 02 80 00 07 be 4001378c <rtems_rfs_rtems_fstat+0x40> <== ALWAYS TAKEN
40013774: c4 07 bf e4 ld [ %fp + -28 ], %g2
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
40013778: 40 00 36 91 call 400211bc <__errno> <== NOT EXECUTED
4001377c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013780: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40013784: 81 c7 e0 08 ret <== NOT EXECUTED
40013788: 81 e8 00 00 restore <== NOT EXECUTED
4001378c: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
40013790: 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))
40013794: 05 3f ff ec sethi %hi(0xffffb000), %g2
40013798: 83 28 60 08 sll %g1, 8, %g1
4001379c: b8 10 40 1c or %g1, %i4, %i4
400137a0: 82 08 40 02 and %g1, %g2, %g1
400137a4: 05 00 00 08 sethi %hi(0x2000), %g2
400137a8: 80 a0 40 02 cmp %g1, %g2
400137ac: 32 80 00 0c bne,a 400137dc <rtems_rfs_rtems_fstat+0x90> <== ALWAYS TAKEN
400137b0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
400137b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
400137b8: 7f ff fc c5 call 40012acc <rtems_rfs_inode_get_block> <== NOT EXECUTED
400137bc: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
400137c0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
400137c4: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
400137c8: 7f ff fc c1 call 40012acc <rtems_rfs_inode_get_block> <== NOT EXECUTED
400137cc: 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 =
400137d0: f6 26 60 18 st %i3, [ %i1 + 0x18 ] <== NOT EXECUTED
400137d4: 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);
400137d8: 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);
400137dc: 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);
400137e0: c2 26 60 04 st %g1, [ %i1 + 4 ]
400137e4: 83 38 60 1f sra %g1, 0x1f, %g1
400137e8: c2 26 40 00 st %g1, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
400137ec: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_mode = rtems_rfs_rtems_mode (mode);
400137f0: 91 32 20 10 srl %o0, 0x10, %o0
400137f4: 40 00 01 03 call 40013c00 <rtems_rfs_rtems_mode>
400137f8: 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);
400137fc: c2 07 bf e4 ld [ %fp + -28 ], %g1
40013800: d0 26 60 0c st %o0, [ %i1 + 0xc ]
40013804: c6 08 60 01 ldub [ %g1 + 1 ], %g3
40013808: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
4001380c: 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);
40013810: 85 28 a0 08 sll %g2, 8, %g2
40013814: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
40013818: 87 28 a0 10 sll %g2, 0x10, %g3
4001381c: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
40013820: 86 39 00 03 xnor %g4, %g3, %g3
40013824: 80 a0 00 03 cmp %g0, %g3
40013828: 86 60 20 00 subx %g0, 0, %g3
4001382c: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
40013830: 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;
40013834: c6 08 60 06 ldub [ %g1 + 6 ], %g3
40013838: c4 08 60 07 ldub [ %g1 + 7 ], %g2
4001383c: 87 28 e0 08 sll %g3, 8, %g3
40013840: 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);
40013844: 90 07 bf d8 add %fp, -40, %o0
40013848: 7f ff fc 99 call 40012aac <rtems_rfs_inode_get_gid>
4001384c: 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));
40013850: 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);
40013854: 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));
40013858: 40 00 2a 07 call 4001e074 <rtems_rfs_file_get_shared>
4001385c: 90 10 00 1d mov %i5, %o0
if (shared)
40013860: 92 92 20 00 orcc %o0, 0, %o1
40013864: 02 80 00 17 be 400138c0 <rtems_rfs_rtems_fstat+0x174>
40013868: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4001386c: 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))
40013870: 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);
40013874: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40013878: c2 02 60 90 ld [ %o1 + 0x90 ], %g1
4001387c: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40013880: c2 02 60 94 ld [ %o1 + 0x94 ], %g1
40013884: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
40013888: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
4001388c: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
40013890: 03 00 00 3c sethi %hi(0xf000), %g1
40013894: 84 08 80 01 and %g2, %g1, %g2
40013898: 03 00 00 28 sethi %hi(0xa000), %g1
4001389c: 80 a0 80 01 cmp %g2, %g1
400138a0: 12 80 00 04 bne 400138b0 <rtems_rfs_rtems_fstat+0x164> <== ALWAYS TAKEN
400138a4: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
400138a8: 10 80 00 3d b 4001399c <rtems_rfs_rtems_fstat+0x250> <== NOT EXECUTED
400138ac: 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);
400138b0: 40 00 1c a9 call 4001ab54 <rtems_rfs_block_get_size>
400138b4: 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);
400138b8: 10 80 00 3f b 400139b4 <rtems_rfs_rtems_fstat+0x268>
400138bc: 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);
400138c0: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
400138c4: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
400138c8: 87 28 e0 18 sll %g3, 0x18, %g3
400138cc: 85 28 a0 10 sll %g2, 0x10, %g2
400138d0: 84 10 c0 02 or %g3, %g2, %g2
400138d4: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
400138d8: 84 10 80 03 or %g2, %g3, %g2
400138dc: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
400138e0: 87 28 e0 08 sll %g3, 8, %g3
400138e4: 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);
400138e8: 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);
400138ec: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
400138f0: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
400138f4: 87 28 e0 18 sll %g3, 0x18, %g3
400138f8: 85 28 a0 10 sll %g2, 0x10, %g2
400138fc: 84 10 c0 02 or %g3, %g2, %g2
40013900: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
40013904: 84 10 80 03 or %g2, %g3, %g2
40013908: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
4001390c: 87 28 e0 08 sll %g3, 8, %g3
40013910: 84 10 80 03 or %g2, %g3, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
40013914: 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);
40013918: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
4001391c: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
40013920: 87 28 e0 18 sll %g3, 0x18, %g3
40013924: 85 28 a0 10 sll %g2, 0x10, %g2
40013928: 84 10 c0 02 or %g3, %g2, %g2
4001392c: c6 08 60 1b ldub [ %g1 + 0x1b ], %g3
40013930: 84 10 80 03 or %g2, %g3, %g2
40013934: c6 08 60 1a ldub [ %g1 + 0x1a ], %g3
40013938: 87 28 e0 08 sll %g3, 8, %g3
4001393c: 84 10 80 03 or %g2, %g3, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
40013940: 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);
40013944: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
40013948: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
4001394c: 87 28 e0 18 sll %g3, 0x18, %g3
40013950: 85 28 a0 10 sll %g2, 0x10, %g2
40013954: 84 10 c0 02 or %g3, %g2, %g2
40013958: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
4001395c: 84 10 80 03 or %g2, %g3, %g2
40013960: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
40013964: 87 28 e0 08 sll %g3, 8, %g3
40013968: 84 10 80 03 or %g2, %g3, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
4001396c: 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);
40013970: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
40013974: 05 00 00 3c sethi %hi(0xf000), %g2
40013978: 86 08 c0 02 and %g3, %g2, %g3
4001397c: 05 00 00 28 sethi %hi(0xa000), %g2
40013980: 80 a0 c0 02 cmp %g3, %g2
40013984: 12 80 00 09 bne 400139a8 <rtems_rfs_rtems_fstat+0x25c>
40013988: 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);
4001398c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
40013990: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
40013994: 85 28 a0 08 sll %g2, 8, %g2
40013998: 82 10 40 02 or %g1, %g2, %g1
4001399c: c0 26 60 20 clr [ %i1 + 0x20 ]
400139a0: 10 80 00 05 b 400139b4 <rtems_rfs_rtems_fstat+0x268>
400139a4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
400139a8: 7f ff fc 29 call 40012a4c <rtems_rfs_inode_get_size>
400139ac: 92 07 bf d8 add %fp, -40, %o1
400139b0: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
400139b4: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
400139b8: 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);
400139bc: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
400139c0: 92 07 bf d8 add %fp, -40, %o1
400139c4: 7f ff fa 7a call 400123ac <rtems_rfs_inode_close>
400139c8: b0 10 20 00 clr %i0
if (rc > 0)
400139cc: 80 a2 20 00 cmp %o0, 0
400139d0: 04 80 00 05 ble 400139e4 <rtems_rfs_rtems_fstat+0x298> <== ALWAYS TAKEN
400139d4: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
400139d8: 40 00 35 f9 call 400211bc <__errno> <== NOT EXECUTED
400139dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400139e0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
400139e4: 81 c7 e0 08 ret
400139e8: 81 e8 00 00 restore
40013244 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
40013244: 9d e3 bf 98 save %sp, -104, %sp
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
40013248: 3b 10 00 d1 sethi %hi(0x40034400), %i5
if (strncmp (options, "hold-bitmaps",
4001324c: 35 10 00 d1 sethi %hi(0x40034400), %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40013250: 21 10 00 d1 sethi %hi(0x40034400), %l0
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
40013254: 23 10 00 d1 sethi %hi(0x40034400), %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;
40013258: 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;
4001325c: b8 10 20 00 clr %i4
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
40013260: ba 17 63 90 or %i5, 0x390, %i5
if (strncmp (options, "hold-bitmaps",
40013264: b4 16 a3 a0 or %i2, 0x3a0, %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40013268: a0 14 23 b0 or %l0, 0x3b0, %l0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
4001326c: 10 80 00 2f b 40013328 <rtems_rfs_rtems_initialise+0xe4>
40013270: a2 14 63 c0 or %l1, 0x3c0, %l1
{
printf ("options=%s\n", options);
40013274: 40 00 3d 2b call 40022720 <printf> <== NOT EXECUTED
40013278: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4001327c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40013280: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40013284: 40 00 41 ec call 40023a34 <strncmp> <== NOT EXECUTED
40013288: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
4001328c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013290: 12 80 00 04 bne 400132a0 <rtems_rfs_rtems_initialise+0x5c><== NOT EXECUTED
40013294: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
40013298: 10 80 00 1a b 40013300 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
4001329c: b8 17 20 01 or %i4, 1, %i4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
400132a0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400132a4: 40 00 41 e4 call 40023a34 <strncmp> <== NOT EXECUTED
400132a8: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
400132ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400132b0: 12 80 00 04 bne 400132c0 <rtems_rfs_rtems_initialise+0x7c><== NOT EXECUTED
400132b4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
400132b8: 10 80 00 12 b 40013300 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
400132bc: b8 17 20 02 or %i4, 2, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
400132c0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
400132c4: 40 00 41 dc call 40023a34 <strncmp> <== NOT EXECUTED
400132c8: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
400132cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400132d0: 12 80 00 07 bne 400132ec <rtems_rfs_rtems_initialise+0xa8><== NOT EXECUTED
400132d4: 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);
400132d8: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
400132dc: 40 00 42 b5 call 40023db0 <strtoul> <== NOT EXECUTED
400132e0: 94 10 20 00 clr %o2 <== NOT EXECUTED
400132e4: 10 80 00 06 b 400132fc <rtems_rfs_rtems_initialise+0xb8> <== NOT EXECUTED
400132e8: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
400132ec: 40 00 37 b4 call 400211bc <__errno> <== NOT EXECUTED
400132f0: 01 00 00 00 nop <== NOT EXECUTED
400132f4: 10 80 00 18 b 40013354 <rtems_rfs_rtems_initialise+0x110> <== NOT EXECUTED
400132f8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
options = strchr (options, ',');
400132fc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40013300: 40 00 3f 31 call 40022fc4 <strchr> <== NOT EXECUTED
40013304: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
40013308: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
4001330c: 02 80 00 0a be 40013334 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
40013310: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
40013314: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1 <== NOT EXECUTED
40013318: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001331c: 02 80 00 06 be 40013334 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
40013320: 01 00 00 00 nop <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
40013324: b2 06 60 01 inc %i1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
40013328: 80 a6 60 00 cmp %i1, 0
4001332c: 12 bf ff d2 bne 40013274 <rtems_rfs_rtems_initialise+0x30><== NEVER TAKEN
40013330: 92 10 00 19 mov %i1, %o1
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40013334: 7f ff d6 ab call 40008de0 <malloc>
40013338: 90 10 20 04 mov 4, %o0
if (!rtems)
4001333c: ba 92 20 00 orcc %o0, 0, %i5
40013340: 12 80 00 08 bne 40013360 <rtems_rfs_rtems_initialise+0x11c><== ALWAYS TAKEN
40013344: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
40013348: 40 00 37 9d call 400211bc <__errno> <== NOT EXECUTED
4001334c: 01 00 00 00 nop <== NOT EXECUTED
40013350: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
40013354: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013358: 81 c7 e0 08 ret <== NOT EXECUTED
4001335c: 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);
40013360: 40 00 30 ad call 4001f614 <rtems_rfs_mutex_create>
40013364: c0 27 40 00 clr [ %i5 ]
if (rc > 0)
40013368: b4 92 20 00 orcc %o0, 0, %i2
4001336c: 14 80 00 09 bg 40013390 <rtems_rfs_rtems_initialise+0x14c><== NEVER TAKEN
40013370: 01 00 00 00 nop
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
40013374: 7f ff ff 96 call 400131cc <rtems_rfs_mutex_lock.isra.2>
40013378: d0 07 40 00 ld [ %i5 ], %o0
if (rc > 0)
4001337c: b4 92 20 00 orcc %o0, 0, %i2
40013380: 24 80 00 0b ble,a 400133ac <rtems_rfs_rtems_initialise+0x168><== ALWAYS TAKEN
40013384: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
{
rtems_rfs_mutex_destroy (&rtems->access);
40013388: 40 00 30 be call 4001f680 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
4001338c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free (rtems);
40013390: 7f ff d5 03 call 4000879c <free> <== NOT EXECUTED
40013394: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
40013398: 40 00 37 89 call 400211bc <__errno> <== NOT EXECUTED
4001339c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400133a0: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
400133a4: 81 c7 e0 08 ret <== NOT EXECUTED
400133a8: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
400133ac: 94 10 00 1c mov %i4, %o2
400133b0: 92 10 00 1d mov %i5, %o1
400133b4: 96 10 00 1b mov %i3, %o3
400133b8: 40 00 2c 11 call 4001e3fc <rtems_rfs_fs_open>
400133bc: 98 07 bf fc add %fp, -4, %o4
if (rc)
400133c0: b8 92 20 00 orcc %o0, 0, %i4
400133c4: 02 80 00 09 be 400133e8 <rtems_rfs_rtems_initialise+0x1a4><== ALWAYS TAKEN
400133c8: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
400133cc: 7f ff d4 f4 call 4000879c <free> <== NOT EXECUTED
400133d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
400133d4: 40 00 37 7a call 400211bc <__errno> <== NOT EXECUTED
400133d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400133dc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400133e0: 81 c7 e0 08 ret <== NOT EXECUTED
400133e4: 81 e8 00 00 restore <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
400133e8: 03 10 00 d1 sethi %hi(0x40034400), %g1
400133ec: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 400347d0 <rtems_rfs_ops>
400133f0: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
400133f4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
400133f8: 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;
400133fc: 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);
40013400: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
40013404: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
40013408: 05 10 00 da sethi %hi(0x40036800), %g2
4001340c: 84 10 a3 10 or %g2, 0x310, %g2 ! 40036b10 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
40013410: 40 00 22 fc call 4001c000 <rtems_rfs_buffers_release>
40013414: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
rtems_rfs_mutex_unlock (&rtems->access);
40013418: d0 07 40 00 ld [ %i5 ], %o0
4001341c: 7f ff ff 56 call 40013174 <rtems_rfs_mutex_unlock.isra.1>
40013420: b0 10 20 00 clr %i0
rtems_rfs_rtems_unlock (fs);
return 0;
}
40013424: 81 c7 e0 08 ret
40013428: 81 e8 00 00 restore
40012bf0 <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)
{
40012bf0: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
40012bf4: 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);
40012bf8: d6 06 20 08 ld [ %i0 + 8 ], %o3
40012bfc: d0 00 60 08 ld [ %g1 + 8 ], %o0
40012c00: d8 06 60 08 ld [ %i1 + 8 ], %o4
40012c04: 92 10 00 1a mov %i2, %o1
40012c08: 94 10 00 1b mov %i3, %o2
40012c0c: 9a 10 20 00 clr %o5
40012c10: 40 00 30 22 call 4001ec98 <rtems_rfs_link>
40012c14: b0 10 20 00 clr %i0
if (rc)
40012c18: 80 a2 20 00 cmp %o0, 0
40012c1c: 02 80 00 05 be 40012c30 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
40012c20: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
40012c24: 40 00 39 66 call 400211bc <__errno> <== NOT EXECUTED
40012c28: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012c2c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012c30: 81 c7 e0 08 ret
40012c34: 81 e8 00 00 restore
4001fb58 <rtems_rfs_rtems_lock>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
4001fb58: 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
};
4001fb5c: 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);
4001fb60: 92 10 20 00 clr %o1
4001fb64: d0 00 40 00 ld [ %g1 ], %o0
4001fb68: 7f ff b5 74 call 4000d138 <rtems_semaphore_obtain>
4001fb6c: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
4001fb70: ba 92 20 00 orcc %o0, 0, %i5
4001fb74: 02 80 00 0c be 4001fba4 <rtems_rfs_rtems_lock+0x4c> <== ALWAYS TAKEN
4001fb78: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001fb7c: 7f ff d0 23 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001fb80: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001fb84: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fb88: 02 80 00 07 be 4001fba4 <rtems_rfs_rtems_lock+0x4c> <== NOT EXECUTED
4001fb8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4001fb90: 7f ff dd 64 call 40017120 <rtems_status_text> <== NOT EXECUTED
4001fb94: 31 10 00 d1 sethi %hi(0x40034400), %i0 <== NOT EXECUTED
4001fb98: b0 16 23 68 or %i0, 0x368, %i0 ! 40034768 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
4001fb9c: 40 00 0a e1 call 40022720 <printf> <== NOT EXECUTED
4001fba0: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
4001fba4: 81 c7 e0 08 ret
4001fba8: 81 e8 00 00 restore
40012f80 <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)
{
40012f80: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
40012f84: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
40012f88: f0 06 20 08 ld [ %i0 + 8 ], %i0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
40012f8c: 40 00 11 3c call 4001747c <geteuid>
40012f90: e0 00 60 08 ld [ %g1 + 8 ], %l0
gid = getegid ();
40012f94: 40 00 11 36 call 4001746c <getegid>
40012f98: a4 10 00 08 mov %o0, %l2
40012f9c: a2 10 00 08 mov %o0, %l1
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
40012fa0: 40 00 03 15 call 40013bf4 <rtems_rfs_rtems_imode>
40012fa4: 90 10 00 1b mov %i3, %o0
40012fa8: 82 07 bf d4 add %fp, -44, %g1
40012fac: 99 2a 20 10 sll %o0, 0x10, %o4
40012fb0: 96 10 00 1a mov %i2, %o3
40012fb4: a5 2c a0 10 sll %l2, 0x10, %l2
40012fb8: a3 2c 60 10 sll %l1, 0x10, %l1
40012fbc: a5 34 a0 10 srl %l2, 0x10, %l2
40012fc0: a3 34 60 10 srl %l1, 0x10, %l1
40012fc4: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
40012fc8: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
40012fcc: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40012fd0: 90 10 00 10 mov %l0, %o0
40012fd4: 92 10 00 18 mov %i0, %o1
40012fd8: 94 10 00 19 mov %i1, %o2
40012fdc: 99 33 20 10 srl %o4, 0x10, %o4
40012fe0: 7f ff fd c8 call 40012700 <rtems_rfs_inode_create>
40012fe4: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
40012fe8: b4 92 20 00 orcc %o0, 0, %i2
40012fec: 14 80 00 09 bg 40013010 <rtems_rfs_rtems_mknod+0x90>
40012ff0: 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);
40012ff4: 90 10 00 10 mov %l0, %o0
40012ff8: 94 07 bf d8 add %fp, -40, %o2
40012ffc: 7f ff fc 7a call 400121e4 <rtems_rfs_inode_open>
40013000: 96 10 20 01 mov 1, %o3
if (rc > 0)
40013004: b4 92 20 00 orcc %o0, 0, %i2
40013008: 04 80 00 07 ble 40013024 <rtems_rfs_rtems_mknod+0xa4> <== ALWAYS TAKEN
4001300c: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
40013010: 40 00 38 6b call 400211bc <__errno>
40013014: b0 10 3f ff mov -1, %i0
40013018: f4 22 00 00 st %i2, [ %o0 ]
4001301c: 81 c7 e0 08 ret
40013020: 81 e8 00 00 restore
}
if (S_ISDIR(mode) || S_ISREG(mode))
40013024: 05 00 00 20 sethi %hi(0x8000), %g2
40013028: 82 0e c0 01 and %i3, %g1, %g1
4001302c: 80 a0 40 02 cmp %g1, %g2
40013030: 02 80 00 1c be 400130a0 <rtems_rfs_rtems_mknod+0x120>
40013034: 05 00 00 10 sethi %hi(0x4000), %g2
40013038: 80 a0 40 02 cmp %g1, %g2
4001303c: 02 80 00 19 be 400130a0 <rtems_rfs_rtems_mknod+0x120> <== ALWAYS TAKEN
40013040: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
40013044: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
40013048: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
4001304c: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
40013050: 12 80 00 0b bne 4001307c <rtems_rfs_rtems_mknod+0xfc> <== NOT EXECUTED
40013054: 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);
40013058: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001305c: 7f ff fe ac call 40012b0c <rtems_rfs_inode_set_block> <== NOT EXECUTED
40013060: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
40013064: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
40013068: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001306c: 7f ff fe a8 call 40012b0c <rtems_rfs_inode_set_block> <== NOT EXECUTED
40013070: 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);
40013074: 10 80 00 0c b 400130a4 <rtems_rfs_rtems_mknod+0x124> <== NOT EXECUTED
40013078: 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);
4001307c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013080: 7f ff fc cb call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
40013084: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
40013088: 40 00 38 4d call 400211bc <__errno> <== NOT EXECUTED
4001308c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013090: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40013094: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013098: 81 c7 e0 08 ret <== NOT EXECUTED
4001309c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
400130a0: 90 10 00 10 mov %l0, %o0
400130a4: 92 07 bf d8 add %fp, -40, %o1
400130a8: 7f ff fc c1 call 400123ac <rtems_rfs_inode_close>
400130ac: b0 10 20 00 clr %i0
if (rc > 0)
400130b0: 80 a2 20 00 cmp %o0, 0
400130b4: 04 80 00 05 ble 400130c8 <rtems_rfs_rtems_mknod+0x148> <== ALWAYS TAKEN
400130b8: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
400130bc: 40 00 38 40 call 400211bc <__errno> <== NOT EXECUTED
400130c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400130c4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
400130c8: 81 c7 e0 08 ret
400130cc: 81 e8 00 00 restore
400134b0 <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)
{
400134b0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400134b4: 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);
400134b8: 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);
400134bc: 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);
400134c0: 94 07 bf d8 add %fp, -40, %o2
400134c4: 90 10 00 1d mov %i5, %o0
400134c8: 7f ff fb 47 call 400121e4 <rtems_rfs_inode_open>
400134cc: 96 10 20 01 mov 1, %o3
if (rc > 0)
400134d0: b8 92 20 00 orcc %o0, 0, %i4
400134d4: 04 80 00 07 ble 400134f0 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
400134d8: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
400134dc: 40 00 37 38 call 400211bc <__errno> <== NOT EXECUTED
400134e0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400134e4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400134e8: 81 c7 e0 08 ret <== NOT EXECUTED
400134ec: 81 e8 00 00 restore <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
400134f0: 7f ff ff cf call 4001342c <rtems_rfs_rtems_node_type_by_inode>
400134f4: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
400134f8: 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);
400134fc: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
40013500: 7f ff fb ab call 400123ac <rtems_rfs_inode_close>
40013504: 90 10 00 1d mov %i5, %o0
if (rc > 0)
40013508: ba 92 20 00 orcc %o0, 0, %i5
4001350c: 04 80 00 05 ble 40013520 <rtems_rfs_rtems_node_type+0x70> <== ALWAYS TAKEN
40013510: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
40013514: 40 00 37 2a call 400211bc <__errno> <== NOT EXECUTED
40013518: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001351c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
40013520: 81 c7 e0 08 ret
40013524: 81 e8 00 00 restore
40012d08 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
40012d08: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012d0c: 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);
40012d10: d2 06 20 08 ld [ %i0 + 8 ], %o1
40012d14: d0 00 60 08 ld [ %g1 + 8 ], %o0
40012d18: 94 10 00 19 mov %i1, %o2
40012d1c: 96 10 00 1a mov %i2, %o3
40012d20: 40 00 31 cc call 4001f450 <rtems_rfs_symlink_read>
40012d24: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
40012d28: 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)
40012d2c: 80 a2 20 00 cmp %o0, 0
40012d30: 02 80 00 05 be 40012d44 <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
40012d34: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
40012d38: 40 00 39 21 call 400211bc <__errno> <== NOT EXECUTED
40012d3c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012d40: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
40012d44: 81 c7 e0 08 ret
40012d48: 81 e8 00 00 restore
40012c38 <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)
{
40012c38: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
40012c3c: 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);
40012c40: 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);
40012c44: 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);
40012c48: 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);
40012c4c: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
40012c50: 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);
40012c54: 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);
40012c58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012c5c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40012c60: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40012c64: 40 00 30 0d call 4001ec98 <rtems_rfs_link> <== NOT EXECUTED
40012c68: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
40012c6c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40012c70: 02 80 00 07 be 40012c8c <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
40012c74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
40012c78: 40 00 39 51 call 400211bc <__errno> <== NOT EXECUTED
40012c7c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012c80: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40012c84: 81 c7 e0 08 ret <== NOT EXECUTED
40012c88: 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,
40012c8c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40012c90: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40012c94: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
40012c98: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
40012c9c: 40 00 30 68 call 4001ee3c <rtems_rfs_unlink> <== NOT EXECUTED
40012ca0: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
40012ca4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012ca8: 02 80 00 05 be 40012cbc <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
40012cac: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
40012cb0: 40 00 39 43 call 400211bc <__errno> <== NOT EXECUTED
40012cb4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012cb8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012cbc: 81 c7 e0 08 ret <== NOT EXECUTED
40012cc0: 81 e8 00 00 restore <== NOT EXECUTED
40013b3c <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
40013b3c: 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);
40013b40: 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))
40013b44: 05 00 00 10 sethi %hi(0x4000), %g2
40013b48: d2 08 60 02 ldub [ %g1 + 2 ], %o1
40013b4c: c2 08 60 03 ldub [ %g1 + 3 ], %g1
40013b50: 93 2a 60 08 sll %o1, 8, %o1
40013b54: 92 12 40 01 or %o1, %g1, %o1
40013b58: 03 00 00 3c sethi %hi(0xf000), %g1
40013b5c: 82 0a 40 01 and %o1, %g1, %g1
40013b60: 80 a0 40 02 cmp %g1, %g2
40013b64: 12 80 00 05 bne 40013b78 <rtems_rfs_rtems_set_handlers+0x3c>
40013b68: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
40013b6c: 03 10 00 da sethi %hi(0x40036800), %g1
40013b70: 10 80 00 0a b 40013b98 <rtems_rfs_rtems_set_handlers+0x5c>
40013b74: 82 10 63 10 or %g1, 0x310, %g1 ! 40036b10 <rtems_rfs_rtems_dir_handlers>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
40013b78: 07 00 00 2c sethi %hi(0xb000), %g3
40013b7c: 05 00 00 08 sethi %hi(0x2000), %g2
40013b80: 86 0a 40 03 and %o1, %g3, %g3
40013b84: 80 a0 c0 02 cmp %g3, %g2
40013b88: 12 80 00 07 bne 40013ba4 <rtems_rfs_rtems_set_handlers+0x68><== ALWAYS TAKEN
40013b8c: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
40013b90: 03 10 00 da sethi %hi(0x40036800), %g1 <== NOT EXECUTED
40013b94: 82 10 62 e4 or %g1, 0x2e4, %g1 ! 40036ae4 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
40013b98: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40013b9c: 10 80 00 13 b 40013be8 <rtems_rfs_rtems_set_handlers+0xac>
40013ba0: 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))
40013ba4: 80 a0 40 02 cmp %g1, %g2
40013ba8: 12 80 00 05 bne 40013bbc <rtems_rfs_rtems_set_handlers+0x80>
40013bac: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
40013bb0: 03 10 00 d2 sethi %hi(0x40034800), %g1
40013bb4: 10 bf ff f9 b 40013b98 <rtems_rfs_rtems_set_handlers+0x5c>
40013bb8: 82 10 60 24 or %g1, 0x24, %g1 ! 40034824 <rtems_rfs_rtems_link_handlers>
else if (RTEMS_RFS_S_ISREG (mode))
40013bbc: 80 a0 40 02 cmp %g1, %g2
40013bc0: 32 80 00 05 bne,a 40013bd4 <rtems_rfs_rtems_set_handlers+0x98><== NEVER TAKEN
40013bc4: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
40013bc8: 03 10 00 da sethi %hi(0x40036800), %g1
40013bcc: 10 bf ff f3 b 40013b98 <rtems_rfs_rtems_set_handlers+0x5c>
40013bd0: 82 10 63 3c or %g1, 0x33c, %g1 ! 40036b3c <rtems_rfs_rtems_file_handlers>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
40013bd4: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40013bd8: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
40013bdc: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
40013be0: 40 00 3a d0 call 40022720 <printf> <== NOT EXECUTED
40013be4: b0 10 20 00 clr %i0 <== NOT EXECUTED
return false;
}
return true;
}
40013be8: b0 0e 20 01 and %i0, 1, %i0
40013bec: 81 c7 e0 08 ret
40013bf0: 81 e8 00 00 restore
40012b5c <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
40012b5c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012b60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40012b64: 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);
40012b68: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40012b6c: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
40012b70: 7f ff fd 3b call 4001205c <rtems_rfs_group_usage> <== NOT EXECUTED
40012b74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
40012b78: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40012b7c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40012b80: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
40012b84: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40012b88: 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);
40012b8c: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40012b90: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40012b94: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
40012b98: 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);
40012b9c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40012ba0: 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;
40012ba4: 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;
40012ba8: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
40012bac: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
40012bb0: 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;
40012bb4: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
40012bb8: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
40012bbc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40012bc0: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
40012bc4: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
40012bc8: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
40012bcc: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_SIZE+0x27c92001><== NOT EXECUTED
40012bd0: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
40012bd4: 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;
40012bd8: 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);
40012bdc: c2 26 60 30 st %g1, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
40012be0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
40012be4: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED
return 0;
}
40012be8: 81 c7 e0 08 ret <== NOT EXECUTED
40012bec: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40012d4c <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)
{
40012d4c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
40012d50: 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),
40012d54: 90 10 00 1b mov %i3, %o0
40012d58: 40 00 43 05 call 4002396c <strlen>
40012d5c: 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);
40012d60: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
40012d64: 40 00 11 c6 call 4001747c <geteuid>
40012d68: ba 10 00 08 mov %o0, %i5
40012d6c: 40 00 11 c0 call 4001746c <getegid>
40012d70: a0 10 00 08 mov %o0, %l0
40012d74: 91 2a 20 10 sll %o0, 0x10, %o0
40012d78: 91 32 20 10 srl %o0, 0x10, %o0
40012d7c: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
40012d80: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
40012d84: 98 10 00 1d mov %i5, %o4
40012d88: 9b 2c 20 10 sll %l0, 0x10, %o5
40012d8c: 90 10 00 1c mov %i4, %o0
40012d90: 92 10 00 19 mov %i1, %o1
40012d94: 94 10 00 1a mov %i2, %o2
40012d98: 96 10 00 1b mov %i3, %o3
40012d9c: 9b 33 60 10 srl %o5, 0x10, %o5
40012da0: 40 00 31 13 call 4001f1ec <rtems_rfs_symlink>
40012da4: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
40012da8: 80 a2 20 00 cmp %o0, 0
40012dac: 02 80 00 05 be 40012dc0 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
40012db0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
40012db4: 40 00 39 02 call 400211bc <__errno> <== NOT EXECUTED
40012db8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012dbc: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012dc0: 81 c7 e0 08 ret
40012dc4: 81 e8 00 00 restore
4001f770 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
4001f770: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
4001f774: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rtems_rfs_buffers_release (fs);
4001f778: 7f ff f2 22 call 4001c000 <rtems_rfs_buffers_release>
4001f77c: 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);
4001f780: 7f ff b6 b7 call 4000d25c <rtems_semaphore_release>
4001f784: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4001f788: ba 92 20 00 orcc %o0, 0, %i5
4001f78c: 02 80 00 0c be 4001f7bc <rtems_rfs_rtems_unlock+0x4c> <== ALWAYS TAKEN
4001f790: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4001f794: 7f ff d1 1d call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f798: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4001f79c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f7a0: 02 80 00 07 be 4001f7bc <rtems_rfs_rtems_unlock+0x4c> <== NOT EXECUTED
4001f7a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
4001f7a8: 7f ff de 5e call 40017120 <rtems_status_text> <== NOT EXECUTED
4001f7ac: 31 10 00 d1 sethi %hi(0x40034400), %i0 <== NOT EXECUTED
4001f7b0: b0 16 23 40 or %i0, 0x340, %i0 ! 40034740 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
4001f7b4: 40 00 0b db call 40022720 <printf> <== NOT EXECUTED
4001f7b8: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
4001f7bc: 81 c7 e0 08 ret
4001f7c0: 81 e8 00 00 restore
40012dc8 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
40012dc8: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012dcc: 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);
40012dd0: 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);
40012dd4: 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);
40012dd8: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40012ddc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012de0: 7f ff fd 01 call 400121e4 <rtems_rfs_inode_open> <== NOT EXECUTED
40012de4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40012de8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40012dec: 02 80 00 07 be 40012e08 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
40012df0: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
40012df4: 40 00 38 f2 call 400211bc <__errno> <== NOT EXECUTED
40012df8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012dfc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40012e00: 81 c7 e0 08 ret <== NOT EXECUTED
40012e04: 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);
40012e08: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
40012e0c: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
40012e10: 85 36 60 10 srl %i1, 0x10, %g2 <== NOT EXECUTED
40012e14: c4 28 60 11 stb %g2, [ %g1 + 0x11 ] <== NOT EXECUTED
40012e18: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
40012e1c: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012e20: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
40012e24: 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);
40012e28: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
40012e2c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
40012e30: 85 36 a0 10 srl %i2, 0x10, %g2 <== NOT EXECUTED
40012e34: c4 28 60 15 stb %g2, [ %g1 + 0x15 ] <== NOT EXECUTED
40012e38: 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);
40012e3c: 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);
40012e40: 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);
40012e44: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
40012e48: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
40012e4c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012e50: 7f ff fd 57 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
40012e54: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
40012e58: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012e5c: 02 80 00 05 be 40012e70 <rtems_rfs_rtems_utime+0xa8> <== NOT EXECUTED
40012e60: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
40012e64: 40 00 38 d6 call 400211bc <__errno> <== NOT EXECUTED
40012e68: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012e6c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012e70: 81 c7 e0 08 ret <== NOT EXECUTED
40012e74: 81 e8 00 00 restore <== NOT EXECUTED
4001b8a4 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
4001b8a4: 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))
4001b8a8: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
4001b8ac: fa 06 20 08 ld [ %i0 + 8 ], %i5
4001b8b0: 7f ff e0 d6 call 40013c08 <rtems_rfs_trace>
4001b8b4: 92 10 20 80 mov 0x80, %o1
4001b8b8: 80 8a 20 ff btst 0xff, %o0
4001b8bc: 22 80 00 29 be,a 4001b960 <rtems_rfs_scan_chain+0xbc> <== ALWAYS TAKEN
4001b8c0: 39 10 00 d5 sethi %hi(0x40035400), %i4
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
4001b8c4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001b8c8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001b8cc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001b8d0: 40 00 1b 94 call 40022720 <printf> <== NOT EXECUTED
4001b8d4: 90 12 21 70 or %o0, 0x170, %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));
4001b8d8: 10 80 00 22 b 4001b960 <rtems_rfs_scan_chain+0xbc> <== NOT EXECUTED
4001b8dc: 39 10 00 d5 sethi %hi(0x40035400), %i4 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001b8e0: 7f ff e0 ca call 40013c08 <rtems_rfs_trace>
4001b8e4: 01 00 00 00 nop
4001b8e8: 80 8a 20 ff btst 0xff, %o0
4001b8ec: 22 80 00 06 be,a 4001b904 <rtems_rfs_scan_chain+0x60> <== ALWAYS TAKEN
4001b8f0: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001b8f4: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001b8f8: 40 00 1b 8a call 40022720 <printf> <== NOT EXECUTED
4001b8fc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001b900: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
4001b904: 80 a0 40 1a cmp %g1, %i2
4001b908: 32 80 00 17 bne,a 4001b964 <rtems_rfs_scan_chain+0xc0>
4001b90c: fa 07 60 04 ld [ %i5 + 4 ], %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001b910: 90 10 20 00 clr %o0
4001b914: 7f ff e0 bd call 40013c08 <rtems_rfs_trace>
4001b918: 92 10 20 80 mov 0x80, %o1
4001b91c: 80 8a 20 ff btst 0xff, %o0
4001b920: 22 80 00 07 be,a 4001b93c <rtems_rfs_scan_chain+0x98> <== ALWAYS TAKEN
4001b924: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
4001b928: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001b92c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
4001b930: 40 00 1b 7c call 40022720 <printf> <== NOT EXECUTED
4001b934: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400355a8 <CSWTCH.2+0x168><== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
4001b938: 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 );
4001b93c: 90 10 00 1d mov %i5, %o0
4001b940: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
4001b944: b0 10 00 1d mov %i5, %i0
4001b948: 7f ff f4 1b call 400189b4 <_Chain_Extract>
4001b94c: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4001b950: c0 27 60 04 clr [ %i5 + 4 ]
4001b954: c0 27 40 00 clr [ %i5 ]
4001b958: 81 c7 e0 08 ret
4001b95c: 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));
4001b960: b8 17 21 a0 or %i4, 0x1a0, %i4
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001b964: 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))
4001b968: 80 a7 40 18 cmp %i5, %i0
4001b96c: 12 bf ff dd bne 4001b8e0 <rtems_rfs_scan_chain+0x3c>
4001b970: 92 10 20 80 mov 0x80, %o1
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001b974: 7f ff e0 a5 call 40013c08 <rtems_rfs_trace>
4001b978: b0 10 20 00 clr %i0
4001b97c: 80 8a 20 ff btst 0xff, %o0
4001b980: 02 bf ff f6 be 4001b958 <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
4001b984: 11 10 00 d5 sethi %hi(0x40035400), %o0
printf (": not found\n");
4001b988: 40 00 1b fe call 40022980 <puts> <== NOT EXECUTED
4001b98c: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 400355c0 <CSWTCH.2+0x180><== NOT EXECUTED
return NULL;
}
4001b990: 81 c7 e0 08 ret <== NOT EXECUTED
4001b994: 81 e8 00 00 restore <== NOT EXECUTED
40019ff4 <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,
40019ff4: 9d e3 bf 88 save %sp, -120, %sp
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
40019ff8: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
40019ffc: 90 10 00 18 mov %i0, %o0
4001a000: 7f ff ff e8 call 40019fa0 <rtems_rfs_bitmap_load_map>
4001a004: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001a008: 80 a2 20 00 cmp %o0, 0
4001a00c: 14 80 00 98 bg 4001a26c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NEVER TAKEN
4001a010: 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;
4001a014: fa 06 40 00 ld [ %i1 ], %i5
end_bit = test_bit + (window * direction);
if (end_bit < 0)
4001a018: a0 84 00 1d addcc %l0, %i5, %l0
4001a01c: 2c 80 00 08 bneg,a 4001a03c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
4001a020: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
4001a024: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001a028: 80 a4 00 01 cmp %l0, %g1
4001a02c: 3a 80 00 04 bcc,a 4001a03c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
4001a030: 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];
4001a034: 10 80 00 03 b 4001a040 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001a038: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4001a03c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
map_bits = &map[map_index];
4001a040: 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);
4001a044: 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);
4001a048: 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);
4001a04c: 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];
4001a050: 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);
4001a054: 82 0f 20 1f and %i4, 0x1f, %g1
search_bits = &control->search_bits[search_index];
4001a058: a6 00 80 13 add %g2, %l3, %l3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
4001a05c: 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];
4001a060: 85 2f 20 02 sll %i4, 2, %g2
4001a064: a8 10 20 1f mov 0x1f, %l4
4001a068: 80 a6 e0 00 cmp %i3, 0
4001a06c: 04 80 00 03 ble 4001a078 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x84>
4001a070: a2 04 40 02 add %l1, %g2, %l1
4001a074: 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)))
4001a078: ab 3e e0 1f sra %i3, 0x1f, %l5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001a07c: 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)))
4001a080: 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);
4001a084: 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))
4001a088: 87 36 e0 1f srl %i3, 0x1f, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
4001a08c: 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;
4001a090: 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))
4001a094: d8 04 c0 00 ld [ %l3 ], %o4
4001a098: 80 a3 20 00 cmp %o4, 0
4001a09c: 02 80 00 44 be 4001a1ac <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8>
4001a0a0: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001a0a4: 96 07 00 1b add %i4, %i3, %o3
4001a0a8: 84 10 20 00 clr %g2
4001a0ac: 97 2a e0 05 sll %o3, 5, %o3
4001a0b0: 82 20 40 1c sub %g1, %i4, %g1
4001a0b4: 10 80 00 38 b 4001a194 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
4001a0b8: 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))
4001a0bc: 80 8b c0 0c btst %o7, %o4
4001a0c0: 12 80 00 1a bne 4001a128 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x134>
4001a0c4: a4 24 80 1d sub %l2, %i5, %l2
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001a0c8: 10 80 00 1d b 4001a13c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
4001a0cc: 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);
4001a0d0: 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))
4001a0d4: 80 8a 80 09 btst %o2, %o1
4001a0d8: 02 80 00 12 be 4001a120 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
4001a0dc: 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);
4001a0e0: 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,
4001a0e4: 80 a2 a0 00 cmp %o2, 0
4001a0e8: 12 80 00 05 bne 4001a0fc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108>
4001a0ec: 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);
4001a0f0: c2 04 c0 00 ld [ %l3 ], %g1
4001a0f4: 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,
4001a0f8: de 24 c0 00 st %o7, [ %l3 ]
1 << search_offset);
control->free--;
4001a0fc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a100: 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--;
4001a104: 82 00 7f ff add %g1, -1, %g1
4001a108: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
*bit = test_bit;
4001a10c: fa 26 40 00 st %i5, [ %i1 ]
*found = true;
4001a110: 82 10 20 01 mov 1, %g1
4001a114: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a118: 10 80 00 54 b 4001a268 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
4001a11c: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
}
if (test_bit == end_bit)
4001a120: 02 80 00 06 be 4001a138 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
4001a124: ba 07 40 1b add %i5, %i3, %i5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001a128: 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)
4001a12c: 80 a2 a0 1f cmp %o2, 0x1f
4001a130: 28 bf ff e8 bleu,a 4001a0d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xdc><== ALWAYS TAKEN
4001a134: d2 04 40 00 ld [ %l1 ], %o1
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001a138: ba 00 80 0b add %g2, %o3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
4001a13c: a2 04 40 16 add %l1, %l6, %l1
map_index += direction;
4001a140: 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))
4001a144: 80 a7 40 10 cmp %i5, %l0
4001a148: 04 80 00 03 ble 4001a154 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x160>
4001a14c: 9e 10 20 01 mov 1, %o7
4001a150: 9e 10 20 00 clr %o7
4001a154: 80 8b e0 ff btst 0xff, %o7
4001a158: 02 80 00 05 be 4001a16c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178>
4001a15c: 84 00 80 04 add %g2, %g4, %g2
4001a160: 80 a0 e0 00 cmp %g3, 0
4001a164: 32 80 00 29 bne,a 4001a208 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x214>
4001a168: a4 10 00 14 mov %l4, %l2
|| ((direction > 0) && (test_bit >= end_bit)))
4001a16c: 80 a7 40 10 cmp %i5, %l0
4001a170: 16 80 00 03 bge 4001a17c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188>
4001a174: 9e 10 20 01 mov 1, %o7
4001a178: 9e 10 20 00 clr %o7
4001a17c: 80 8b e0 ff btst 0xff, %o7
4001a180: 02 80 00 05 be 4001a194 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
4001a184: a4 10 00 14 mov %l4, %l2
4001a188: 80 a5 60 00 cmp %l5, 0
4001a18c: 32 80 00 20 bne,a 4001a20c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
4001a190: a6 04 c0 16 add %l3, %l6, %l3
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001a194: 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)
4001a198: 80 a3 e0 1f cmp %o7, 0x1f
4001a19c: 28 bf ff c8 bleu,a 4001a0bc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc8>
4001a1a0: 9f 2d c0 0f sll %l7, %o7, %o7
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
4001a1a4: 10 80 00 1a b 4001a20c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
4001a1a8: 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)
4001a1ac: 04 80 00 07 ble 4001a1c8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4>
4001a1b0: ba 0f 7f e0 and %i5, -32, %i5
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001a1b4: 92 23 40 01 sub %o5, %g1, %o1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
4001a1b8: 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 ();
4001a1bc: 83 2a 60 05 sll %o1, 5, %g1
4001a1c0: 10 80 00 07 b 4001a1dc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8>
4001a1c4: ba 00 40 1d add %g1, %i5, %i5
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
4001a1c8: 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;
4001a1cc: 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;
4001a1d0: 83 28 60 05 sll %g1, 5, %g1
4001a1d4: 82 38 00 01 xnor %g0, %g1, %g1
4001a1d8: ba 00 40 1d add %g1, %i5, %i5
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
4001a1dc: c6 27 bf f4 st %g3, [ %fp + -12 ]
4001a1e0: c8 27 bf f0 st %g4, [ %fp + -16 ]
4001a1e4: da 27 bf ec st %o5, [ %fp + -20 ]
4001a1e8: 7f ff a0 eb call 40002594 <.umul>
4001a1ec: 90 10 00 1b mov %i3, %o0
4001a1f0: c6 07 bf f4 ld [ %fp + -12 ], %g3
4001a1f4: 83 2a 20 02 sll %o0, 2, %g1
map_index += direction * bits_skipped;
4001a1f8: 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;
4001a1fc: a2 04 40 01 add %l1, %g1, %l1
4001a200: c8 07 bf f0 ld [ %fp + -16 ], %g4
4001a204: da 07 bf ec ld [ %fp + -20 ], %o5
map_index += direction * bits_skipped;
}
search_bits += direction;
4001a208: a6 04 c0 16 add %l3, %l6, %l3
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001a20c: 80 a6 e0 00 cmp %i3, 0
4001a210: 04 80 00 03 ble 4001a21c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x228>
4001a214: 82 10 20 1f mov 0x1f, %g1
4001a218: 82 10 20 00 clr %g1
}
while (((direction < 0) && (test_bit >= end_bit))
4001a21c: 80 a7 40 10 cmp %i5, %l0
4001a220: 16 80 00 03 bge 4001a22c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x238>
4001a224: 84 10 20 01 mov 1, %g2
4001a228: 84 10 20 00 clr %g2
|| ((direction > 0) && (test_bit <= end_bit)));
4001a22c: 80 88 a0 ff btst 0xff, %g2
4001a230: 02 80 00 06 be 4001a248 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x254>
4001a234: 80 a7 40 10 cmp %i5, %l0
4001a238: 80 a0 e0 00 cmp %g3, 0
4001a23c: 32 bf ff 97 bne,a 4001a098 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
4001a240: d8 04 c0 00 ld [ %l3 ], %o4
4001a244: 80 a7 40 10 cmp %i5, %l0
4001a248: 04 80 00 03 ble 4001a254 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x260>
4001a24c: 84 10 20 01 mov 1, %g2
4001a250: 84 10 20 00 clr %g2
4001a254: 80 88 a0 ff btst 0xff, %g2
4001a258: 02 80 00 04 be 4001a268 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
4001a25c: 80 a5 60 00 cmp %l5, 0
4001a260: 32 bf ff 8e bne,a 4001a098 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
4001a264: d8 04 c0 00 ld [ %l3 ], %o4
return 0;
4001a268: 90 10 20 00 clr %o0
}
4001a26c: 81 c7 e0 08 ret
4001a270: 91 e8 00 08 restore %g0, %o0, %o0
4001f1ec <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001f1ec: 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))
4001f1f0: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001f1f4: e2 07 a0 60 ld [ %fp + 0x60 ], %l1
4001f1f8: 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))
4001f1fc: 7f ff d2 83 call 40013c08 <rtems_rfs_trace>
4001f200: 92 10 20 00 clr %o1
4001f204: 80 8a 20 ff btst 0xff, %o0
4001f208: 12 80 00 07 bne 4001f224 <rtems_rfs_symlink+0x38> <== NEVER TAKEN
4001f20c: 11 10 00 da sethi %hi(0x40036800), %o0
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
4001f210: c2 06 20 08 ld [ %i0 + 8 ], %g1
4001f214: 80 a7 00 01 cmp %i4, %g1
4001f218: 1a 80 00 8b bcc 4001f444 <rtems_rfs_symlink+0x258> <== NEVER TAKEN
4001f21c: b4 10 20 5b mov 0x5b, %i2
4001f220: 30 80 00 19 b,a 4001f284 <rtems_rfs_symlink+0x98>
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
4001f224: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001f228: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED
4001f22c: 40 00 0d 3d call 40022720 <printf> <== NOT EXECUTED
4001f230: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
4001f234: 10 80 00 05 b 4001f248 <rtems_rfs_symlink+0x5c> <== NOT EXECUTED
4001f238: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
4001f23c: 40 00 0d a3 call 400228c8 <putchar> <== NOT EXECUTED
4001f240: 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++)
4001f244: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
4001f248: 26 bf ff fd bl,a 4001f23c <rtems_rfs_symlink+0x50> <== NOT EXECUTED
4001f24c: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
4001f250: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001f254: 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:");
4001f258: 40 00 0d 32 call 40022720 <printf> <== NOT EXECUTED
4001f25c: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001f260: 10 80 00 05 b 4001f274 <rtems_rfs_symlink+0x88> <== NOT EXECUTED
4001f264: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
printf ("%c", link[c]);
4001f268: 40 00 0d 98 call 400228c8 <putchar> <== NOT EXECUTED
4001f26c: 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++)
4001f270: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
4001f274: 26 bf ff fd bl,a 4001f268 <rtems_rfs_symlink+0x7c> <== NOT EXECUTED
4001f278: d0 4e c0 1a ldsb [ %i3 + %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
4001f27c: 10 bf ff e6 b 4001f214 <rtems_rfs_symlink+0x28> <== NOT EXECUTED
4001f280: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4001f284: 40 00 11 ba call 4002396c <strlen>
4001f288: 90 10 00 19 mov %i1, %o0
4001f28c: 82 07 bf 74 add %fp, -140, %g1
4001f290: 96 10 00 08 mov %o0, %o3
4001f294: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4001f298: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
4001f29c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4001f2a0: 90 10 00 18 mov %i0, %o0
4001f2a4: 92 10 00 11 mov %l1, %o1
4001f2a8: 94 10 00 19 mov %i1, %o2
4001f2ac: 19 00 00 28 sethi %hi(0xa000), %o4
4001f2b0: 9a 10 20 01 mov 1, %o5
4001f2b4: 7f ff cd 13 call 40012700 <rtems_rfs_inode_create>
4001f2b8: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
4001f2bc: b4 92 20 00 orcc %o0, 0, %i2
4001f2c0: 34 80 00 62 bg,a 4001f448 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
4001f2c4: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001f2c8: d2 07 bf 74 ld [ %fp + -140 ], %o1
4001f2cc: 90 10 00 18 mov %i0, %o0
4001f2d0: 94 07 bf 88 add %fp, -120, %o2
4001f2d4: 7f ff cb c4 call 400121e4 <rtems_rfs_inode_open>
4001f2d8: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001f2dc: b4 92 20 00 orcc %o0, 0, %i2
4001f2e0: 34 80 00 5a bg,a 4001f448 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
4001f2e4: 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)
4001f2e8: 80 a7 20 13 cmp %i4, 0x13
4001f2ec: 38 80 00 15 bgu,a 4001f340 <rtems_rfs_symlink+0x154> <== NEVER TAKEN
4001f2f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
4001f2f4: d0 07 bf 94 ld [ %fp + -108 ], %o0
4001f2f8: 92 10 20 00 clr %o1
4001f2fc: 94 10 20 14 mov 0x14, %o2
4001f300: 40 00 0c 8a call 40022528 <memset>
4001f304: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
4001f308: d0 07 bf 94 ld [ %fp + -108 ], %o0
4001f30c: 92 10 00 1b mov %i3, %o1
4001f310: 90 02 20 1c add %o0, 0x1c, %o0
4001f314: 40 00 0b f6 call 400222ec <memcpy>
4001f318: 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);
4001f31c: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001f320: c0 28 60 0c clrb [ %g1 + 0xc ]
4001f324: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001f328: c0 28 60 0d clrb [ %g1 + 0xd ]
4001f32c: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001f330: c0 28 60 0e clrb [ %g1 + 0xe ]
4001f334: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001f338: 10 80 00 38 b 4001f418 <rtems_rfs_symlink+0x22c>
4001f33c: 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);
4001f340: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001f344: 7f ff ee 1c call 4001abb4 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001f348: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
4001f34c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
4001f350: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001f354: 14 80 00 2d bg 4001f408 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
4001f358: 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);
4001f35c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001f360: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001f364: 7f ff ef 6f call 4001b120 <rtems_rfs_block_map_grow> <== NOT EXECUTED
4001f368: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
4001f36c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001f370: 14 80 00 0c bg 4001f3a0 <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
4001f374: 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);
4001f378: 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;
4001f37c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001f380: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001f384: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001f388: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001f38c: 7f ff f1 f7 call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001f390: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
4001f394: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001f398: 04 80 00 06 ble 4001f3b0 <rtems_rfs_symlink+0x1c4> <== NOT EXECUTED
4001f39c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
4001f3a0: 7f ff ee 66 call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001f3a4: 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);
4001f3a8: 10 80 00 18 b 4001f408 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
4001f3ac: 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);
4001f3b0: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
4001f3b4: 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);
4001f3b8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
4001f3bc: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
4001f3c0: 40 00 0c 5a call 40022528 <memset> <== NOT EXECUTED
4001f3c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
4001f3c8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001f3cc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001f3d0: 40 00 0b c7 call 400222ec <memcpy> <== NOT EXECUTED
4001f3d4: 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);
4001f3d8: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001f3dc: 7f ff f1 6f call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f3e0: 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);
4001f3e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001f3e8: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001f3ec: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001f3f0: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001f3f4: 7f ff ee 51 call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001f3f8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
4001f3fc: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001f400: 04 80 00 06 ble 4001f418 <rtems_rfs_symlink+0x22c> <== NOT EXECUTED
4001f404: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4001f408: 7f ff cb e9 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001f40c: 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;
}
4001f410: 81 c7 e0 08 ret <== NOT EXECUTED
4001f414: 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);
4001f418: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001f41c: 85 37 20 08 srl %i4, 8, %g2
4001f420: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
4001f424: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
4001f428: 90 10 00 18 mov %i0, %o0
4001f42c: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f430: 82 10 20 01 mov 1, %g1
4001f434: 92 07 bf 88 add %fp, -120, %o1
4001f438: 7f ff cb dd call 400123ac <rtems_rfs_inode_close>
4001f43c: c2 2f bf 98 stb %g1, [ %fp + -104 ]
4001f440: b4 10 00 08 mov %o0, %i2
return rc;
}
4001f444: b0 10 00 1a mov %i2, %i0
4001f448: 81 c7 e0 08 ret
4001f44c: 81 e8 00 00 restore
4001f450 <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)
{
4001f450: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
4001f454: 90 10 20 04 mov 4, %o0
4001f458: 92 10 20 00 clr %o1
4001f45c: 7f ff d1 eb call 40013c08 <rtems_rfs_trace>
4001f460: ba 10 00 18 mov %i0, %i5
4001f464: 80 8a 20 ff btst 0xff, %o0
4001f468: 22 80 00 07 be,a 4001f484 <rtems_rfs_symlink_read+0x34> <== ALWAYS TAKEN
4001f46c: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
4001f470: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f474: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001f478: 40 00 0c aa call 40022720 <printf> <== NOT EXECUTED
4001f47c: 90 12 22 70 or %o0, 0x270, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001f480: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f484: 92 10 00 19 mov %i1, %o1
4001f488: 94 07 bf 88 add %fp, -120, %o2
4001f48c: 7f ff cb 56 call 400121e4 <rtems_rfs_inode_open>
4001f490: 96 10 20 01 mov 1, %o3
if (rc)
4001f494: b0 92 20 00 orcc %o0, 0, %i0
4001f498: 12 80 00 0d bne 4001f4cc <rtems_rfs_symlink_read+0x7c> <== NEVER TAKEN
4001f49c: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
4001f4a0: 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);
4001f4a4: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
4001f4a8: 85 28 a0 08 sll %g2, 8, %g2
4001f4ac: 84 08 80 01 and %g2, %g1, %g2
4001f4b0: 03 00 00 28 sethi %hi(0xa000), %g1
4001f4b4: 80 a0 80 01 cmp %g2, %g1
4001f4b8: 02 80 00 07 be 4001f4d4 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
4001f4bc: 90 10 00 1d mov %i5, %o0
{
rtems_rfs_inode_close (fs, &inode);
4001f4c0: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001f4c4: 7f ff cb ba call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001f4c8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
4001f4cc: 81 c7 e0 08 ret <== NOT EXECUTED
4001f4d0: 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);
4001f4d4: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4001f4d8: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
4001f4dc: 95 2a a0 08 sll %o2, 8, %o2
4001f4e0: 94 10 40 0a or %g1, %o2, %o2
4001f4e4: 80 a2 80 1b cmp %o2, %i3
4001f4e8: 38 80 00 02 bgu,a 4001f4f0 <rtems_rfs_symlink_read+0xa0>
4001f4ec: 94 10 00 1b mov %i3, %o2
4001f4f0: 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);
4001f4f4: c2 0a 60 0d ldub [ %o1 + 0xd ], %g1
4001f4f8: c4 0a 60 0c ldub [ %o1 + 0xc ], %g2
4001f4fc: 83 28 60 10 sll %g1, 0x10, %g1
4001f500: 85 28 a0 18 sll %g2, 0x18, %g2
4001f504: 84 10 80 01 or %g2, %g1, %g2
4001f508: c2 0a 60 0f ldub [ %o1 + 0xf ], %g1
4001f50c: 84 10 80 01 or %g2, %g1, %g2
4001f510: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
4001f514: 83 28 60 08 sll %g1, 8, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001f518: 80 90 80 01 orcc %g2, %g1, %g0
4001f51c: 32 80 00 07 bne,a 4001f538 <rtems_rfs_symlink_read+0xe8> <== NEVER TAKEN
4001f520: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
4001f524: 90 10 00 1a mov %i2, %o0
4001f528: 40 00 0b 71 call 400222ec <memcpy>
4001f52c: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
4001f530: 10 80 00 34 b 4001f600 <rtems_rfs_symlink_read+0x1b0>
4001f534: 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);
4001f538: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001f53c: 7f ff ed 9e call 4001abb4 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001f540: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
4001f544: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if (rc > 0)
4001f548: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001f54c: 14 80 00 29 bg 4001f5f0 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
4001f550: 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);
4001f554: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001f558: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001f55c: 96 10 20 00 clr %o3 <== NOT EXECUTED
4001f560: 7f ff ee c6 call 4001b078 <rtems_rfs_block_map_seek> <== NOT EXECUTED
4001f564: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
4001f568: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001f56c: 14 80 00 0c bg 4001f59c <rtems_rfs_symlink_read+0x14c> <== NOT EXECUTED
4001f570: 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);
4001f574: 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;
4001f578: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001f57c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001f580: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001f584: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001f588: 7f ff f1 78 call 4001bb68 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001f58c: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
4001f590: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001f594: 04 80 00 06 ble 4001f5ac <rtems_rfs_symlink_read+0x15c> <== NOT EXECUTED
4001f598: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
4001f59c: 7f ff ed e7 call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001f5a0: 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);
4001f5a4: 10 80 00 13 b 4001f5f0 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
4001f5a8: 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);
4001f5ac: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
4001f5b0: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4001f5b4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4001f5b8: 40 00 0b 4d call 400222ec <memcpy> <== NOT EXECUTED
4001f5bc: 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);
4001f5c0: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4001f5c4: 7f ff f0 f5 call 4001b998 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f5c8: 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);
4001f5cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001f5d0: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
4001f5d4: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
4001f5d8: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
4001f5dc: 7f ff ed d7 call 4001ad38 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001f5e0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
4001f5e4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001f5e8: 04 80 00 06 ble 4001f600 <rtems_rfs_symlink_read+0x1b0> <== NOT EXECUTED
4001f5ec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4001f5f0: 7f ff cb 6f call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001f5f4: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4001f5f8: 81 c7 e0 08 ret <== NOT EXECUTED
4001f5fc: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
4001f600: 7f ff cb 6b call 400123ac <rtems_rfs_inode_close>
4001f604: 92 07 bf 88 add %fp, -120, %o1
4001f608: b0 10 00 08 mov %o0, %i0
return rc;
}
4001f60c: 81 c7 e0 08 ret
4001f610: 81 e8 00 00 restore
40013c48 <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;
40013c48: 03 10 01 20 sethi %hi(0x40048000), %g1 <== NOT EXECUTED
40013c4c: c4 18 62 e0 ldd [ %g1 + 0x2e0 ], %g2 ! 400482e0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
40013c50: 90 28 80 08 andn %g2, %o0, %o0 <== NOT EXECUTED
40013c54: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
40013c58: d0 38 62 e0 std %o0, [ %g1 + 0x2e0 ] <== NOT EXECUTED
return state;
}
40013c5c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
40013c60: 81 c3 e0 08 retl <== NOT EXECUTED
40013c64: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40013c28 <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;
40013c28: 03 10 01 20 sethi %hi(0x40048000), %g1 <== NOT EXECUTED
40013c2c: c4 18 62 e0 ldd [ %g1 + 0x2e0 ], %g2 ! 400482e0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
40013c30: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
40013c34: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
40013c38: d0 38 62 e0 std %o0, [ %g1 + 0x2e0 ] <== NOT EXECUTED
return state;
}
40013c3c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
40013c40: 81 c3 e0 08 retl <== NOT EXECUTED
40013c44: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40013c68 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
40013c68: 9d e3 be f8 save %sp, -264, %sp <== NOT EXECUTED
const char* table[] =
40013c6c: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
40013c70: 90 07 bf 64 add %fp, -156, %o0 <== NOT EXECUTED
40013c74: 92 12 63 5c or %o1, 0x35c, %o1 <== NOT EXECUTED
40013c78: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40013c7c: 27 10 00 ca sethi %hi(0x40032800), %l3 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40013c80: 29 10 00 d2 sethi %hi(0x40034800), %l4 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
40013c84: 40 00 39 9a call 400222ec <memcpy> <== NOT EXECUTED
40013c88: 2b 10 00 d2 sethi %hi(0x40034800), %l5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40013c8c: 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;
40013c90: 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;
40013c94: b4 10 20 00 clr %i2 <== NOT EXECUTED
40013c98: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
40013c9c: b8 10 20 00 clr %i4 <== NOT EXECUTED
40013ca0: ba 10 20 00 clr %i5 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40013ca4: a6 14 e1 f0 or %l3, 0x1f0, %l3 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40013ca8: a8 15 20 f0 or %l4, 0xf0, %l4 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
40013cac: aa 15 60 f8 or %l5, 0xf8, %l5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40013cb0: 10 80 00 68 b 40013e50 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
40013cb4: 25 10 01 20 sethi %hi(0x40048000), %l2 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
40013cb8: ec 06 40 01 ld [ %i1 + %g1 ], %l6 <== NOT EXECUTED
40013cbc: c2 4d 80 00 ldsb [ %l6 ], %g1 <== NOT EXECUTED
40013cc0: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40013cc4: 12 80 00 25 bne 40013d58 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
40013cc8: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
switch (argv[arg][1])
40013ccc: c2 4d a0 01 ldsb [ %l6 + 1 ], %g1 <== NOT EXECUTED
40013cd0: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
40013cd4: 02 80 00 06 be 40013cec <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
40013cd8: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
40013cdc: 32 80 00 1a bne,a 40013d44 <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
40013ce0: 11 10 00 d2 sethi %hi(0x40034800), %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]);
40013ce4: 10 80 00 08 b 40013d04 <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
40013ce8: 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]);
40013cec: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40013cf0: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40013cf4: 40 00 3a 8b call 40022720 <printf> <== NOT EXECUTED
40013cf8: 90 12 20 80 or %o0, 0x80, %o0 ! 40034880 <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;
40013cfc: 81 c7 e0 08 ret <== NOT EXECUTED
40013d00: 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]);
40013d04: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
40013d08: 39 10 00 d2 sethi %hi(0x40034800), %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]);
40013d0c: 90 12 20 a8 or %o0, 0xa8, %o0 <== NOT EXECUTED
40013d10: 40 00 3a 84 call 40022720 <printf> <== NOT EXECUTED
40013d14: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
40013d18: b8 17 20 d0 or %i4, 0xd0, %i4 <== NOT EXECUTED
40013d1c: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
40013d20: d2 00 40 1d ld [ %g1 + %i5 ], %o1 <== NOT EXECUTED
40013d24: 40 00 3a 7f call 40022720 <printf> <== NOT EXECUTED
40013d28: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40013d2c: 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++)
40013d30: 80 a7 60 9c cmp %i5, 0x9c <== NOT EXECUTED
40013d34: 12 bf ff fb bne 40013d20 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
40013d38: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
40013d3c: 81 c7 e0 08 ret <== NOT EXECUTED
40013d40: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
default:
printf ("error: unknown option\n");
return 1;
40013d44: 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");
40013d48: 40 00 3b 0e call 40022980 <puts> <== NOT EXECUTED
40013d4c: 90 12 20 d8 or %o0, 0xd8, %o0 <== NOT EXECUTED
40013d50: 81 c7 e0 08 ret <== NOT EXECUTED
40013d54: 81 e8 00 00 restore <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40013d58: 40 00 3c f9 call 4002313c <strcmp> <== NOT EXECUTED
40013d5c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40013d60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013d64: 22 80 00 02 be,a 40013d6c <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
40013d68: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40013d6c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40013d70: 40 00 3c f3 call 4002313c <strcmp> <== NOT EXECUTED
40013d74: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40013d78: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013d7c: 22 80 00 2e be,a 40013e34 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40013d80: a2 10 20 00 clr %l1 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
40013d84: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40013d88: 40 00 3c ed call 4002313c <strcmp> <== NOT EXECUTED
40013d8c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
40013d90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013d94: 12 80 00 09 bne 40013db8 <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
40013d98: 94 10 20 00 clr %o2 <== NOT EXECUTED
{
if (set)
40013d9c: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
40013da0: 22 80 00 23 be,a 40013e2c <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
40013da4: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
40013da8: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
40013dac: b8 17 23 ff or %i4, 0x3ff, %i4 ! ffffffff <LEON_REG+0x7fffffff><== NOT EXECUTED
40013db0: 10 80 00 21 b 40013e34 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40013db4: 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[])
40013db8: 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)
40013dbc: 84 07 bf 64 add %fp, -156, %g2 <== NOT EXECUTED
40013dc0: d2 00 80 01 ld [ %g2 + %g1 ], %o1 <== NOT EXECUTED
40013dc4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
40013dc8: 40 00 3c dd call 4002313c <strcmp> <== NOT EXECUTED
40013dcc: d4 27 bf 5c st %o2, [ %fp + -164 ] <== NOT EXECUTED
40013dd0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013dd4: 12 80 00 10 bne 40013e14 <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
40013dd8: d4 07 bf 5c ld [ %fp + -164 ], %o2 <== NOT EXECUTED
{
if (set)
set_value = 1ULL << t;
40013ddc: 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)
40013de0: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
40013de4: 02 80 00 07 be 40013e00 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
40013de8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
set_value = 1ULL << t;
40013dec: 40 00 6c e3 call 4002f178 <__ashldi3> <== NOT EXECUTED
40013df0: 01 00 00 00 nop <== NOT EXECUTED
40013df4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
40013df8: 10 80 00 0f b 40013e34 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40013dfc: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
else
clear_value = 1ULL << t;
40013e00: 40 00 6c de call 4002f178 <__ashldi3> <== NOT EXECUTED
40013e04: 01 00 00 00 nop <== NOT EXECUTED
40013e08: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
40013e0c: 10 80 00 0a b 40013e34 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
40013e10: 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++)
40013e14: 94 02 a0 01 inc %o2 <== NOT EXECUTED
40013e18: 80 a2 a0 27 cmp %o2, 0x27 <== NOT EXECUTED
40013e1c: 12 bf ff e8 bne 40013dbc <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
40013e20: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
40013e24: 10 80 00 05 b 40013e38 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
40013e28: c4 1c a2 e0 ldd [ %l2 + 0x2e0 ], %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;
40013e2c: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
40013e30: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
40013e34: c4 1c a2 e0 ldd [ %l2 + 0x2e0 ], %g2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40013e38: a0 04 20 01 inc %l0 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
40013e3c: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
40013e40: 86 17 40 03 or %i5, %g3, %g3 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
40013e44: 84 28 80 1a andn %g2, %i2, %g2 <== NOT EXECUTED
40013e48: 86 28 c0 1b andn %g3, %i3, %g3 <== NOT EXECUTED
40013e4c: c4 3c a2 e0 std %g2, [ %l2 + 0x2e0 ] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40013e50: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED
40013e54: 06 bf ff 99 bl 40013cb8 <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
40013e58: 83 2c 20 02 sll %l0, 2, %g1 <== NOT EXECUTED
40013e5c: 30 bf ff b8 b,a 40013d3c <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
40013e60: 40 01 4d 44 call 40067370 <__end+0x1dfd0> <== NOT EXECUTED
40013e64: 40 01 4c e4 call 400671f4 <__end+0x1de54> <== NOT EXECUTED
40013e68: 40 01 4c f8 call 40067248 <__end+0x1dea8> <== NOT EXECUTED
40013e6c: 40 01 4c f8 call 4006724c <__end+0x1deac> <== NOT EXECUTED
40013e70: 40 01 4c f8 call 40067250 <__end+0x1deb0> <== NOT EXECUTED
40013e74: 40 01 4c f8 call 40067254 <__end+0x1deb4> <== NOT EXECUTED
40013e78: 40 01 4c dc call 400671e8 <__end+0x1de48> <== NOT EXECUTED
40013e7c: 40 01 4d 04 call 4006728c <__end+0x1deec> <== NOT EXECUTED
40013e80: 40 01 4d 04 call 40067290 <__end+0x1def0> <== NOT EXECUTED
40013e84: 40 01 4d 04 call 40067294 <__end+0x1def4> <== NOT EXECUTED
40013e88: 40 01 4d 24 call 40067318 <__end+0x1df78> <== NOT EXECUTED
40013e8c: 40 01 4c 30 call 40066f4c <__end+0x1dbac> <== NOT EXECUTED
40013e90: 40 01 4c 30 call 40066f50 <__end+0x1dbb0> <== NOT EXECUTED
40013e94: 40 01 4c 50 call 40066fd4 <__end+0x1dc34> <== NOT EXECUTED
40013e98: 40 01 4c 50 call 40066fd8 <__end+0x1dc38> <== NOT EXECUTED
40013e9c: 40 01 4c 50 call 40066fdc <__end+0x1dc3c> <== NOT EXECUTED
40013ea0: 40 01 4c 50 call 40066fe0 <__end+0x1dc40> <== NOT EXECUTED
40013ea4: 40 01 4b fc call 40066e94 <__end+0x1daf4> <== NOT EXECUTED
40013ea8: 40 01 4c 5c call 40067018 <__end+0x1dc78> <== NOT EXECUTED
40013eac: 40 01 4c 5c call 4006701c <__end+0x1dc7c> <== NOT EXECUTED
40013eb0: 40 01 4c 5c call 40067020 <__end+0x1dc80> <== NOT EXECUTED
40013eb4: 40 01 62 d0 call 4006c9f4 <__end+0x23654> <== NOT EXECUTED
40013eb8: 40 01 62 d0 call 4006c9f8 <__end+0x23658> <== NOT EXECUTED
40013ebc: 40 01 62 90 call 4006c8fc <__end+0x2355c> <== NOT EXECUTED
40013ec0: 40 01 62 c0 call 4006c9c0 <__end+0x23620> <== NOT EXECUTED
40013ec4: 40 01 62 c0 call 4006c9c4 <__end+0x23624> <== NOT EXECUTED
40013ec8: 40 01 62 c0 call 4006c9c8 <__end+0x23628> <== NOT EXECUTED
40013ecc: 40 01 62 d0 call 4006ca0c <__end+0x2366c> <== NOT EXECUTED
40013ed0: 40 01 62 88 call 4006c8f0 <__end+0x23550> <== NOT EXECUTED
40013ed4: 40 01 62 80 call 4006c8d4 <__end+0x23534> <== NOT EXECUTED
40013ed8: 40 01 62 b8 call 4006c9b8 <__end+0x23618> <== NOT EXECUTED
40013edc: 40 01 62 d0 call 4006ca1c <__end+0x2367c> <== NOT EXECUTED
4001ee3c <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)
{
4001ee3c: 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))
4001ee40: 90 10 20 00 clr %o0
4001ee44: 7f ff d3 71 call 40013c08 <rtems_rfs_trace>
4001ee48: 13 00 80 00 sethi %hi(0x2000000), %o1
4001ee4c: 80 8a 20 ff btst 0xff, %o0
4001ee50: 02 80 00 08 be 4001ee70 <rtems_rfs_unlink+0x34> <== ALWAYS TAKEN
4001ee54: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
4001ee58: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001ee5c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001ee60: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
4001ee64: 40 00 0e 2f call 40022720 <printf> <== NOT EXECUTED
4001ee68: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001ee6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ee70: 92 10 00 1a mov %i2, %o1
4001ee74: 94 07 bf d8 add %fp, -40, %o2
4001ee78: 7f ff cc db call 400121e4 <rtems_rfs_inode_open>
4001ee7c: 96 10 20 01 mov 1, %o3
if (rc)
4001ee80: ba 92 20 00 orcc %o0, 0, %i5
4001ee84: 12 80 00 d7 bne 4001f1e0 <rtems_rfs_unlink+0x3a4> <== NEVER TAKEN
4001ee88: 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));
4001ee8c: 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);
4001ee90: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001ee94: 83 28 60 08 sll %g1, 8, %g1
4001ee98: 82 08 40 02 and %g1, %g2, %g1
4001ee9c: 05 00 00 10 sethi %hi(0x4000), %g2
4001eea0: 82 18 40 02 xor %g1, %g2, %g1
4001eea4: 80 a0 00 01 cmp %g0, %g1
4001eea8: a0 60 3f ff subx %g0, -1, %l0
if (dir)
4001eeac: 80 8c 20 ff btst 0xff, %l0
4001eeb0: 02 80 00 26 be 4001ef48 <rtems_rfs_unlink+0x10c>
4001eeb4: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
4001eeb8: 22 80 00 06 be,a 4001eed0 <rtems_rfs_unlink+0x94> <== NEVER TAKEN
4001eebc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001eec0: 80 a7 20 01 cmp %i4, 1
4001eec4: 12 80 00 22 bne 4001ef4c <rtems_rfs_unlink+0x110> <== NEVER TAKEN
4001eec8: 90 10 00 18 mov %i0, %o0
4001eecc: 30 80 00 0f b,a 4001ef08 <rtems_rfs_unlink+0xcc>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001eed0: 7f ff d3 4e call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001eed4: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001eed8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001eedc: 22 80 00 06 be,a 4001eef4 <rtems_rfs_unlink+0xb8> <== NOT EXECUTED
4001eee0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
4001eee4: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001eee8: 40 00 0e a6 call 40022980 <puts> <== NOT EXECUTED
4001eeec: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400368a0 <CSWTCH.2+0x1460><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001eef0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001eef4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001eef8: 7f ff cd 2d call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001eefc: 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;
}
4001ef00: 81 c7 e0 08 ret <== NOT EXECUTED
4001ef04: 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);
4001ef08: 7f ff f8 dc call 4001d278 <rtems_rfs_dir_empty>
4001ef0c: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001ef10: ba 92 20 00 orcc %o0, 0, %i5
4001ef14: 04 80 00 0d ble 4001ef48 <rtems_rfs_unlink+0x10c>
4001ef18: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001ef1c: 7f ff d3 3b call 40013c08 <rtems_rfs_trace>
4001ef20: 13 00 80 00 sethi %hi(0x2000000), %o1
4001ef24: 80 8a 20 ff btst 0xff, %o0
4001ef28: 22 80 00 97 be,a 4001f184 <rtems_rfs_unlink+0x348> <== ALWAYS TAKEN
4001ef2c: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4001ef30: 40 00 12 68 call 400238d0 <strerror> <== NOT EXECUTED
4001ef34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ef38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ef3c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001ef40: 10 80 00 8e b 4001f178 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
4001ef44: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400368c0 <CSWTCH.2+0x1480><== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001ef48: 90 10 00 18 mov %i0, %o0
4001ef4c: 92 10 00 19 mov %i1, %o1
4001ef50: 94 07 bf b0 add %fp, -80, %o2
4001ef54: 7f ff cc a4 call 400121e4 <rtems_rfs_inode_open>
4001ef58: 96 10 20 01 mov 1, %o3
if (rc)
4001ef5c: ba 92 20 00 orcc %o0, 0, %i5
4001ef60: 02 80 00 0e be 4001ef98 <rtems_rfs_unlink+0x15c> <== ALWAYS TAKEN
4001ef64: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001ef68: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ef6c: 7f ff d3 27 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001ef70: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001ef74: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ef78: 22 80 00 83 be,a 4001f184 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
4001ef7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
4001ef80: 40 00 12 54 call 400238d0 <strerror> <== NOT EXECUTED
4001ef84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ef88: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ef8c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001ef90: 10 80 00 7a b 4001f178 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
4001ef94: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400368e0 <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);
4001ef98: 92 07 bf b0 add %fp, -80, %o1
4001ef9c: 94 10 00 1a mov %i2, %o2
4001efa0: 7f ff f6 d4 call 4001caf0 <rtems_rfs_dir_del_entry>
4001efa4: 96 10 00 1b mov %i3, %o3
if (rc > 0)
4001efa8: ba 92 20 00 orcc %o0, 0, %i5
4001efac: 04 80 00 0e ble 4001efe4 <rtems_rfs_unlink+0x1a8> <== ALWAYS TAKEN
4001efb0: 01 00 00 00 nop
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001efb4: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
4001efb8: 7f ff d3 14 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001efbc: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001efc0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001efc4: 22 80 00 59 be,a 4001f128 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
4001efc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
4001efcc: 40 00 12 41 call 400238d0 <strerror> <== NOT EXECUTED
4001efd0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001efd4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001efd8: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001efdc: 10 80 00 50 b 4001f11c <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
4001efe0: 90 12 21 10 or %o0, 0x110, %o0 ! 40036910 <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);
4001efe4: 7f ff ff 1e call 4001ec5c <rtems_rfs_inode_get_links>
4001efe8: 90 07 bf d8 add %fp, -40, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001efec: 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);
4001eff0: ba 10 00 08 mov %o0, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001eff4: 7f ff d3 05 call 40013c08 <rtems_rfs_trace>
4001eff8: 90 10 20 00 clr %o0
4001effc: 80 8a 20 ff btst 0xff, %o0
4001f000: 02 80 00 09 be 4001f024 <rtems_rfs_unlink+0x1e8> <== ALWAYS TAKEN
4001f004: 83 2f 60 10 sll %i5, 0x10, %g1
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001f008: 95 2f 60 10 sll %i5, 0x10, %o2 <== NOT EXECUTED
4001f00c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f010: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001f014: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
4001f018: 40 00 0d c2 call 40022720 <printf> <== NOT EXECUTED
4001f01c: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
if (links > 1)
4001f020: 83 2f 60 10 sll %i5, 0x10, %g1 <== NOT EXECUTED
4001f024: 83 30 60 10 srl %g1, 0x10, %g1
4001f028: 80 a0 60 01 cmp %g1, 1
4001f02c: 08 80 00 0a bleu 4001f054 <rtems_rfs_unlink+0x218>
4001f030: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
4001f034: 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);
4001f038: 85 37 60 08 srl %i5, 8, %g2
4001f03c: c4 28 40 00 stb %g2, [ %g1 ]
4001f040: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001f044: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f048: 82 10 20 01 mov 1, %g1
4001f04c: 10 80 00 23 b 4001f0d8 <rtems_rfs_unlink+0x29c>
4001f050: 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);
4001f054: 90 10 00 18 mov %i0, %o0
4001f058: 7f ff cc f8 call 40012438 <rtems_rfs_inode_delete>
4001f05c: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001f060: ba 92 20 00 orcc %o0, 0, %i5
4001f064: 04 80 00 0d ble 4001f098 <rtems_rfs_unlink+0x25c> <== ALWAYS TAKEN
4001f068: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f06c: 7f ff d2 e7 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f070: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001f074: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f078: 22 80 00 2c be,a 4001f128 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
4001f07c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
4001f080: 40 00 12 14 call 400238d0 <strerror> <== NOT EXECUTED
4001f084: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f088: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f08c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f090: 10 80 00 23 b 4001f11c <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
4001f094: 90 12 21 68 or %o0, 0x168, %o0 ! 40036968 <CSWTCH.2+0x1528><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
4001f098: 80 8c 20 ff btst 0xff, %l0
4001f09c: 02 80 00 10 be 4001f0dc <rtems_rfs_unlink+0x2a0>
4001f0a0: 90 07 bf b0 add %fp, -80, %o0
{
links = rtems_rfs_inode_get_links (&parent_inode);
4001f0a4: 7f ff fe ee call 4001ec5c <rtems_rfs_inode_get_links>
4001f0a8: 90 07 bf b0 add %fp, -80, %o0
if (links > 1)
4001f0ac: 80 a2 20 01 cmp %o0, 1
4001f0b0: 08 80 00 03 bleu 4001f0bc <rtems_rfs_unlink+0x280>
4001f0b4: 82 10 00 08 mov %o0, %g1
links--;
4001f0b8: 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);
4001f0bc: c4 07 bf bc ld [ %fp + -68 ], %g2
4001f0c0: 87 30 60 08 srl %g1, 8, %g3
4001f0c4: c6 28 80 00 stb %g3, [ %g2 ]
4001f0c8: c4 07 bf bc ld [ %fp + -68 ], %g2
4001f0cc: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f0d0: 82 10 20 01 mov 1, %g1
4001f0d4: 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);
4001f0d8: 90 07 bf b0 add %fp, -80, %o0
4001f0dc: 92 10 20 01 mov 1, %o1
4001f0e0: 7f ff cd 0b call 4001250c <rtems_rfs_inode_time_stamp_now>
4001f0e4: 94 10 20 01 mov 1, %o2
if (rc > 0)
4001f0e8: ba 92 20 00 orcc %o0, 0, %i5
4001f0ec: 04 80 00 13 ble 4001f138 <rtems_rfs_unlink+0x2fc> <== ALWAYS TAKEN
4001f0f0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f0f4: 7f ff d2 c5 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f0f8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001f0fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f100: 22 80 00 0a be,a 4001f128 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
4001f104: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
4001f108: 40 00 11 f2 call 400238d0 <strerror> <== NOT EXECUTED
4001f10c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f110: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f114: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f118: 90 12 21 98 or %o0, 0x198, %o0 ! 40036998 <CSWTCH.2+0x1558><== NOT EXECUTED
4001f11c: 40 00 0d 81 call 40022720 <printf> <== NOT EXECUTED
4001f120: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
4001f124: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001f128: 7f ff cc a1 call 400123ac <rtems_rfs_inode_close> <== NOT EXECUTED
4001f12c: 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);
4001f130: 10 80 00 15 b 4001f184 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
4001f134: 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);
4001f138: 90 10 00 18 mov %i0, %o0
4001f13c: 7f ff cc 9c call 400123ac <rtems_rfs_inode_close>
4001f140: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
4001f144: ba 92 20 00 orcc %o0, 0, %i5
4001f148: 04 80 00 13 ble 4001f194 <rtems_rfs_unlink+0x358> <== ALWAYS TAKEN
4001f14c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f150: 7f ff d2 ae call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f154: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001f158: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f15c: 02 80 00 0a be 4001f184 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
4001f160: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
4001f164: 40 00 11 db call 400238d0 <strerror> <== NOT EXECUTED
4001f168: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f16c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f170: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f174: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400369d0 <CSWTCH.2+0x1590><== NOT EXECUTED
4001f178: 40 00 0d 6a call 40022720 <printf> <== NOT EXECUTED
4001f17c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
4001f180: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001f184: 7f ff cc 8a call 400123ac <rtems_rfs_inode_close>
4001f188: 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;
}
4001f18c: 81 c7 e0 08 ret
4001f190: 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);
4001f194: 90 10 00 18 mov %i0, %o0
4001f198: 7f ff cc 85 call 400123ac <rtems_rfs_inode_close>
4001f19c: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f1a0: ba 92 20 00 orcc %o0, 0, %i5
4001f1a4: 04 80 00 10 ble 4001f1e4 <rtems_rfs_unlink+0x3a8> <== ALWAYS TAKEN
4001f1a8: b0 10 00 1d mov %i5, %i0
4001f1ac: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f1b0: 7f ff d2 96 call 40013c08 <rtems_rfs_trace> <== NOT EXECUTED
4001f1b4: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001f1b8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f1bc: 22 80 00 0a be,a 4001f1e4 <rtems_rfs_unlink+0x3a8> <== NOT EXECUTED
4001f1c0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
4001f1c4: 40 00 11 c3 call 400238d0 <strerror> <== NOT EXECUTED
4001f1c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f1cc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001f1d0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f1d4: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
4001f1d8: 40 00 0d 52 call 40022720 <printf> <== NOT EXECUTED
4001f1dc: 90 12 22 08 or %o0, 0x208, %o0 ! 40036a08 <CSWTCH.2+0x15c8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
4001f1e0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001f1e4: 81 c7 e0 08 ret
4001f1e8: 81 e8 00 00 restore
400211b0 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
400211b0: 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));
400211b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
400211b8: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
400211bc: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
400211c0: 40 00 66 14 call 4003aa10 <memset> <== NOT EXECUTED
400211c4: 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;
400211c8: b8 10 20 00 clr %i4 <== NOT EXECUTED
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
400211cc: 10 80 00 5b b 40021338 <rtems_shell_rfs_format+0x188> <== NOT EXECUTED
400211d0: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
400211d4: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
400211d8: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
400211dc: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
400211e0: 12 80 00 4e bne 40021318 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
400211e4: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
400211e8: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
400211ec: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
400211f0: 22 80 00 2e be,a 400212a8 <rtems_shell_rfs_format+0xf8> <== NOT EXECUTED
400211f4: ba 07 60 01 inc %i5 <== NOT EXECUTED
400211f8: 14 80 00 09 bg 4002121c <rtems_shell_rfs_format+0x6c> <== NOT EXECUTED
400211fc: 80 a0 60 73 cmp %g1, 0x73 <== NOT EXECUTED
40021200: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED
40021204: 02 80 00 35 be 400212d8 <rtems_shell_rfs_format+0x128> <== NOT EXECUTED
40021208: 80 a0 60 62 cmp %g1, 0x62 <== NOT EXECUTED
4002120c: 12 80 00 41 bne 40021310 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
40021210: 11 10 01 5f sethi %hi(0x40057c00), %o0 <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
40021214: 10 80 00 19 b 40021278 <rtems_shell_rfs_format+0xc8> <== NOT EXECUTED
40021218: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
4002121c: 02 80 00 0a be 40021244 <rtems_shell_rfs_format+0x94> <== NOT EXECUTED
40021220: 80 a0 60 76 cmp %g1, 0x76 <== NOT EXECUTED
40021224: 02 80 00 06 be 4002123c <rtems_shell_rfs_format+0x8c> <== NOT EXECUTED
40021228: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
4002122c: 12 80 00 39 bne 40021310 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
40021230: 11 10 01 5f sethi %hi(0x40057c00), %o0 <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
40021234: 10 80 00 2b b 400212e0 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED
40021238: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
break;
4002123c: 10 80 00 3e b 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40021240: f6 2f bf fd stb %i3, [ %fp + -3 ] <== NOT EXECUTED
case 's':
arg++;
40021244: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
40021248: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
4002124c: 06 80 00 05 bl 40021260 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
40021250: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
40021254: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
40021258: 10 80 00 40 b 40021358 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
4002125c: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40059eb0 <rtems_rtc_shell_usage+0x17a0><== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
40021260: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40021264: 92 10 20 00 clr %o1 <== NOT EXECUTED
40021268: 40 00 7a 56 call 4003fbc0 <strtoul> <== NOT EXECUTED
4002126c: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
40021270: 10 80 00 31 b 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
40021274: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
40021278: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
4002127c: 06 80 00 05 bl 40021290 <rtems_shell_rfs_format+0xe0> <== NOT EXECUTED
40021280: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
40021284: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
40021288: 10 80 00 34 b 40021358 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
4002128c: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 40059ed8 <rtems_rtc_shell_usage+0x17c8><== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
40021290: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40021294: 92 10 20 00 clr %o1 <== NOT EXECUTED
40021298: 40 00 7a 4a call 4003fbc0 <strtoul> <== NOT EXECUTED
4002129c: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400212a0: 10 80 00 25 b 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
400212a4: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
400212a8: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
400212ac: 06 80 00 05 bl 400212c0 <rtems_shell_rfs_format+0x110> <== NOT EXECUTED
400212b0: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
400212b4: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
400212b8: 10 80 00 28 b 40021358 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
400212bc: 90 12 23 08 or %o0, 0x308, %o0 ! 40059f08 <rtems_rtc_shell_usage+0x17f8><== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
400212c0: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400212c4: 92 10 20 00 clr %o1 <== NOT EXECUTED
400212c8: 40 00 7a 3e call 4003fbc0 <strtoul> <== NOT EXECUTED
400212cc: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400212d0: 10 80 00 19 b 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
400212d4: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
400212d8: 10 80 00 17 b 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
400212dc: f6 2f bf fc stb %i3, [ %fp + -4 ] <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
400212e0: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
400212e4: 06 80 00 05 bl 400212f8 <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
400212e8: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
400212ec: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
400212f0: 10 80 00 1a b 40021358 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
400212f4: 90 12 23 38 or %o0, 0x338, %o0 ! 40059f38 <rtems_rtc_shell_usage+0x1828><== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
400212f8: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400212fc: 92 10 20 00 clr %o1 <== NOT EXECUTED
40021300: 40 00 7a 30 call 4003fbc0 <strtoul> <== NOT EXECUTED
40021304: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
40021308: 10 80 00 0b b 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
4002130c: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
40021310: 10 80 00 06 b 40021328 <rtems_shell_rfs_format+0x178> <== NOT EXECUTED
40021314: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
40021318: 22 80 00 07 be,a 40021334 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
4002131c: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
40021320: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
40021324: 90 12 23 70 or %o0, 0x370, %o0 ! 40059f70 <rtems_rtc_shell_usage+0x1860><== NOT EXECUTED
40021328: 40 00 6a 2b call 4003bbd4 <printf> <== NOT EXECUTED
4002132c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40021330: 30 80 00 1c b,a 400213a0 <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++)
40021334: ba 07 60 01 inc %i5 <== NOT EXECUTED
40021338: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
4002133c: 06 bf ff a6 bl 400211d4 <rtems_shell_rfs_format+0x24> <== NOT EXECUTED
40021340: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
40021344: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40021348: 12 80 00 07 bne 40021364 <rtems_shell_rfs_format+0x1b4> <== NOT EXECUTED
4002134c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
printf ("error: no driver name provided\n");
40021350: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
40021354: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 40059fa0 <rtems_rtc_shell_usage+0x1890><== NOT EXECUTED
40021358: 40 00 6a b7 call 4003be34 <puts> <== NOT EXECUTED
4002135c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40021360: 30 80 00 10 b,a 400213a0 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
40021364: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
40021368: 40 00 35 69 call 4002e90c <rtems_rfs_format> <== NOT EXECUTED
4002136c: b0 10 20 00 clr %i0 <== NOT EXECUTED
40021370: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40021374: 16 80 00 0b bge 400213a0 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
40021378: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
4002137c: 40 00 57 c7 call 40037298 <__errno> <== NOT EXECUTED
40021380: 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",
40021384: 40 00 73 92 call 4003e1cc <strerror> <== NOT EXECUTED
40021388: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4002138c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40021390: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40021394: 11 10 01 67 sethi %hi(0x40059c00), %o0 <== NOT EXECUTED
40021398: 40 00 6a 0f call 4003bbd4 <printf> <== NOT EXECUTED
4002139c: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 40059fc0 <rtems_rtc_shell_usage+0x18b0><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
400213a0: 81 c7 e0 08 ret <== NOT EXECUTED
400213a4: 81 e8 00 00 restore <== NOT EXECUTED
400181c0 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
400181c0: 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 )
400181c4: 80 a6 60 00 cmp %i1, 0
400181c8: 02 80 00 35 be 4001829c <rtems_signal_send+0xdc>
400181cc: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
400181d0: 90 10 00 18 mov %i0, %o0
400181d4: 40 00 12 93 call 4001cc20 <_Thread_Get>
400181d8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
400181dc: c2 07 bf fc ld [ %fp + -4 ], %g1
400181e0: 80 a0 60 00 cmp %g1, 0
400181e4: 12 80 00 2d bne 40018298 <rtems_signal_send+0xd8>
400181e8: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
400181ec: fa 02 21 4c ld [ %o0 + 0x14c ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
400181f0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400181f4: 80 a0 60 00 cmp %g1, 0
400181f8: 02 80 00 24 be 40018288 <rtems_signal_send+0xc8>
400181fc: 01 00 00 00 nop
if ( asr->is_enabled ) {
40018200: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
40018204: 80 a0 60 00 cmp %g1, 0
40018208: 02 80 00 15 be 4001825c <rtems_signal_send+0x9c>
4001820c: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
40018210: 7f ff e0 e9 call 400105b4 <sparc_disable_interrupts>
40018214: 01 00 00 00 nop
*signal_set |= signals;
40018218: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001821c: b2 10 40 19 or %g1, %i1, %i1
40018220: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
40018224: 7f ff e0 e8 call 400105c4 <sparc_enable_interrupts>
40018228: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001822c: 03 10 00 fb sethi %hi(0x4003ec00), %g1
40018230: 82 10 61 30 or %g1, 0x130, %g1 ! 4003ed30 <_Per_CPU_Information>
40018234: c4 00 60 08 ld [ %g1 + 8 ], %g2
40018238: 80 a0 a0 00 cmp %g2, 0
4001823c: 02 80 00 0f be 40018278 <rtems_signal_send+0xb8>
40018240: 01 00 00 00 nop
40018244: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40018248: 80 a7 00 02 cmp %i4, %g2
4001824c: 12 80 00 0b bne 40018278 <rtems_signal_send+0xb8> <== NEVER TAKEN
40018250: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
40018254: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
40018258: 30 80 00 08 b,a 40018278 <rtems_signal_send+0xb8>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
4001825c: 7f ff e0 d6 call 400105b4 <sparc_disable_interrupts>
40018260: 01 00 00 00 nop
*signal_set |= signals;
40018264: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40018268: b2 10 40 19 or %g1, %i1, %i1
4001826c: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
40018270: 7f ff e0 d5 call 400105c4 <sparc_enable_interrupts>
40018274: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
40018278: 40 00 12 5e call 4001cbf0 <_Thread_Enable_dispatch>
4001827c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
40018280: 10 80 00 07 b 4001829c <rtems_signal_send+0xdc>
40018284: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
_Thread_Enable_dispatch();
40018288: 40 00 12 5a call 4001cbf0 <_Thread_Enable_dispatch>
4001828c: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
40018290: 10 80 00 03 b 4001829c <rtems_signal_send+0xdc>
40018294: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40018298: 82 10 20 04 mov 4, %g1
}
4001829c: 81 c7 e0 08 ret
400182a0: 91 e8 00 01 restore %g0, %g1, %o0
4000f478 <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 )
{
4000f478: 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 )
4000f47c: 92 10 00 1a mov %i2, %o1
4000f480: 7f ff cc 74 call 40002650 <.umul>
4000f484: 90 06 60 08 add %i1, 8, %o0
+ key_table_size + data_size;
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
4000f488: 7f ff da fe call 40006080 <malloc>
4000f48c: 90 02 20 1c add %o0, 0x1c, %o0
4000f490: 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 ) {
4000f494: 80 a2 60 00 cmp %o1, 0
4000f498: 02 80 00 0b be 4000f4c4 <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
4000f49c: 90 10 20 1a mov 0x1a, %o0
sc = rtems_sparse_disk_register(
4000f4a0: 03 10 00 3c sethi %hi(0x4000f000), %g1
4000f4a4: 82 10 61 00 or %g1, 0x100, %g1 ! 4000f100 <rtems_sparse_disk_free>
4000f4a8: 90 10 00 18 mov %i0, %o0
4000f4ac: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000f4b0: 94 10 00 19 mov %i1, %o2
4000f4b4: 96 10 00 1a mov %i2, %o3
4000f4b8: 98 10 00 1b mov %i3, %o4
4000f4bc: 7f ff ff b7 call 4000f398 <rtems_sparse_disk_register>
4000f4c0: 9a 10 00 1c mov %i4, %o5
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
4000f4c4: 81 c7 e0 08 ret
4000f4c8: 91 e8 00 08 restore %g0, %o0, %o0
4000f4cc: 40 01 03 b0 call 4005038c <__end+0x21a9c> <== NOT EXECUTED
4000f4d0: 40 01 03 50 call 40050210 <__end+0x21920> <== NOT EXECUTED
4000f4d4: 40 01 03 64 call 40050264 <__end+0x21974> <== NOT EXECUTED
4000f4d8: 40 01 03 64 call 40050268 <__end+0x21978> <== NOT EXECUTED
4000f4dc: 40 01 03 64 call 4005026c <__end+0x2197c> <== NOT EXECUTED
4000f4e0: 40 01 03 64 call 40050270 <__end+0x21980> <== NOT EXECUTED
4000f4e4: 40 01 03 48 call 40050204 <__end+0x21914> <== NOT EXECUTED
4000f4e8: 40 01 03 70 call 400502a8 <__end+0x219b8> <== NOT EXECUTED
4000f4ec: 40 01 03 70 call 400502ac <__end+0x219bc> <== NOT EXECUTED
4000f4f0: 40 01 03 70 call 400502b0 <__end+0x219c0> <== NOT EXECUTED
4000f4f4: 40 01 03 90 call 40050334 <__end+0x21a44> <== NOT EXECUTED
4000f4f8: 40 01 02 9c call 4004ff68 <__end+0x21678> <== NOT EXECUTED
4000f4fc: 40 01 02 9c call 4004ff6c <__end+0x2167c> <== NOT EXECUTED
4000f500: 40 01 02 bc call 4004fff0 <__end+0x21700> <== NOT EXECUTED
4000f504: 40 01 02 bc call 4004fff4 <__end+0x21704> <== NOT EXECUTED
4000f508: 40 01 02 bc call 4004fff8 <__end+0x21708> <== NOT EXECUTED
4000f50c: 40 01 02 bc call 4004fffc <__end+0x2170c> <== NOT EXECUTED
4000f510: 40 01 02 68 call 4004feb0 <__end+0x215c0> <== NOT EXECUTED
4000f514: 40 01 02 c8 call 40050034 <__end+0x21744> <== NOT EXECUTED
4000f518: 40 01 02 c8 call 40050038 <__end+0x21748> <== NOT EXECUTED
4000f51c: 40 01 02 c8 call 4005003c <__end+0x2174c> <== NOT EXECUTED
4000f520: 40 01 19 3c call 40055a10 <__end+0x27120> <== NOT EXECUTED
4000f524: 40 01 19 3c call 40055a14 <__end+0x27124> <== NOT EXECUTED
4000f528: 40 01 18 fc call 40055918 <__end+0x27028> <== NOT EXECUTED
4000f52c: 40 01 19 2c call 400559dc <__end+0x270ec> <== NOT EXECUTED
4000f530: 40 01 19 2c call 400559e0 <__end+0x270f0> <== NOT EXECUTED
4000f534: 40 01 19 2c call 400559e4 <__end+0x270f4> <== NOT EXECUTED
4000f538: 40 01 19 3c call 40055a28 <__end+0x27138> <== NOT EXECUTED
4000f53c: 40 01 18 f4 call 4005590c <__end+0x2701c> <== NOT EXECUTED
4000f540: 40 01 18 ec call 400558f0 <__end+0x27000> <== NOT EXECUTED
4000f544: 40 01 19 24 call 400559d4 <__end+0x270e4> <== NOT EXECUTED
4000f548: 40 01 19 3c call 40055a38 <__end+0x27148> <== NOT EXECUTED
4000f398 <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 )
{
4000f398: 9d e3 bf a0 save %sp, -96, %sp
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
4000f39c: 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 )
{
4000f3a0: a0 10 00 19 mov %i1, %l0
4000f3a4: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
4000f3a8: 80 a6 c0 1c cmp %i3, %i4
4000f3ac: 18 80 00 31 bgu 4000f470 <rtems_sparse_disk_register+0xd8><== NEVER TAKEN
4000f3b0: b2 10 00 1a mov %i2, %i1
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
4000f3b4: 80 a4 20 00 cmp %l0, 0
4000f3b8: 02 80 00 2d be 4000f46c <rtems_sparse_disk_register+0xd4> <== NEVER TAKEN
4000f3bc: 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
4000f3c0: 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 );
4000f3c4: 90 10 00 10 mov %l0, %o0
4000f3c8: a2 06 a0 1c add %i2, 0x1c, %l1
4000f3cc: 40 00 34 40 call 4001c4cc <memset>
4000f3d0: 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;
4000f3d4: 92 10 00 19 mov %i1, %o1
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
4000f3d8: 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;
4000f3dc: 7f ff cc 9d call 40002650 <.umul>
4000f3e0: 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 ),
4000f3e4: 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;
4000f3e8: 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 ),
4000f3ec: a2 04 00 11 add %l0, %l1, %l1
4000f3f0: 40 00 34 37 call 4001c4cc <memset>
4000f3f4: 90 10 00 11 mov %l1, %o0
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
sc = rtems_semaphore_create(
4000f3f8: 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;
4000f3fc: e4 24 20 10 st %l2, [ %l0 + 0x10 ]
sc = rtems_semaphore_create(
4000f400: 90 12 21 52 or %o0, 0x152, %o0
4000f404: 92 10 20 01 mov 1, %o1
4000f408: 94 10 20 54 mov 0x54, %o2
4000f40c: 96 10 20 00 clr %o3
4000f410: 7f ff ea 56 call 40009d68 <rtems_semaphore_create>
4000f414: 98 10 00 10 mov %l0, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
4000f418: 80 a2 20 00 cmp %o0, 0
4000f41c: 12 80 00 15 bne 4000f470 <rtems_sparse_disk_register+0xd8><== NEVER TAKEN
4000f420: 84 04 20 1c add %l0, 0x1c, %g2
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
4000f424: f6 24 20 04 st %i3, [ %l0 + 4 ]
sd->key_table = (rtems_sparse_disk_key *) data;
4000f428: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000f42c: 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;
4000f430: 10 80 00 06 b 4000f448 <rtems_sparse_disk_register+0xb0>
4000f434: 84 00 80 1a add %g2, %i2, %g2
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000f438: 82 00 60 01 inc %g1
}
return sc;
}
rtems_status_code rtems_sparse_disk_register(
4000f43c: 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;
4000f440: 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 ) {
4000f444: 84 00 80 19 add %g2, %i1, %g2
4000f448: 80 a0 40 1b cmp %g1, %i3
4000f44c: 12 bf ff fb bne 4000f438 <rtems_sparse_disk_register+0xa0>
4000f450: 87 28 60 03 sll %g1, 3, %g3
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
4000f454: b4 10 00 1c mov %i4, %i2
4000f458: 37 10 00 3c sethi %hi(0x4000f000), %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;
4000f45c: f2 24 20 0c st %i1, [ %l0 + 0xc ]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
4000f460: b6 16 e1 0c or %i3, 0x10c, %i3
4000f464: 40 00 0a 93 call 40011eb0 <rtems_blkdev_create>
4000f468: 99 e8 00 10 restore %g0, %l0, %o4
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
return RTEMS_INVALID_ADDRESS;
4000f46c: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
4000f470: 81 c7 e0 08 ret <== NOT EXECUTED
4000f474: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40022b08 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
40022b08: 9d e3 bf a0 save %sp, -96, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
40022b0c: c2 06 20 08 ld [ %i0 + 8 ], %g1
40022b10: 80 a0 60 00 cmp %g1, 0
40022b14: 02 80 00 07 be 40022b30 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
40022b18: 13 10 01 93 sethi %hi(0x40064c00), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
40022b1c: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
40022b20: 90 02 20 08 add %o0, 8, %o0
40022b24: 92 12 62 6c or %o1, 0x26c, %o1
40022b28: 40 00 5f 2b call 4003a7d4 <memcpy>
40022b2c: 94 10 20 10 mov 0x10, %o2
40022b30: 81 c7 e0 08 ret
40022b34: 81 e8 00 00 restore
40022a50 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
40022a50: 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 )
40022a54: 03 10 01 8e sethi %hi(0x40063800), %g1
40022a58: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 40063b20 <Stack_check_Initialized>
40022a5c: 80 a0 60 00 cmp %g1, 0
40022a60: 12 80 00 21 bne 40022ae4 <rtems_stack_checker_create_extension+0x94>
40022a64: 05 10 01 93 sethi %hi(0x40064c00), %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 ];
40022a68: 07 3f bb 7c sethi %hi(0xfeedf000), %g3
40022a6c: 82 10 a2 6c or %g2, 0x26c, %g1
40022a70: 86 10 e0 0d or %g3, 0xd, %g3
40022a74: c6 20 a2 6c st %g3, [ %g2 + 0x26c ]
40022a78: 05 02 eb 43 sethi %hi(0xbad0c00), %g2
40022a7c: 84 10 a1 06 or %g2, 0x106, %g2 ! bad0d06 <RAM_SIZE+0xb6d0d06>
40022a80: c4 20 60 04 st %g2, [ %g1 + 4 ]
40022a84: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
40022a88: 84 10 a0 0d or %g2, 0xd, %g2 ! deadf00d <LEON_REG+0x5eadf00d>
40022a8c: c4 20 60 08 st %g2, [ %g1 + 8 ]
40022a90: 05 18 03 43 sethi %hi(0x600d0c00), %g2
40022a94: 84 10 a1 06 or %g2, 0x106, %g2 ! 600d0d06 <RAM_END+0x1fcd0d06>
40022a98: 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) {
40022a9c: 03 10 01 92 sethi %hi(0x40064800), %g1
40022aa0: d0 00 61 40 ld [ %g1 + 0x140 ], %o0 ! 40064940 <_Per_CPU_Information>
40022aa4: 80 a2 20 00 cmp %o0, 0
40022aa8: 02 80 00 0c be 40022ad8 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40022aac: 84 10 61 40 or %g1, 0x140, %g2
40022ab0: d4 00 a0 04 ld [ %g2 + 4 ], %o2
40022ab4: 80 a2 a0 00 cmp %o2, 0
40022ab8: 02 80 00 08 be 40022ad8 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40022abc: 03 10 01 93 sethi %hi(0x40064c00), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
40022ac0: 84 10 62 7c or %g1, 0x27c, %g2 ! 40064e7c <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40022ac4: 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;
40022ac8: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40022acc: d4 20 62 7c st %o2, [ %g1 + 0x27c ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
40022ad0: 40 00 5f d0 call 4003aa10 <memset>
40022ad4: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
40022ad8: 84 10 20 01 mov 1, %g2
40022adc: 03 10 01 8e sethi %hi(0x40063800), %g1
40022ae0: c4 20 63 20 st %g2, [ %g1 + 0x320 ] ! 40063b20 <Stack_check_Initialized>
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
40022ae4: 80 a6 60 00 cmp %i1, 0
40022ae8: 02 80 00 06 be 40022b00 <rtems_stack_checker_create_extension+0xb0><== NEVER TAKEN
40022aec: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
40022af0: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
40022af4: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
40022af8: 40 00 5f c6 call 4003aa10 <memset>
40022afc: 92 10 20 a5 mov 0xa5, %o1
return true;
}
40022b00: 81 c7 e0 08 ret
40022b04: 91 e8 20 01 restore %g0, 1, %o0
40022c58 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
40022c58: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
40022c5c: 03 10 01 92 sethi %hi(0x40064800), %g1
40022c60: fa 00 61 50 ld [ %g1 + 0x150 ], %i5 ! 40064950 <_Per_CPU_Information+0x10>
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40022c64: d0 07 60 b8 ld [ %i5 + 0xb8 ], %o0
40022c68: 80 a7 80 08 cmp %fp, %o0
40022c6c: 0a 80 00 06 bcs 40022c84 <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
40022c70: b8 10 20 00 clr %i4
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
40022c74: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40022c78: 82 02 00 01 add %o0, %g1, %g1
40022c7c: 80 a0 40 1e cmp %g1, %fp
40022c80: 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 ) {
40022c84: 03 10 01 8e sethi %hi(0x40063800), %g1
40022c88: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 40063b20 <Stack_check_Initialized>
40022c8c: 80 a0 60 00 cmp %g1, 0
40022c90: 02 80 00 09 be 40022cb4 <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
40022c94: 92 10 20 01 mov 1, %o1
pattern_ok = (!memcmp(
40022c98: 90 02 20 08 add %o0, 8, %o0
40022c9c: 13 10 01 93 sethi %hi(0x40064c00), %o1
40022ca0: 94 10 20 10 mov 0x10, %o2
40022ca4: 40 00 5e a2 call 4003a72c <memcmp>
40022ca8: 92 12 62 6c or %o1, 0x26c, %o1
40022cac: 80 a0 00 08 cmp %g0, %o0
40022cb0: 92 60 3f ff subx %g0, -1, %o1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
40022cb4: 82 1a 60 01 xor %o1, 1, %g1
40022cb8: 80 88 60 ff btst 0xff, %g1
40022cbc: 12 80 00 05 bne 40022cd0 <rtems_stack_checker_is_blown+0x78><== NEVER TAKEN
40022cc0: b8 1f 20 01 xor %i4, 1, %i4
40022cc4: 80 8f 20 ff btst 0xff, %i4
40022cc8: 02 80 00 05 be 40022cdc <rtems_stack_checker_is_blown+0x84><== ALWAYS TAKEN
40022ccc: 01 00 00 00 nop
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
40022cd0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40022cd4: 7f ff ff 99 call 40022b38 <Stack_check_report_blown_task> <== NOT EXECUTED
40022cd8: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
40022cdc: 81 c7 e0 08 ret
40022ce0: 91 e8 20 00 restore %g0, 0, %o0
40022d44 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
40022d44: 13 10 00 94 sethi %hi(0x40025000), %o1 <== NOT EXECUTED
40022d48: 90 10 20 00 clr %o0 <== NOT EXECUTED
40022d4c: 92 12 62 14 or %o1, 0x214, %o1 <== NOT EXECUTED
40022d50: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40022d54: 7f ff ff e4 call 40022ce4 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
40022d58: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40022ce4 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40022ce4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( !print )
40022ce8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40022cec: 02 80 00 14 be 40022d3c <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
40022cf0: 39 10 01 8e sethi %hi(0x40063800), %i4 <== NOT EXECUTED
return;
print_context = context;
print_handler = print;
40022cf4: 3b 10 01 8e sethi %hi(0x40063800), %i5 <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
40022cf8: f0 27 23 24 st %i0, [ %i4 + 0x324 ] <== NOT EXECUTED
print_handler = print;
40022cfc: f2 27 63 28 st %i1, [ %i5 + 0x328 ] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
40022d00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40022d04: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
40022d08: 9f c6 40 00 call %i1 <== NOT EXECUTED
40022d0c: 92 12 61 40 or %o1, 0x140, %o1 ! 4005a940 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8><== NOT EXECUTED
(*print)( context,
40022d10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40022d14: 13 10 01 6a sethi %hi(0x4005a800), %o1 <== NOT EXECUTED
40022d18: 9f c6 40 00 call %i1 <== NOT EXECUTED
40022d1c: 92 12 61 58 or %o1, 0x158, %o1 ! 4005a958 <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 );
40022d20: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40022d24: 40 00 11 a7 call 400273c0 <rtems_iterate_over_all_threads><== NOT EXECUTED
40022d28: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400228e0 <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);
40022d2c: 7f ff fe ed call 400228e0 <Stack_check_Dump_threads_usage><== NOT EXECUTED
40022d30: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
#endif
print_context = NULL;
40022d34: c0 27 23 24 clr [ %i4 + 0x324 ] <== NOT EXECUTED
print_handler = NULL;
40022d38: c0 27 63 28 clr [ %i5 + 0x328 ] <== NOT EXECUTED
40022d3c: 81 c7 e0 08 ret <== NOT EXECUTED
40022d40: 81 e8 00 00 restore <== NOT EXECUTED
40022be8 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
40022be8: 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);
40022bec: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
40022bf0: ba 10 20 00 clr %i5
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40022bf4: 80 a7 80 01 cmp %fp, %g1
40022bf8: 0a 80 00 06 bcs 40022c10 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
40022bfc: 90 00 60 08 add %g1, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
40022c00: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
40022c04: 82 00 40 02 add %g1, %g2, %g1
40022c08: 80 a0 40 1e cmp %g1, %fp
40022c0c: 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,
40022c10: 13 10 01 93 sethi %hi(0x40064c00), %o1
40022c14: 94 10 20 10 mov 0x10, %o2
40022c18: 40 00 5e c5 call 4003a72c <memcmp>
40022c1c: 92 12 62 6c or %o1, 0x26c, %o1
40022c20: 80 a0 00 08 cmp %g0, %o0
40022c24: 82 60 3f ff subx %g0, -1, %g1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
40022c28: 80 a0 60 00 cmp %g1, 0
40022c2c: 02 80 00 06 be 40022c44 <rtems_stack_checker_switch_extension+0x5c><== NEVER TAKEN
40022c30: 92 10 00 01 mov %g1, %o1
40022c34: ba 1f 60 01 xor %i5, 1, %i5
40022c38: 80 8f 60 ff btst 0xff, %i5
40022c3c: 02 80 00 05 be 40022c50 <rtems_stack_checker_switch_extension+0x68><== ALWAYS TAKEN
40022c40: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
40022c44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40022c48: 7f ff ff bc call 40022b38 <Stack_check_report_blown_task> <== NOT EXECUTED
40022c4c: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
40022c50: 81 c7 e0 08 ret
40022c54: 81 e8 00 00 restore
4000e6a0 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4000e6a0: 9d e3 bf 98 save %sp, -104, %sp
double result;
char *end;
if ( !n )
4000e6a4: 80 a6 60 00 cmp %i1, 0
4000e6a8: 02 80 00 34 be 4000e778 <rtems_string_to_double+0xd8>
4000e6ac: b6 10 20 09 mov 9, %i3
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000e6b0: 40 00 0b 42 call 400113b8 <__errno>
4000e6b4: 01 00 00 00 nop
4000e6b8: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000e6bc: c0 26 40 00 clr [ %i1 ]
4000e6c0: c0 26 60 04 clr [ %i1 + 4 ]
result = strtod( s, &end );
4000e6c4: 90 10 00 18 mov %i0, %o0
4000e6c8: 40 00 16 bf call 400141c4 <strtod>
4000e6cc: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
4000e6d0: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4000e6d4: b8 10 00 08 mov %o0, %i4
4000e6d8: ba 10 00 09 mov %o1, %i5
if ( endptr )
4000e6dc: 02 80 00 03 be 4000e6e8 <rtems_string_to_double+0x48>
4000e6e0: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
4000e6e4: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000e6e8: 80 a0 40 18 cmp %g1, %i0
4000e6ec: 02 80 00 23 be 4000e778 <rtems_string_to_double+0xd8>
4000e6f0: b6 10 20 0b mov 0xb, %i3
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000e6f4: 40 00 0b 31 call 400113b8 <__errno>
4000e6f8: 01 00 00 00 nop
4000e6fc: c2 02 00 00 ld [ %o0 ], %g1
4000e700: 80 a0 60 22 cmp %g1, 0x22
4000e704: 32 80 00 1c bne,a 4000e774 <rtems_string_to_double+0xd4>
4000e708: f8 3e 40 00 std %i4, [ %i1 ]
4000e70c: 90 10 00 1c mov %i4, %o0
4000e710: 92 10 00 1d mov %i5, %o1
4000e714: 94 10 20 00 clr %o2
4000e718: 96 10 20 00 clr %o3
4000e71c: 40 00 41 35 call 4001ebf0 <__eqdf2>
4000e720: b6 10 20 0a mov 0xa, %i3
4000e724: 80 a2 20 00 cmp %o0, 0
4000e728: 02 80 00 14 be 4000e778 <rtems_string_to_double+0xd8> <== NEVER TAKEN
4000e72c: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000e730: 92 10 00 1d mov %i5, %o1
4000e734: 15 1f fb ff sethi %hi(0x7feffc00), %o2
4000e738: 96 10 3f ff mov -1, %o3
4000e73c: 40 00 41 43 call 4001ec48 <__gtdf2>
4000e740: 94 12 a3 ff or %o2, 0x3ff, %o2
4000e744: 80 a2 20 00 cmp %o0, 0
4000e748: 14 80 00 0c bg 4000e778 <rtems_string_to_double+0xd8>
4000e74c: 90 10 00 1c mov %i4, %o0
4000e750: 92 10 00 1d mov %i5, %o1
4000e754: 15 3f fb ff sethi %hi(0xffeffc00), %o2
4000e758: 96 10 3f ff mov -1, %o3
4000e75c: 40 00 41 67 call 4001ecf8 <__ltdf2>
4000e760: 94 12 a3 ff or %o2, 0x3ff, %o2
4000e764: 80 a2 20 00 cmp %o0, 0
4000e768: 06 80 00 04 bl 4000e778 <rtems_string_to_double+0xd8> <== ALWAYS TAKEN
4000e76c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000e770: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000e774: b6 10 20 00 clr %i3
}
4000e778: 81 c7 e0 08 ret
4000e77c: 91 e8 00 1b restore %g0, %i3, %o0
4000e780 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4000e780: 9d e3 bf 98 save %sp, -104, %sp
float result;
char *end;
if ( !n )
4000e784: 80 a6 60 00 cmp %i1, 0
4000e788: 02 80 00 2c be 4000e838 <rtems_string_to_float+0xb8>
4000e78c: b8 10 20 09 mov 9, %i4
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000e790: 40 00 0b 0a call 400113b8 <__errno>
4000e794: 01 00 00 00 nop
4000e798: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000e79c: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
4000e7a0: 90 10 00 18 mov %i0, %o0
4000e7a4: 40 00 16 8f call 400141e0 <strtof>
4000e7a8: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
4000e7ac: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
4000e7b0: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000e7b4: 02 80 00 03 be 4000e7c0 <rtems_string_to_float+0x40>
4000e7b8: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
4000e7bc: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000e7c0: 80 a0 40 18 cmp %g1, %i0
4000e7c4: 02 80 00 1d be 4000e838 <rtems_string_to_float+0xb8>
4000e7c8: b8 10 20 0b mov 0xb, %i4
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000e7cc: 40 00 0a fb call 400113b8 <__errno>
4000e7d0: 01 00 00 00 nop
4000e7d4: c2 02 00 00 ld [ %o0 ], %g1
4000e7d8: 80 a0 60 22 cmp %g1, 0x22
4000e7dc: 32 80 00 16 bne,a 4000e834 <rtems_string_to_float+0xb4>
4000e7e0: fa 26 40 00 st %i5, [ %i1 ]
4000e7e4: 90 10 00 1d mov %i5, %o0
4000e7e8: 92 10 20 00 clr %o1
4000e7ec: 40 00 3e 5c call 4001e15c <__eqsf2>
4000e7f0: b8 10 20 0a mov 0xa, %i4
4000e7f4: 80 a2 20 00 cmp %o0, 0
4000e7f8: 02 80 00 10 be 4000e838 <rtems_string_to_float+0xb8> <== NEVER TAKEN
4000e7fc: 90 10 00 1d mov %i5, %o0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000e800: 13 1f df ff sethi %hi(0x7f7ffc00), %o1
4000e804: 40 00 3e 6b call 4001e1b0 <__gtsf2>
4000e808: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7f7fffff <RAM_END+0x3f3fffff>
4000e80c: 80 a2 20 00 cmp %o0, 0
4000e810: 14 80 00 0a bg 4000e838 <rtems_string_to_float+0xb8>
4000e814: 90 10 00 1d mov %i5, %o0
4000e818: 13 3f df ff sethi %hi(0xff7ffc00), %o1
4000e81c: 40 00 3e 7a call 4001e204 <__ltsf2>
4000e820: 92 12 63 ff or %o1, 0x3ff, %o1 ! ff7fffff <LEON_REG+0x7f7fffff>
4000e824: 80 a2 20 00 cmp %o0, 0
4000e828: 06 80 00 04 bl 4000e838 <rtems_string_to_float+0xb8> <== ALWAYS TAKEN
4000e82c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000e830: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000e834: b8 10 20 00 clr %i4
}
4000e838: 81 c7 e0 08 ret
4000e83c: 91 e8 00 1c restore %g0, %i4, %o0
4001da94 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4001da94: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4001da98: 80 a6 60 00 cmp %i1, 0
4001da9c: 02 80 00 25 be 4001db30 <rtems_string_to_int+0x9c>
4001daa0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4001daa4: 40 00 65 fd call 40037298 <__errno>
4001daa8: 01 00 00 00 nop
4001daac: c0 22 00 00 clr [ %o0 ]
*n = 0;
4001dab0: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4001dab4: 90 10 00 18 mov %i0, %o0
4001dab8: 92 07 bf fc add %fp, -4, %o1
4001dabc: 40 00 86 f3 call 4003f688 <strtol>
4001dac0: 94 10 00 1b mov %i3, %o2
if ( endptr )
4001dac4: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4001dac8: ba 10 00 08 mov %o0, %i5
if ( endptr )
4001dacc: 02 80 00 03 be 4001dad8 <rtems_string_to_int+0x44>
4001dad0: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4001dad4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4001dad8: 80 a0 80 18 cmp %g2, %i0
4001dadc: 02 80 00 15 be 4001db30 <rtems_string_to_int+0x9c>
4001dae0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001dae4: 40 00 65 ed call 40037298 <__errno>
4001dae8: 01 00 00 00 nop
4001daec: c2 02 00 00 ld [ %o0 ], %g1
4001daf0: 80 a0 60 22 cmp %g1, 0x22
4001daf4: 32 80 00 0e bne,a 4001db2c <rtems_string_to_int+0x98>
4001daf8: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001dafc: 03 20 00 00 sethi %hi(0x80000000), %g1
4001db00: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001db04: 80 a0 60 00 cmp %g1, 0
4001db08: 02 80 00 0a be 4001db30 <rtems_string_to_int+0x9c>
4001db0c: 82 10 20 0a mov 0xa, %g1
4001db10: 80 a7 60 00 cmp %i5, 0
4001db14: 02 80 00 07 be 4001db30 <rtems_string_to_int+0x9c> <== NEVER TAKEN
4001db18: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001db1c: 80 a7 40 02 cmp %i5, %g2
4001db20: 02 80 00 04 be 4001db30 <rtems_string_to_int+0x9c> <== ALWAYS TAKEN
4001db24: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4001db28: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4001db2c: 82 10 20 00 clr %g1
}
4001db30: 81 c7 e0 08 ret
4001db34: 91 e8 00 01 restore %g0, %g1, %o0
4000e9b0 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4000e9b0: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4000e9b4: 80 a6 60 00 cmp %i1, 0
4000e9b8: 02 80 00 25 be 4000ea4c <rtems_string_to_long+0x9c>
4000e9bc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000e9c0: 40 00 0a 7e call 400113b8 <__errno>
4000e9c4: 01 00 00 00 nop
4000e9c8: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000e9cc: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000e9d0: 90 10 00 18 mov %i0, %o0
4000e9d4: 92 07 bf fc add %fp, -4, %o1
4000e9d8: 40 00 16 a3 call 40014464 <strtol>
4000e9dc: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000e9e0: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4000e9e4: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000e9e8: 02 80 00 03 be 4000e9f4 <rtems_string_to_long+0x44>
4000e9ec: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000e9f0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000e9f4: 80 a0 80 18 cmp %g2, %i0
4000e9f8: 02 80 00 15 be 4000ea4c <rtems_string_to_long+0x9c>
4000e9fc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ea00: 40 00 0a 6e call 400113b8 <__errno>
4000ea04: 01 00 00 00 nop
4000ea08: c2 02 00 00 ld [ %o0 ], %g1
4000ea0c: 80 a0 60 22 cmp %g1, 0x22
4000ea10: 32 80 00 0e bne,a 4000ea48 <rtems_string_to_long+0x98>
4000ea14: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000ea18: 03 20 00 00 sethi %hi(0x80000000), %g1
4000ea1c: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ea20: 80 a0 60 00 cmp %g1, 0
4000ea24: 02 80 00 0a be 4000ea4c <rtems_string_to_long+0x9c>
4000ea28: 82 10 20 0a mov 0xa, %g1
4000ea2c: 80 a7 60 00 cmp %i5, 0
4000ea30: 02 80 00 07 be 4000ea4c <rtems_string_to_long+0x9c> <== NEVER TAKEN
4000ea34: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000ea38: 80 a7 40 02 cmp %i5, %g2
4000ea3c: 02 80 00 04 be 4000ea4c <rtems_string_to_long+0x9c> <== ALWAYS TAKEN
4000ea40: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000ea44: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000ea48: 82 10 20 00 clr %g1
}
4000ea4c: 81 c7 e0 08 ret
4000ea50: 91 e8 00 01 restore %g0, %g1, %o0
4000e8e4 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4000e8e4: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
4000e8e8: 80 a6 60 00 cmp %i1, 0
4000e8ec: 02 80 00 2f be 4000e9a8 <rtems_string_to_long_long+0xc4>
4000e8f0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000e8f4: 40 00 0a b1 call 400113b8 <__errno>
4000e8f8: 01 00 00 00 nop
4000e8fc: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000e900: c0 26 40 00 clr [ %i1 ]
4000e904: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
4000e908: 90 10 00 18 mov %i0, %o0
4000e90c: 92 07 bf fc add %fp, -4, %o1
4000e910: 40 00 16 de call 40014488 <strtoll>
4000e914: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000e918: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4000e91c: b8 10 00 08 mov %o0, %i4
4000e920: ba 10 00 09 mov %o1, %i5
if ( endptr )
4000e924: 02 80 00 03 be 4000e930 <rtems_string_to_long_long+0x4c>
4000e928: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000e92c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000e930: 80 a0 80 18 cmp %g2, %i0
4000e934: 02 80 00 1d be 4000e9a8 <rtems_string_to_long_long+0xc4>
4000e938: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000e93c: 40 00 0a 9f call 400113b8 <__errno>
4000e940: 01 00 00 00 nop
4000e944: c2 02 00 00 ld [ %o0 ], %g1
4000e948: 80 a0 60 22 cmp %g1, 0x22
4000e94c: 32 80 00 16 bne,a 4000e9a4 <rtems_string_to_long_long+0xc0>
4000e950: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000e954: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
4000e958: 07 3f ff ff sethi %hi(0xfffffc00), %g3
4000e95c: 84 10 a3 ff or %g2, 0x3ff, %g2
4000e960: 86 10 e3 ff or %g3, 0x3ff, %g3
4000e964: 84 1f 00 02 xor %i4, %g2, %g2
4000e968: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000e96c: 80 90 80 03 orcc %g2, %g3, %g0
4000e970: 02 80 00 0e be 4000e9a8 <rtems_string_to_long_long+0xc4>
4000e974: 82 10 20 0a mov 0xa, %g1
4000e978: 80 97 00 1d orcc %i4, %i5, %g0
4000e97c: 02 80 00 0b be 4000e9a8 <rtems_string_to_long_long+0xc4> <== NEVER TAKEN
4000e980: 01 00 00 00 nop
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000e984: 03 20 00 00 sethi %hi(0x80000000), %g1
4000e988: 80 a7 00 01 cmp %i4, %g1
4000e98c: 32 80 00 06 bne,a 4000e9a4 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
4000e990: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000e994: 80 a7 60 00 cmp %i5, 0
4000e998: 22 80 00 04 be,a 4000e9a8 <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
4000e99c: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
4000e9a0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000e9a4: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
}
4000e9a8: 81 c7 e0 08 ret
4000e9ac: 91 e8 00 01 restore %g0, %g1, %o0
4001db48 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4001db48: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4001db4c: 80 a6 60 00 cmp %i1, 0
4001db50: 02 80 00 26 be 4001dbe8 <rtems_string_to_unsigned_char+0xa0>
4001db54: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4001db58: 40 00 65 d0 call 40037298 <__errno>
4001db5c: 01 00 00 00 nop
4001db60: c0 22 00 00 clr [ %o0 ]
*n = 0;
4001db64: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
4001db68: 90 10 00 18 mov %i0, %o0
4001db6c: 92 07 bf fc add %fp, -4, %o1
4001db70: 40 00 88 14 call 4003fbc0 <strtoul>
4001db74: 94 10 00 1b mov %i3, %o2
if ( endptr )
4001db78: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4001db7c: ba 10 00 08 mov %o0, %i5
if ( endptr )
4001db80: 02 80 00 03 be 4001db8c <rtems_string_to_unsigned_char+0x44>
4001db84: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4001db88: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4001db8c: 80 a0 80 18 cmp %g2, %i0
4001db90: 02 80 00 16 be 4001dbe8 <rtems_string_to_unsigned_char+0xa0>
4001db94: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001db98: 40 00 65 c0 call 40037298 <__errno>
4001db9c: 01 00 00 00 nop
4001dba0: c2 02 00 00 ld [ %o0 ], %g1
4001dba4: 80 a0 60 22 cmp %g1, 0x22
4001dba8: 12 80 00 07 bne 4001dbc4 <rtems_string_to_unsigned_char+0x7c>
4001dbac: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
4001dbb0: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001dbb4: 80 a0 bf fd cmp %g2, -3
4001dbb8: 18 80 00 0c bgu 4001dbe8 <rtems_string_to_unsigned_char+0xa0><== ALWAYS TAKEN
4001dbbc: 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 ) {
4001dbc0: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
4001dbc4: 28 80 00 08 bleu,a 4001dbe4 <rtems_string_to_unsigned_char+0x9c>
4001dbc8: fa 2e 40 00 stb %i5, [ %i1 ]
errno = ERANGE;
4001dbcc: 40 00 65 b3 call 40037298 <__errno>
4001dbd0: 01 00 00 00 nop
4001dbd4: 82 10 20 22 mov 0x22, %g1 ! 22 <PROM_START+0x22>
4001dbd8: c2 22 00 00 st %g1, [ %o0 ]
return RTEMS_INVALID_NUMBER;
4001dbdc: 10 80 00 03 b 4001dbe8 <rtems_string_to_unsigned_char+0xa0>
4001dbe0: 82 10 20 0a mov 0xa, %g1
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
4001dbe4: 82 10 20 00 clr %g1
}
4001dbe8: 81 c7 e0 08 ret
4001dbec: 91 e8 00 01 restore %g0, %g1, %o0
4000eb0c <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4000eb0c: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000eb10: 80 a6 60 00 cmp %i1, 0
4000eb14: 02 80 00 1e be 4000eb8c <rtems_string_to_unsigned_int+0x80>
4000eb18: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000eb1c: 40 00 0a 27 call 400113b8 <__errno>
4000eb20: 01 00 00 00 nop
4000eb24: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000eb28: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000eb2c: 90 10 00 18 mov %i0, %o0
4000eb30: 92 07 bf fc add %fp, -4, %o1
4000eb34: 40 00 17 9a call 4001499c <strtoul>
4000eb38: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000eb3c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4000eb40: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000eb44: 02 80 00 03 be 4000eb50 <rtems_string_to_unsigned_int+0x44>
4000eb48: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000eb4c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000eb50: 80 a0 80 18 cmp %g2, %i0
4000eb54: 02 80 00 0e be 4000eb8c <rtems_string_to_unsigned_int+0x80>
4000eb58: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000eb5c: 40 00 0a 17 call 400113b8 <__errno>
4000eb60: 01 00 00 00 nop
4000eb64: c2 02 00 00 ld [ %o0 ], %g1
4000eb68: 80 a0 60 22 cmp %g1, 0x22
4000eb6c: 32 80 00 07 bne,a 4000eb88 <rtems_string_to_unsigned_int+0x7c>
4000eb70: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
4000eb74: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000eb78: 80 a0 bf fd cmp %g2, -3
4000eb7c: 18 80 00 04 bgu 4000eb8c <rtems_string_to_unsigned_int+0x80><== ALWAYS TAKEN
4000eb80: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000eb84: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000eb88: 82 10 20 00 clr %g1
}
4000eb8c: 81 c7 e0 08 ret
4000eb90: 91 e8 00 01 restore %g0, %g1, %o0
4000bddc <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4000bddc: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000bde0: 80 a6 60 00 cmp %i1, 0
4000bde4: 02 80 00 1e be 4000be5c <rtems_string_to_unsigned_long+0x80>
4000bde8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000bdec: 40 00 ad 2b call 40037298 <__errno>
4000bdf0: 01 00 00 00 nop
4000bdf4: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000bdf8: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000bdfc: 90 10 00 18 mov %i0, %o0
4000be00: 92 07 bf fc add %fp, -4, %o1
4000be04: 40 00 cf 6f call 4003fbc0 <strtoul>
4000be08: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000be0c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4000be10: ba 10 00 08 mov %o0, %i5
if ( endptr )
4000be14: 02 80 00 03 be 4000be20 <rtems_string_to_unsigned_long+0x44>
4000be18: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000be1c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000be20: 80 a0 80 18 cmp %g2, %i0
4000be24: 02 80 00 0e be 4000be5c <rtems_string_to_unsigned_long+0x80>
4000be28: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000be2c: 40 00 ad 1b call 40037298 <__errno>
4000be30: 01 00 00 00 nop
4000be34: c2 02 00 00 ld [ %o0 ], %g1
4000be38: 80 a0 60 22 cmp %g1, 0x22
4000be3c: 32 80 00 07 bne,a 4000be58 <rtems_string_to_unsigned_long+0x7c>
4000be40: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
4000be44: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000be48: 80 a0 bf fd cmp %g2, -3
4000be4c: 18 80 00 04 bgu 4000be5c <rtems_string_to_unsigned_long+0x80><== ALWAYS TAKEN
4000be50: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000be54: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000be58: 82 10 20 00 clr %g1
}
4000be5c: 81 c7 e0 08 ret
4000be60: 91 e8 00 01 restore %g0, %g1, %o0
4000eb94 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4000eb94: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
4000eb98: 80 a6 60 00 cmp %i1, 0
4000eb9c: 02 80 00 23 be 4000ec28 <rtems_string_to_unsigned_long_long+0x94>
4000eba0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000eba4: 40 00 0a 05 call 400113b8 <__errno>
4000eba8: 01 00 00 00 nop
4000ebac: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000ebb0: c0 26 40 00 clr [ %i1 ]
4000ebb4: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
4000ebb8: 90 10 00 18 mov %i0, %o0
4000ebbc: 92 07 bf fc add %fp, -4, %o1
4000ebc0: 40 00 17 80 call 400149c0 <strtoull>
4000ebc4: 94 10 00 1b mov %i3, %o2
if ( endptr )
4000ebc8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4000ebcc: b8 10 00 08 mov %o0, %i4
4000ebd0: ba 10 00 09 mov %o1, %i5
if ( endptr )
4000ebd4: 02 80 00 03 be 4000ebe0 <rtems_string_to_unsigned_long_long+0x4c>
4000ebd8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000ebdc: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000ebe0: 80 a0 80 18 cmp %g2, %i0
4000ebe4: 02 80 00 11 be 4000ec28 <rtems_string_to_unsigned_long_long+0x94>
4000ebe8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ebec: 40 00 09 f3 call 400113b8 <__errno>
4000ebf0: 01 00 00 00 nop
4000ebf4: c2 02 00 00 ld [ %o0 ], %g1
4000ebf8: 80 a0 60 22 cmp %g1, 0x22
4000ebfc: 32 80 00 0a bne,a 4000ec24 <rtems_string_to_unsigned_long_long+0x90>
4000ec00: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4000ec04: 86 87 7f ff addcc %i5, -1, %g3
4000ec08: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ec0c: 80 a0 bf ff cmp %g2, -1
4000ec10: 12 80 00 04 bne 4000ec20 <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
4000ec14: 80 a0 ff fd cmp %g3, -3
4000ec18: 18 80 00 04 bgu 4000ec28 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
4000ec1c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000ec20: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000ec24: 82 10 20 00 clr %g1
}
4000ec28: 81 c7 e0 08 ret
4000ec2c: 91 e8 00 01 restore %g0, %g1, %o0
40003a90 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
40003a90: 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 =
40003a94: 94 10 20 18 mov 0x18, %o2
40003a98: 92 10 00 18 mov %i0, %o1
40003a9c: 40 00 07 b4 call 4000596c <rtems_filesystem_eval_path_start>
40003aa0: 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(
40003aa4: 92 07 be 78 add %fp, -392, %o1
40003aa8: b6 10 00 08 mov %o0, %i3
40003aac: 40 00 08 aa call 40005d54 <rtems_filesystem_location_copy_and_detach>
40003ab0: 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;
40003ab4: 82 10 20 60 mov 0x60, %g1
40003ab8: c2 27 be 70 st %g1, [ %fp + -400 ]
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
40003abc: c2 07 be 5c ld [ %fp + -420 ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40003ac0: 05 10 00 85 sethi %hi(0x40021400), %g2
rootloc.mt_entry->ops != &IMFS_ops
40003ac4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40003ac8: 84 10 a3 d8 or %g2, 0x3d8, %g2
40003acc: 80 a0 40 02 cmp %g1, %g2
40003ad0: 02 80 00 06 be 40003ae8 <rtems_tarfs_load+0x58>
40003ad4: 05 10 00 88 sethi %hi(0x40022000), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
40003ad8: 84 10 a3 18 or %g2, 0x318, %g2 ! 40022318 <fifoIMFS_ops>
40003adc: 80 a0 40 02 cmp %g1, %g2
40003ae0: 32 80 00 66 bne,a 40003c78 <rtems_tarfs_load+0x1e8> <== ALWAYS TAKEN
40003ae4: 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))
40003ae8: 25 10 00 86 sethi %hi(0x40021800), %l2
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40003aec: 27 10 00 88 sethi %hi(0x40022000), %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, "/");
40003af0: 29 10 00 7a sethi %hi(0x4001e800), %l4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40003af4: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
40003af8: a4 14 a0 60 or %l2, 0x60, %l2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
40003afc: a0 07 be 98 add %fp, -360, %l0
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40003b00: a6 14 e0 74 or %l3, 0x74, %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, "/");
40003b04: a8 15 22 80 or %l4, 0x280, %l4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
40003b08: b8 07 62 00 add %i5, 0x200, %i4
40003b0c: 80 a7 00 1a cmp %i4, %i2
40003b10: 18 80 00 59 bgu 40003c74 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
40003b14: 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))
40003b18: 92 10 00 12 mov %l2, %o1
40003b1c: 90 07 61 01 add %i5, 0x101, %o0
40003b20: 40 00 42 8f call 4001455c <strncmp>
40003b24: 94 10 20 05 mov 5, %o2
40003b28: 80 a2 20 00 cmp %o0, 0
40003b2c: 12 80 00 52 bne 40003c74 <rtems_tarfs_load+0x1e4>
40003b30: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
40003b34: 92 10 00 1d mov %i5, %o1
40003b38: 40 00 42 df call 400146b4 <strncpy>
40003b3c: 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);
40003b40: 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';
40003b44: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
40003b48: ec 0f 60 9c ldub [ %i5 + 0x9c ], %l6
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
40003b4c: 40 00 21 c4 call 4000c25c <_rtems_octal2ulong>
40003b50: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40003b54: 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);
40003b58: aa 10 00 08 mov %o0, %l5
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40003b5c: 40 00 21 c0 call 4000c25c <_rtems_octal2ulong>
40003b60: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40003b64: 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);
40003b68: a2 10 00 08 mov %o0, %l1
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40003b6c: 40 00 21 bc call 4000c25c <_rtems_octal2ulong>
40003b70: 90 07 60 94 add %i5, 0x94, %o0
40003b74: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
40003b78: 40 00 21 cc call 4000c2a8 <_rtems_tar_header_checksum>
40003b7c: 90 10 00 1d mov %i5, %o0
40003b80: 80 a2 00 17 cmp %o0, %l7
40003b84: 12 80 00 3c bne 40003c74 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
40003b88: 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) {
40003b8c: 80 a0 60 35 cmp %g1, 0x35
40003b90: 12 80 00 16 bne 40003be8 <rtems_tarfs_load+0x158>
40003b94: 80 a0 60 30 cmp %g1, 0x30
strcpy(full_filename, mountpoint);
40003b98: 92 10 00 18 mov %i0, %o1
40003b9c: 40 00 40 7c call 40013d8c <strcpy>
40003ba0: 90 07 bf 00 add %fp, -256, %o0
if (full_filename[strlen(full_filename)-1] != '/')
40003ba4: 40 00 42 3c call 40014494 <strlen>
40003ba8: 90 07 bf 00 add %fp, -256, %o0
40003bac: 90 07 80 08 add %fp, %o0, %o0
40003bb0: c2 4a 3e ff ldsb [ %o0 + -257 ], %g1
40003bb4: 80 a0 60 2f cmp %g1, 0x2f
40003bb8: 02 80 00 04 be 40003bc8 <rtems_tarfs_load+0x138> <== ALWAYS TAKEN
40003bbc: 90 07 bf 00 add %fp, -256, %o0
strcat(full_filename, "/");
40003bc0: 40 00 40 22 call 40013c48 <strcat> <== NOT EXECUTED
40003bc4: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
strcat(full_filename, filename);
40003bc8: 92 10 00 10 mov %l0, %o1
40003bcc: 40 00 40 1f call 40013c48 <strcat>
40003bd0: 90 07 bf 00 add %fp, -256, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
40003bd4: 90 07 bf 00 add %fp, -256, %o0
40003bd8: 40 00 03 f0 call 40004b98 <mkdir>
40003bdc: 92 10 21 ff mov 0x1ff, %o1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40003be0: 10 bf ff ca b 40003b08 <rtems_tarfs_load+0x78>
40003be4: 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) {
40003be8: 12 bf ff c8 bne 40003b08 <rtems_tarfs_load+0x78>
40003bec: ba 10 00 1c mov %i4, %i5
rtems_filesystem_location_free( currentloc );
40003bf0: 40 00 02 53 call 4000453c <rtems_filesystem_location_free>
40003bf4: 90 10 00 1b mov %i3, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
40003bf8: 92 07 be 48 add %fp, -440, %o1
40003bfc: 40 00 01 81 call 40004200 <rtems_filesystem_location_clone>
40003c00: 90 10 00 1b mov %i3, %o0
rtems_filesystem_eval_path_set_path(
40003c04: 40 00 42 24 call 40014494 <strlen>
40003c08: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
40003c0c: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
40003c10: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
40003c14: 40 00 06 f8 call 400057f4 <rtems_filesystem_eval_path_continue>
40003c18: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40003c1c: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
40003c20: 80 a0 40 13 cmp %g1, %l3
40003c24: 02 80 00 0f be 40003c60 <rtems_tarfs_load+0x1d0> <== NEVER TAKEN
40003c28: 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 =
40003c2c: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40003c30: 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,
40003c34: 98 0d 61 ff and %l5, 0x1ff, %o4
40003c38: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
40003c3c: 03 00 00 20 sethi %hi(0x8000), %g1
40003c40: 90 10 00 1b mov %i3, %o0
40003c44: 98 13 00 01 or %o4, %g1, %o4
40003c48: 40 00 23 31 call 4000c90c <IMFS_create_node_with_control>
40003c4c: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
40003c50: 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;
40003c54: c0 22 20 50 clr [ %o0 + 0x50 ]
40003c58: e2 22 20 54 st %l1, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
40003c5c: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
40003c60: a2 04 61 ff add %l1, 0x1ff, %l1
offset += 512 * nblocks;
40003c64: a2 0c 7e 00 and %l1, -512, %l1
40003c68: b8 04 40 1c add %l1, %i4, %i4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40003c6c: 10 bf ff a7 b 40003b08 <rtems_tarfs_load+0x78>
40003c70: 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)
40003c74: b0 10 20 00 clr %i0
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
40003c78: 40 00 02 31 call 4000453c <rtems_filesystem_location_free>
40003c7c: 90 07 be 48 add %fp, -440, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40003c80: 40 00 07 77 call 40005a5c <rtems_filesystem_eval_path_cleanup>
40003c84: 90 07 be 60 add %fp, -416, %o0
return rv;
}
40003c88: 81 c7 e0 08 ret
40003c8c: 81 e8 00 00 restore
40011a60 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
40011a60: 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 )
40011a64: 80 a6 a0 00 cmp %i2, 0
40011a68: 02 80 00 5a be 40011bd0 <rtems_task_mode+0x170>
40011a6c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
40011a70: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40011a74: f8 00 62 60 ld [ %g1 + 0x260 ], %i4 ! 4001be60 <_Per_CPU_Information+0x10>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40011a78: 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 ];
40011a7c: fa 07 21 4c ld [ %i4 + 0x14c ], %i5
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40011a80: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
40011a84: 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;
40011a88: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
40011a8c: 80 a0 60 00 cmp %g1, 0
40011a90: 02 80 00 03 be 40011a9c <rtems_task_mode+0x3c>
40011a94: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
40011a98: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40011a9c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
40011aa0: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
40011aa4: 7f ff ed 50 call 4000cfe4 <_CPU_ISR_Get_level>
40011aa8: 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;
40011aac: a1 2c 20 0a sll %l0, 0xa, %l0
40011ab0: 90 14 00 08 or %l0, %o0, %o0
old_mode |= _ISR_Get_level();
40011ab4: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
40011ab8: 80 8e 61 00 btst 0x100, %i1
40011abc: 02 80 00 06 be 40011ad4 <rtems_task_mode+0x74>
40011ac0: 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;
40011ac4: 83 36 20 08 srl %i0, 8, %g1
40011ac8: 82 18 60 01 xor %g1, 1, %g1
40011acc: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
40011ad0: c2 2f 20 70 stb %g1, [ %i4 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
40011ad4: 80 8e 62 00 btst 0x200, %i1
40011ad8: 02 80 00 0b be 40011b04 <rtems_task_mode+0xa4>
40011adc: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
40011ae0: 80 8e 22 00 btst 0x200, %i0
40011ae4: 22 80 00 07 be,a 40011b00 <rtems_task_mode+0xa0>
40011ae8: c0 27 20 78 clr [ %i4 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
40011aec: 82 10 20 01 mov 1, %g1
40011af0: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
40011af4: 03 10 00 6e sethi %hi(0x4001b800), %g1
40011af8: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 4001b8a0 <_Thread_Ticks_per_timeslice>
40011afc: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40011b00: 80 8e 60 0f btst 0xf, %i1
40011b04: 02 80 00 06 be 40011b1c <rtems_task_mode+0xbc>
40011b08: 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 );
40011b0c: 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 ) );
40011b10: 7f ff c4 55 call 40002c64 <sparc_enable_interrupts>
40011b14: 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 ) {
40011b18: 80 8e 64 00 btst 0x400, %i1
40011b1c: 02 80 00 14 be 40011b6c <rtems_task_mode+0x10c>
40011b20: 88 10 20 00 clr %g4
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
40011b24: 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;
40011b28: b1 36 20 0a srl %i0, 0xa, %i0
40011b2c: b0 1e 20 01 xor %i0, 1, %i0
40011b30: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
40011b34: 80 a6 00 01 cmp %i0, %g1
40011b38: 22 80 00 0e be,a 40011b70 <rtems_task_mode+0x110>
40011b3c: 03 10 00 6f sethi %hi(0x4001bc00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
40011b40: 7f ff c4 45 call 40002c54 <sparc_disable_interrupts>
40011b44: f0 2f 60 08 stb %i0, [ %i5 + 8 ]
_signals = information->signals_pending;
40011b48: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
40011b4c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
information->signals_posted = _signals;
40011b50: 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;
40011b54: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
40011b58: 7f ff c4 43 call 40002c64 <sparc_enable_interrupts>
40011b5c: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
40011b60: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40011b64: 80 a0 00 01 cmp %g0, %g1
40011b68: 88 40 20 00 addx %g0, 0, %g4
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
40011b6c: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40011b70: c4 00 62 48 ld [ %g1 + 0x248 ], %g2 ! 4001be48 <_System_state_Current>
40011b74: 80 a0 a0 03 cmp %g2, 3
40011b78: 12 80 00 16 bne 40011bd0 <rtems_task_mode+0x170>
40011b7c: 82 10 20 00 clr %g1
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40011b80: 07 10 00 6f sethi %hi(0x4001bc00), %g3
if ( are_signals_pending ||
40011b84: 80 89 20 ff btst 0xff, %g4
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40011b88: 86 10 e2 50 or %g3, 0x250, %g3
if ( are_signals_pending ||
40011b8c: 12 80 00 0a bne 40011bb4 <rtems_task_mode+0x154>
40011b90: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
40011b94: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3
40011b98: 80 a0 80 03 cmp %g2, %g3
40011b9c: 02 80 00 0d be 40011bd0 <rtems_task_mode+0x170>
40011ba0: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
40011ba4: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
40011ba8: 80 a0 a0 00 cmp %g2, 0
40011bac: 02 80 00 09 be 40011bd0 <rtems_task_mode+0x170> <== NEVER TAKEN
40011bb0: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
40011bb4: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
40011bb8: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40011bbc: 82 10 62 50 or %g1, 0x250, %g1 ! 4001be50 <_Per_CPU_Information>
40011bc0: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
40011bc4: 7f ff e8 41 call 4000bcc8 <_Thread_Dispatch>
40011bc8: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
40011bcc: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
40011bd0: 81 c7 e0 08 ret
40011bd4: 91 e8 00 01 restore %g0, %g1, %o0
4000c548 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
4000c548: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
4000c54c: 80 a6 60 00 cmp %i1, 0
4000c550: 02 80 00 08 be 4000c570 <rtems_task_set_priority+0x28>
4000c554: 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 ) );
4000c558: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000c55c: c4 08 61 8c ldub [ %g1 + 0x18c ], %g2 ! 4001a98c <rtems_maximum_priority>
4000c560: 80 a6 40 02 cmp %i1, %g2
4000c564: 18 80 00 1e bgu 4000c5dc <rtems_task_set_priority+0x94>
4000c568: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4000c56c: 80 a6 a0 00 cmp %i2, 0
4000c570: 02 80 00 1b be 4000c5dc <rtems_task_set_priority+0x94>
4000c574: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4000c578: 90 10 00 18 mov %i0, %o0
4000c57c: 40 00 09 7c call 4000eb6c <_Thread_Get>
4000c580: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000c584: c2 07 bf fc ld [ %fp + -4 ], %g1
4000c588: 80 a0 60 00 cmp %g1, 0
4000c58c: 12 80 00 14 bne 4000c5dc <rtems_task_set_priority+0x94>
4000c590: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4000c594: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4000c598: 80 a6 60 00 cmp %i1, 0
4000c59c: 02 80 00 0d be 4000c5d0 <rtems_task_set_priority+0x88>
4000c5a0: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
4000c5a4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000c5a8: 80 a0 60 00 cmp %g1, 0
4000c5ac: 02 80 00 06 be 4000c5c4 <rtems_task_set_priority+0x7c>
4000c5b0: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
4000c5b4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000c5b8: 80 a0 40 19 cmp %g1, %i1
4000c5bc: 08 80 00 05 bleu 4000c5d0 <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
4000c5c0: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
4000c5c4: 92 10 00 19 mov %i1, %o1
4000c5c8: 40 00 08 43 call 4000e6d4 <_Thread_Change_priority>
4000c5cc: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
4000c5d0: 40 00 09 5b call 4000eb3c <_Thread_Enable_dispatch>
4000c5d4: 01 00 00 00 nop
4000c5d8: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000c5dc: 81 c7 e0 08 ret
4000c5e0: 91 e8 00 01 restore %g0, %g1, %o0
40006b98 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
40006b98: 82 10 00 08 mov %o0, %g1
int baud_index;
switch (termios_baud) {
40006b9c: 80 a0 60 09 cmp %g1, 9
40006ba0: 02 80 00 17 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006ba4: 90 10 20 09 mov 9, %o0
40006ba8: 80 a0 60 09 cmp %g1, 9
40006bac: 18 80 00 23 bgu 40006c38 <rtems_termios_baud_to_index+0xa0>
40006bb0: 80 a0 60 0e cmp %g1, 0xe
40006bb4: 80 a0 60 04 cmp %g1, 4
40006bb8: 02 80 00 11 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006bbc: 90 10 20 04 mov 4, %o0
40006bc0: 80 a0 60 04 cmp %g1, 4
40006bc4: 18 80 00 10 bgu 40006c04 <rtems_termios_baud_to_index+0x6c>
40006bc8: 80 a0 60 06 cmp %g1, 6
40006bcc: 80 a0 60 01 cmp %g1, 1
40006bd0: 02 80 00 0b be 40006bfc <rtems_termios_baud_to_index+0x64>
40006bd4: 90 10 20 01 mov 1, %o0
40006bd8: 80 a0 60 01 cmp %g1, 1
40006bdc: 0a 80 00 08 bcs 40006bfc <rtems_termios_baud_to_index+0x64>
40006be0: 90 10 20 00 clr %o0
40006be4: 80 a0 60 02 cmp %g1, 2
40006be8: 02 80 00 05 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006bec: 90 10 20 02 mov 2, %o0
40006bf0: 80 a0 60 03 cmp %g1, 3
40006bf4: 12 80 00 3b bne 40006ce0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40006bf8: 90 10 20 03 mov 3, %o0
40006bfc: 81 c3 e0 08 retl
40006c00: 01 00 00 00 nop
40006c04: 02 bf ff fe be 40006bfc <rtems_termios_baud_to_index+0x64>
40006c08: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6>
40006c0c: 80 a0 60 06 cmp %g1, 6
40006c10: 0a bf ff fb bcs 40006bfc <rtems_termios_baud_to_index+0x64>
40006c14: 90 10 20 05 mov 5, %o0
40006c18: 80 a0 60 07 cmp %g1, 7
40006c1c: 02 bf ff f8 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006c20: 90 10 20 07 mov 7, %o0
40006c24: 80 a0 60 08 cmp %g1, 8
40006c28: 12 80 00 2e bne 40006ce0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40006c2c: 90 10 20 08 mov 8, %o0
40006c30: 81 c3 e0 08 retl
40006c34: 01 00 00 00 nop
40006c38: 02 bf ff f1 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006c3c: 90 10 20 0e mov 0xe, %o0 ! e <PROM_START+0xe>
40006c40: 80 a0 60 0e cmp %g1, 0xe
40006c44: 18 80 00 10 bgu 40006c84 <rtems_termios_baud_to_index+0xec>
40006c48: 05 00 00 04 sethi %hi(0x1000), %g2
40006c4c: 80 a0 60 0b cmp %g1, 0xb
40006c50: 02 bf ff eb be 40006bfc <rtems_termios_baud_to_index+0x64>
40006c54: 90 10 20 0b mov 0xb, %o0
40006c58: 80 a0 60 0b cmp %g1, 0xb
40006c5c: 0a bf ff e8 bcs 40006bfc <rtems_termios_baud_to_index+0x64>
40006c60: 90 10 20 0a mov 0xa, %o0
40006c64: 80 a0 60 0c cmp %g1, 0xc
40006c68: 02 bf ff e5 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006c6c: 90 10 20 0c mov 0xc, %o0
40006c70: 80 a0 60 0d cmp %g1, 0xd
40006c74: 12 80 00 1b bne 40006ce0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40006c78: 90 10 20 0d mov 0xd, %o0
40006c7c: 81 c3 e0 08 retl
40006c80: 01 00 00 00 nop
40006c84: 86 10 a0 02 or %g2, 2, %g3
40006c88: 80 a0 40 03 cmp %g1, %g3
40006c8c: 02 bf ff dc be 40006bfc <rtems_termios_baud_to_index+0x64>
40006c90: 90 10 20 11 mov 0x11, %o0
40006c94: 80 a0 40 03 cmp %g1, %g3
40006c98: 38 80 00 0b bgu,a 40006cc4 <rtems_termios_baud_to_index+0x12c>
40006c9c: 86 10 a0 03 or %g2, 3, %g3
40006ca0: 80 a0 60 0f cmp %g1, 0xf
40006ca4: 02 bf ff d6 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006ca8: 90 10 20 0f mov 0xf, %o0
40006cac: 84 10 a0 01 or %g2, 1, %g2
40006cb0: 80 a0 40 02 cmp %g1, %g2
40006cb4: 12 80 00 0b bne 40006ce0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
40006cb8: 90 10 20 10 mov 0x10, %o0
40006cbc: 81 c3 e0 08 retl
40006cc0: 01 00 00 00 nop
40006cc4: 80 a0 40 03 cmp %g1, %g3
40006cc8: 02 bf ff cd be 40006bfc <rtems_termios_baud_to_index+0x64>
40006ccc: 90 10 20 12 mov 0x12, %o0
40006cd0: 84 10 a0 04 or %g2, 4, %g2
40006cd4: 80 a0 40 02 cmp %g1, %g2
40006cd8: 02 bf ff c9 be 40006bfc <rtems_termios_baud_to_index+0x64>
40006cdc: 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;
40006ce0: 90 10 3f ff mov -1, %o0
}
return baud_index;
}
40006ce4: 81 c3 e0 08 retl
40005f34 <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
40005f34: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005f38: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40005f3c: 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;
40005f40: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40005f44: 03 10 00 7c sethi %hi(0x4001f000), %g1
40005f48: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 4001f330 <rtems_termios_ttyMutex>
40005f4c: 40 00 08 27 call 40007fe8 <rtems_semaphore_obtain>
40005f50: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005f54: 80 a2 20 00 cmp %o0, 0
40005f58: 22 80 00 03 be,a 40005f64 <rtems_termios_close+0x30> <== ALWAYS TAKEN
40005f5c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40005f60: 30 80 00 30 b,a 40006020 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
40005f64: 82 00 7f ff add %g1, -1, %g1
40005f68: 80 a0 60 00 cmp %g1, 0
40005f6c: 12 80 00 64 bne 400060fc <rtems_termios_close+0x1c8>
40005f70: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
40005f74: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40005f78: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40005f7c: 85 28 a0 05 sll %g2, 5, %g2
40005f80: 82 10 63 04 or %g1, 0x304, %g1
40005f84: 82 00 40 02 add %g1, %g2, %g1
40005f88: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005f8c: 80 a0 60 00 cmp %g1, 0
40005f90: 22 80 00 06 be,a 40005fa8 <rtems_termios_close+0x74>
40005f94: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
40005f98: 9f c0 40 00 call %g1
40005f9c: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40005fa0: 10 80 00 11 b 40005fe4 <rtems_termios_close+0xb0>
40005fa4: 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);
40005fa8: 92 10 20 00 clr %o1
40005fac: 40 00 08 0f call 40007fe8 <rtems_semaphore_obtain>
40005fb0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
40005fb4: 80 a2 20 00 cmp %o0, 0
40005fb8: 22 80 00 03 be,a 40005fc4 <rtems_termios_close+0x90> <== ALWAYS TAKEN
40005fbc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005fc0: 30 80 00 18 b,a 40006020 <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) {
40005fc4: 80 a0 60 00 cmp %g1, 0
40005fc8: 02 80 00 04 be 40005fd8 <rtems_termios_close+0xa4>
40005fcc: 01 00 00 00 nop
40005fd0: 7f ff fe ad call 40005a84 <drainOutput.part.0>
40005fd4: 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);
40005fd8: 40 00 08 4d call 4000810c <rtems_semaphore_release>
40005fdc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40005fe0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005fe4: 80 a0 60 02 cmp %g1, 2
40005fe8: 32 80 00 10 bne,a 40006028 <rtems_termios_close+0xf4>
40005fec: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
40005ff0: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
40005ff4: 40 00 06 d0 call 40007b34 <rtems_event_send>
40005ff8: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
40005ffc: 80 a2 20 00 cmp %o0, 0
40006000: 22 80 00 03 be,a 4000600c <rtems_termios_close+0xd8> <== ALWAYS TAKEN
40006004: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
40006008: 30 80 00 06 b,a 40006020 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
4000600c: 40 00 06 ca call 40007b34 <rtems_event_send>
40006010: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
40006014: 80 a2 20 00 cmp %o0, 0
40006018: 22 80 00 04 be,a 40006028 <rtems_termios_close+0xf4> <== ALWAYS TAKEN
4000601c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
40006020: 40 00 09 cf call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
40006024: 01 00 00 00 nop <== NOT EXECUTED
}
if (tty->device.lastClose)
40006028: 80 a0 60 00 cmp %g1, 0
4000602c: 22 80 00 07 be,a 40006048 <rtems_termios_close+0x114> <== ALWAYS TAKEN
40006030: c4 07 40 00 ld [ %i5 ], %g2
(*tty->device.lastClose)(tty->major, tty->minor, arg);
40006034: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
40006038: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
4000603c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006040: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
40006044: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
40006048: 80 a0 a0 00 cmp %g2, 0
4000604c: 12 80 00 08 bne 4000606c <rtems_termios_close+0x138>
40006050: c2 07 60 04 ld [ %i5 + 4 ], %g1
rtems_termios_ttyTail = tty->back;
40006054: 05 10 00 7c sethi %hi(0x4001f000), %g2
if ( rtems_termios_ttyTail != NULL ) {
40006058: 80 a0 60 00 cmp %g1, 0
4000605c: 02 80 00 05 be 40006070 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
40006060: c2 20 a3 34 st %g1, [ %g2 + 0x334 ]
rtems_termios_ttyTail->forw = NULL;
40006064: 10 80 00 03 b 40006070 <rtems_termios_close+0x13c> <== NOT EXECUTED
40006068: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
4000606c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
if (tty->back == NULL) {
40006070: c4 07 60 04 ld [ %i5 + 4 ], %g2
40006074: 80 a0 a0 00 cmp %g2, 0
40006078: 12 80 00 08 bne 40006098 <rtems_termios_close+0x164> <== NEVER TAKEN
4000607c: c2 07 40 00 ld [ %i5 ], %g1
rtems_termios_ttyHead = tty->forw;
40006080: 05 10 00 7c sethi %hi(0x4001f000), %g2
if ( rtems_termios_ttyHead != NULL ) {
40006084: 80 a0 60 00 cmp %g1, 0
40006088: 02 80 00 05 be 4000609c <rtems_termios_close+0x168>
4000608c: c2 20 a3 38 st %g1, [ %g2 + 0x338 ]
rtems_termios_ttyHead->back = NULL;
40006090: 10 80 00 03 b 4000609c <rtems_termios_close+0x168>
40006094: c0 20 60 04 clr [ %g1 + 4 ]
}
} else {
tty->back->forw = tty->forw;
40006098: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
4000609c: 40 00 07 a4 call 40007f2c <rtems_semaphore_delete>
400060a0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
400060a4: 40 00 07 a2 call 40007f2c <rtems_semaphore_delete>
400060a8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
400060ac: 40 00 07 a0 call 40007f2c <rtems_semaphore_delete>
400060b0: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
400060b4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
400060b8: 80 a0 60 00 cmp %g1, 0
400060bc: 02 80 00 06 be 400060d4 <rtems_termios_close+0x1a0>
400060c0: 01 00 00 00 nop
400060c4: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
400060c8: 80 a0 60 02 cmp %g1, 2
400060cc: 12 80 00 04 bne 400060dc <rtems_termios_close+0x1a8>
400060d0: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
400060d4: 40 00 07 96 call 40007f2c <rtems_semaphore_delete>
400060d8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free (tty->rawInBuf.theBuf);
400060dc: 7f ff f7 d2 call 40004024 <free>
400060e0: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
400060e4: 7f ff f7 d0 call 40004024 <free>
400060e8: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
400060ec: 7f ff f7 ce call 40004024 <free>
400060f0: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
400060f4: 7f ff f7 cc call 40004024 <free>
400060f8: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
400060fc: 03 10 00 7c sethi %hi(0x4001f000), %g1
40006100: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 4001f330 <rtems_termios_ttyMutex>
40006104: 40 00 08 02 call 4000810c <rtems_semaphore_release>
40006108: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
4000610c: 81 c7 e0 08 ret
40006110: 81 e8 00 00 restore
40007504 <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)
{
40007504: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40007508: 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)
{
4000750c: 90 10 00 18 mov %i0, %o0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40007510: b2 00 40 19 add %g1, %i1, %i1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40007514: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
40007518: 80 a0 60 02 cmp %g1, 2
4000751c: 12 80 00 0a bne 40007544 <rtems_termios_dequeue_characters+0x40>
40007520: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
40007524: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
40007528: 40 00 01 83 call 40007b34 <rtems_event_send>
4000752c: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
40007530: 80 a2 20 00 cmp %o0, 0
40007534: 02 80 00 11 be 40007578 <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
40007538: b0 10 20 00 clr %i0
rtems_fatal_error_occurred (sc);
4000753c: 40 00 04 88 call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
40007540: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
40007544: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
40007548: 80 a0 60 05 cmp %g1, 5
4000754c: 12 80 00 09 bne 40007570 <rtems_termios_dequeue_characters+0x6c>
40007550: 03 10 00 7b sethi %hi(0x4001ec00), %g1
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40007554: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 4001efb8 <rtems_termios_linesw+0xb4>
40007558: 80 a0 60 00 cmp %g1, 0
4000755c: 02 80 00 07 be 40007578 <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
40007560: b0 10 20 00 clr %i0
rtems_termios_linesw[tty->t_line].l_start(tty);
40007564: 9f c0 40 00 call %g1
40007568: 01 00 00 00 nop
4000756c: 30 80 00 03 b,a 40007578 <rtems_termios_dequeue_characters+0x74>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
40007570: 7f ff f8 b0 call 40005830 <rtems_termios_refill_transmitter>
40007574: 81 e8 00 00 restore
}
40007578: 81 c7 e0 08 ret
4000757c: 81 e8 00 00 restore
4000719c <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)
{
4000719c: 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) {
400071a0: c4 06 20 cc ld [ %i0 + 0xcc ], %g2
400071a4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
400071a8: 85 28 a0 05 sll %g2, 5, %g2
400071ac: 82 10 63 04 or %g1, 0x304, %g1
400071b0: 84 00 40 02 add %g1, %g2, %g2
400071b4: 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)
{
400071b8: 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);
400071bc: 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) {
400071c0: 80 a0 a0 00 cmp %g2, 0
400071c4: 12 80 00 10 bne 40007204 <rtems_termios_enqueue_raw_characters+0x68>
400071c8: 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)
400071cc: b6 10 20 00 clr %i3
400071d0: 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);
400071d4: 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);
400071d8: 10 80 00 a5 b 4000746c <rtems_termios_enqueue_raw_characters+0x2d0>
400071dc: 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++;
400071e0: d0 0e 40 00 ldub [ %i1 ], %o0
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
400071e4: 83 28 60 05 sll %g1, 5, %g1
400071e8: 82 07 00 01 add %i4, %g1, %g1
400071ec: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400071f0: 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++;
400071f4: b2 06 60 01 inc %i1
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
400071f8: 91 3a 20 18 sra %o0, 0x18, %o0
400071fc: 9f c0 40 00 call %g1
40007200: 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--) {
40007204: 80 a6 40 1a cmp %i1, %i2
40007208: 32 bf ff f6 bne,a 400071e0 <rtems_termios_enqueue_raw_characters+0x44>
4000720c: 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 )) {
40007210: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
40007214: 80 a0 60 00 cmp %g1, 0
40007218: 12 80 00 0b bne 40007244 <rtems_termios_enqueue_raw_characters+0xa8><== NEVER TAKEN
4000721c: b0 10 20 00 clr %i0
40007220: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
40007224: 80 a0 60 00 cmp %g1, 0
40007228: 02 80 00 9b be 40007494 <rtems_termios_enqueue_raw_characters+0x2f8>
4000722c: 01 00 00 00 nop
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
40007230: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1
40007234: 9f c0 40 00 call %g1
40007238: 90 07 60 30 add %i5, 0x30, %o0
tty->tty_rcvwakeup = 1;
4000723c: 82 10 20 01 mov 1, %g1
40007240: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ]
40007244: 81 c7 e0 08 ret
40007248: 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) {
4000724c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
40007250: 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) {
40007254: 80 88 62 00 btst 0x200, %g1
40007258: 02 80 00 17 be 400072b4 <rtems_termios_enqueue_raw_characters+0x118>
4000725c: 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]) {
40007260: c4 0f 60 4a ldub [ %i5 + 0x4a ], %g2
40007264: 83 2c 20 18 sll %l0, 0x18, %g1
40007268: 83 38 60 18 sra %g1, 0x18, %g1
4000726c: 80 a0 40 02 cmp %g1, %g2
40007270: c4 0f 60 49 ldub [ %i5 + 0x49 ], %g2
40007274: 12 80 00 0a bne 4000729c <rtems_termios_enqueue_raw_characters+0x100>
40007278: 84 08 a0 ff and %g2, 0xff, %g2
if (c == tty->termios.c_cc[VSTART]) {
4000727c: 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;
40007280: 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]) {
40007284: 32 80 00 03 bne,a 40007290 <rtems_termios_enqueue_raw_characters+0xf4><== ALWAYS TAKEN
40007288: 82 10 60 10 or %g1, 0x10, %g1
4000728c: 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;
40007290: 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)
{
40007294: 10 80 00 0b b 400072c0 <rtems_termios_enqueue_raw_characters+0x124>
40007298: 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]) {
4000729c: 80 a0 40 02 cmp %g1, %g2
400072a0: 12 80 00 06 bne 400072b8 <rtems_termios_enqueue_raw_characters+0x11c><== ALWAYS TAKEN
400072a4: 80 8e e0 ff btst 0xff, %i3
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
400072a8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400072ac: 10 bf ff f9 b 40007290 <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
400072b0: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
400072b4: 80 8e e0 ff btst 0xff, %i3
400072b8: 02 80 00 1c be 40007328 <rtems_termios_enqueue_raw_characters+0x18c><== ALWAYS TAKEN
400072bc: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
400072c0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400072c4: 82 08 60 30 and %g1, 0x30, %g1
400072c8: 80 a0 60 20 cmp %g1, 0x20
400072cc: 12 80 00 69 bne 40007470 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
400072d0: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
400072d4: 7f ff ec 5d call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
400072d8: 01 00 00 00 nop <== NOT EXECUTED
400072dc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400072e0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400072e4: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
400072e8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400072ec: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
400072f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400072f4: 02 80 00 09 be 40007318 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
400072f8: 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);
400072fc: 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)(
40007300: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
40007304: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40007308: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000730c: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40007310: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007314: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40007318: 7f ff ec 50 call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
4000731c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
40007320: 10 80 00 54 b 40007470 <rtems_termios_enqueue_raw_characters+0x2d4><== NOT EXECUTED
40007324: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
40007328: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
4000732c: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
40007330: 40 00 47 08 call 40018f50 <.urem>
40007334: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
40007338: 7f ff ec 44 call 40002448 <sparc_disable_interrupts>
4000733c: b8 10 00 08 mov %o0, %i4
40007340: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
40007344: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
40007348: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
4000734c: 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)
40007350: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
40007354: 40 00 46 ff call 40018f50 <.urem>
40007358: 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)
4000735c: c2 07 60 c0 ld [ %i5 + 0xc0 ], %g1
40007360: 80 a2 00 01 cmp %o0, %g1
40007364: 08 80 00 2b bleu 40007410 <rtems_termios_enqueue_raw_characters+0x274><== ALWAYS TAKEN
40007368: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
4000736c: 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) &&
40007370: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40007374: 12 80 00 27 bne 40007410 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
40007378: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
4000737c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40007380: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
40007384: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40007388: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
4000738c: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
40007390: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
40007394: 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))
40007398: 32 80 00 12 bne,a 400073e0 <rtems_termios_enqueue_raw_characters+0x244><== NOT EXECUTED
4000739c: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
400073a0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400073a4: 12 80 00 06 bne 400073bc <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
400073a8: 01 00 00 00 nop <== NOT EXECUTED
400073ac: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
400073b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400073b4: 12 80 00 17 bne 40007410 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
400073b8: 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;
400073bc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400073c0: 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;
400073c4: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
400073c8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400073cc: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
400073d0: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
400073d4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400073d8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
400073dc: 30 80 00 0d b,a 40007410 <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) ) {
400073e0: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
400073e4: 12 80 00 0b bne 40007410 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
400073e8: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
400073ec: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400073f0: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
400073f4: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
400073f8: c2 07 60 ac ld [ %i5 + 0xac ], %g1 <== NOT EXECUTED
400073fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40007400: 02 80 00 04 be 40007410 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
40007404: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
40007408: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000740c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40007410: 7f ff ec 12 call 40002458 <sparc_enable_interrupts>
40007414: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
40007418: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
4000741c: 80 a7 00 01 cmp %i4, %g1
40007420: 32 80 00 04 bne,a 40007430 <rtems_termios_enqueue_raw_characters+0x294><== ALWAYS TAKEN
40007424: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
dropped++;
40007428: 10 80 00 11 b 4000746c <rtems_termios_enqueue_raw_characters+0x2d0><== NOT EXECUTED
4000742c: b0 06 20 01 inc %i0 <== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
40007430: 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 )) {
40007434: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
40007438: 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 )) {
4000743c: 80 a0 60 00 cmp %g1, 0
40007440: 12 80 00 0c bne 40007470 <rtems_termios_enqueue_raw_characters+0x2d4><== NEVER TAKEN
40007444: 80 a6 40 1a cmp %i1, %i2
40007448: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
4000744c: 80 a0 60 00 cmp %g1, 0
40007450: 02 80 00 08 be 40007470 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
40007454: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
40007458: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1 <== NOT EXECUTED
4000745c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007460: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
40007464: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40007468: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ] <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
4000746c: 80 a6 40 1a cmp %i1, %i2
40007470: 12 bf ff 77 bne 4000724c <rtems_termios_enqueue_raw_characters+0xb0>
40007474: 01 00 00 00 nop
}
}
}
}
tty->rawInBufDropped += dropped;
40007478: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
4000747c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
40007480: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
40007484: 40 00 03 22 call 4000810c <rtems_semaphore_release>
40007488: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
return dropped;
4000748c: 81 c7 e0 08 ret
40007490: 81 e8 00 00 restore
}
40007494: 81 c7 e0 08 ret
40007498: 81 e8 00 00 restore
40006134 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40006134: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40006138: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
4000613c: 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;
40006140: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40006144: 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);
40006148: 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;
4000614c: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40006150: 92 10 20 00 clr %o1
40006154: 40 00 07 a5 call 40007fe8 <rtems_semaphore_obtain>
40006158: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
4000615c: b0 92 20 00 orcc %o0, 0, %i0
40006160: 12 80 01 1a bne 400065c8 <rtems_termios_ioctl+0x494> <== NEVER TAKEN
40006164: 01 00 00 00 nop
return sc;
}
switch (args->command) {
40006168: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000616c: 80 a0 60 05 cmp %g1, 5
40006170: 22 80 00 e4 be,a 40006500 <rtems_termios_ioctl+0x3cc>
40006174: c2 06 c0 00 ld [ %i3 ], %g1
40006178: 18 80 00 12 bgu 400061c0 <rtems_termios_ioctl+0x8c>
4000617c: 05 10 01 19 sethi %hi(0x40046400), %g2
40006180: 80 a0 60 02 cmp %g1, 2
40006184: 22 80 00 34 be,a 40006254 <rtems_termios_ioctl+0x120>
40006188: d2 07 20 08 ld [ %i4 + 8 ], %o1
4000618c: 18 80 00 07 bgu 400061a8 <rtems_termios_ioctl+0x74>
40006190: 80 a0 60 03 cmp %g1, 3
40006194: 80 a0 60 01 cmp %g1, 1
40006198: 32 80 00 1e bne,a 40006210 <rtems_termios_ioctl+0xdc> <== NEVER TAKEN
4000619c: 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;
400061a0: 10 80 00 29 b 40006244 <rtems_termios_ioctl+0x110>
400061a4: 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) {
400061a8: 02 80 00 b3 be 40006474 <rtems_termios_ioctl+0x340>
400061ac: 80 a0 60 04 cmp %g1, 4
400061b0: 32 80 00 18 bne,a 40006210 <rtems_termios_ioctl+0xdc> <== NEVER TAKEN
400061b4: 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;
400061b8: 10 80 00 d6 b 40006510 <rtems_termios_ioctl+0x3dc>
400061bc: 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) {
400061c0: 84 10 a2 7f or %g2, 0x27f, %g2
400061c4: 80 a0 40 02 cmp %g1, %g2
400061c8: 02 80 00 f1 be 4000658c <rtems_termios_ioctl+0x458> <== NEVER TAKEN
400061cc: 01 00 00 00 nop
400061d0: 38 80 00 07 bgu,a 400061ec <rtems_termios_ioctl+0xb8>
400061d4: 05 10 01 1d sethi %hi(0x40047400), %g2
400061d8: 80 a0 60 06 cmp %g1, 6
400061dc: 32 80 00 0d bne,a 40006210 <rtems_termios_ioctl+0xdc>
400061e0: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
400061e4: 10 80 00 ab b 40006490 <rtems_termios_ioctl+0x35c>
400061e8: 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) {
400061ec: 84 10 a0 1a or %g2, 0x1a, %g2
400061f0: 80 a0 40 02 cmp %g1, %g2
400061f4: 02 80 00 e3 be 40006580 <rtems_termios_ioctl+0x44c>
400061f8: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
400061fc: 07 20 01 1d sethi %hi(0x80047400), %g3
40006200: 86 10 e0 1b or %g3, 0x1b, %g3 ! 8004741b <LEON_REG+0x4741b>
40006204: 80 a0 40 03 cmp %g1, %g3
40006208: 02 80 00 c6 be 40006520 <rtems_termios_ioctl+0x3ec> <== ALWAYS TAKEN
4000620c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
40006210: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40006214: 85 28 a0 05 sll %g2, 5, %g2
40006218: 82 10 63 04 or %g1, 0x304, %g1
4000621c: 82 00 40 02 add %g1, %g2, %g1
40006220: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40006224: 80 a0 60 00 cmp %g1, 0
40006228: 02 80 00 e6 be 400065c0 <rtems_termios_ioctl+0x48c>
4000622c: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
40006230: 90 10 00 1d mov %i5, %o0
40006234: 9f c0 40 00 call %g1
40006238: 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);
4000623c: 10 80 00 e1 b 400065c0 <rtems_termios_ioctl+0x48c>
40006240: b0 10 00 08 mov %o0, %i0
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
40006244: 92 07 60 30 add %i5, 0x30, %o1
40006248: 40 00 28 78 call 40010428 <memcpy>
4000624c: 94 10 20 24 mov 0x24, %o2
break;
40006250: 30 80 00 dc b,a 400065c0 <rtems_termios_ioctl+0x48c>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
40006254: 90 07 60 30 add %i5, 0x30, %o0
40006258: 40 00 28 74 call 40010428 <memcpy>
4000625c: 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) &&
40006260: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006264: 80 88 62 00 btst 0x200, %g1
40006268: 02 80 00 20 be 400062e8 <rtems_termios_ioctl+0x1b4>
4000626c: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
40006270: 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) &&
40006274: 80 88 64 00 btst 0x400, %g1
40006278: 12 80 00 1c bne 400062e8 <rtems_termios_ioctl+0x1b4>
4000627c: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
40006280: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006284: 82 08 7d ef and %g1, -529, %g1
40006288: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
4000628c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006290: 80 88 60 20 btst 0x20, %g1
40006294: 02 80 00 15 be 400062e8 <rtems_termios_ioctl+0x1b4> <== ALWAYS TAKEN
40006298: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
4000629c: 7f ff f0 6b call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
400062a0: 01 00 00 00 nop <== NOT EXECUTED
400062a4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400062a8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400062ac: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
400062b0: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400062b4: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
400062b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400062bc: 02 80 00 09 be 400062e0 <rtems_termios_ioctl+0x1ac> <== NOT EXECUTED
400062c0: 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);
400062c4: 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)(
400062c8: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
400062cc: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
400062d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
400062d4: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
400062d8: 9f c0 40 00 call %g1 <== NOT EXECUTED
400062dc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
400062e0: 7f ff f0 5e call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
400062e4: 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)) {
400062e8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400062ec: 80 88 64 00 btst 0x400, %g1
400062f0: 02 80 00 0c be 40006320 <rtems_termios_ioctl+0x1ec>
400062f4: 03 00 00 04 sethi %hi(0x1000), %g1
400062f8: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
400062fc: 80 88 80 01 btst %g2, %g1
40006300: 12 80 00 08 bne 40006320 <rtems_termios_ioctl+0x1ec> <== NEVER TAKEN
40006304: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
40006308: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
4000630c: 82 08 7b ff and %g1, -1025, %g1
40006310: 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);
40006314: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006318: 82 08 7f fd and %g1, -3, %g1
4000631c: 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)) {
40006320: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006324: 80 88 61 00 btst 0x100, %g1
40006328: 02 80 00 16 be 40006380 <rtems_termios_ioctl+0x24c> <== ALWAYS TAKEN
4000632c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40006330: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006334: 06 80 00 14 bl 40006384 <rtems_termios_ioctl+0x250> <== NOT EXECUTED
40006338: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
4000633c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006340: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
40006344: 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)) {
40006348: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
4000634c: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
40006350: 02 80 00 08 be 40006370 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
40006354: 01 00 00 00 nop <== NOT EXECUTED
40006358: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
4000635c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006360: 02 80 00 04 be 40006370 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
40006364: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
40006368: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000636c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
40006370: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006374: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
40006378: 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) {
4000637c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
40006380: 80 a0 60 00 cmp %g1, 0
40006384: 36 80 00 06 bge,a 4000639c <rtems_termios_ioctl+0x268> <== ALWAYS TAKEN
40006388: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
tty->flow_ctrl |= FL_MDRTS;
4000638c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006390: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
40006394: 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) {
40006398: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
4000639c: 05 00 00 04 sethi %hi(0x1000), %g2
400063a0: 80 88 40 02 btst %g1, %g2
400063a4: 02 80 00 06 be 400063bc <rtems_termios_ioctl+0x288>
400063a8: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
400063ac: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
400063b0: 84 10 a4 00 or %g2, 0x400, %g2
400063b4: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
400063b8: 80 88 64 00 btst 0x400, %g1
400063bc: 22 80 00 06 be,a 400063d4 <rtems_termios_ioctl+0x2a0>
400063c0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
400063c4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400063c8: 82 10 62 00 or %g1, 0x200, %g1
400063cc: 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) {
400063d0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
400063d4: 80 88 60 02 btst 2, %g1
400063d8: 02 80 00 04 be 400063e8 <rtems_termios_ioctl+0x2b4>
400063dc: 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;
400063e0: 10 80 00 19 b 40006444 <rtems_termios_ioctl+0x310>
400063e4: 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;
400063e8: 40 00 05 46 call 40007900 <rtems_clock_get_ticks_per_second>
400063ec: 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] *
400063f0: 40 00 49 f2 call 40018bb8 <.umul>
400063f4: 92 10 00 1c mov %i4, %o1
rtems_clock_get_ticks_per_second() / 10;
400063f8: 40 00 4a 2a call 40018ca0 <.udiv>
400063fc: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
40006400: 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] *
40006404: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
40006408: 80 a0 60 00 cmp %g1, 0
4000640c: 02 80 00 0a be 40006434 <rtems_termios_ioctl+0x300>
40006410: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
40006414: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
40006418: 80 88 60 ff btst 0xff, %g1
4000641c: 02 80 00 04 be 4000642c <rtems_termios_ioctl+0x2f8>
40006420: 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;
40006424: 10 80 00 0c b 40006454 <rtems_termios_ioctl+0x320>
40006428: 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;
4000642c: 10 80 00 0a b 40006454 <rtems_termios_ioctl+0x320>
40006430: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
} else {
if (tty->termios.c_cc[VMIN]) {
40006434: 80 88 60 ff btst 0xff, %g1
40006438: 02 80 00 06 be 40006450 <rtems_termios_ioctl+0x31c> <== ALWAYS TAKEN
4000643c: 82 10 20 01 mov 1, %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
40006440: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
40006444: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
40006448: 10 80 00 03 b 40006454 <rtems_termios_ioctl+0x320>
4000644c: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
40006450: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
}
}
}
if (tty->device.setAttributes)
40006454: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
40006458: 80 a0 60 00 cmp %g1, 0
4000645c: 02 80 00 59 be 400065c0 <rtems_termios_ioctl+0x48c> <== NEVER TAKEN
40006460: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
40006464: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
40006468: 9f c0 40 00 call %g1
4000646c: 92 07 60 30 add %i5, 0x30, %o1
40006470: 30 80 00 54 b,a 400065c0 <rtems_termios_ioctl+0x48c>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
40006474: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006478: 80 a0 60 00 cmp %g1, 0
4000647c: 02 80 00 51 be 400065c0 <rtems_termios_ioctl+0x48c> <== ALWAYS TAKEN
40006480: 01 00 00 00 nop
40006484: 7f ff fd 80 call 40005a84 <drainOutput.part.0> <== NOT EXECUTED
40006488: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000648c: 30 80 00 4d b,a 400065c0 <rtems_termios_ioctl+0x48c> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
40006490: 80 a0 60 01 cmp %g1, 1
40006494: 02 80 00 07 be 400064b0 <rtems_termios_ioctl+0x37c>
40006498: 80 a0 60 02 cmp %g1, 2
4000649c: 02 80 00 0b be 400064c8 <rtems_termios_ioctl+0x394>
400064a0: 80 a0 60 00 cmp %g1, 0
400064a4: 32 80 00 47 bne,a 400065c0 <rtems_termios_ioctl+0x48c>
400064a8: b0 10 20 03 mov 3, %i0
400064ac: 30 80 00 0e b,a 400064e4 <rtems_termios_ioctl+0x3b0>
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
400064b0: 7f ff ef e6 call 40002448 <sparc_disable_interrupts>
400064b4: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
400064b8: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
400064bc: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
400064c0: 10 80 00 0d b 400064f4 <rtems_termios_ioctl+0x3c0>
400064c4: c0 27 60 94 clr [ %i5 + 0x94 ]
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
400064c8: 7f ff ef e0 call 40002448 <sparc_disable_interrupts>
400064cc: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
400064d0: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
400064d4: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
400064d8: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
400064dc: 7f ff ef df call 40002458 <sparc_enable_interrupts>
400064e0: 01 00 00 00 nop
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
400064e4: 7f ff ef d9 call 40002448 <sparc_disable_interrupts>
400064e8: 01 00 00 00 nop
tty->rawInBuf.Tail = 0;
400064ec: c0 27 60 60 clr [ %i5 + 0x60 ]
tty->rawInBuf.Head = 0;
400064f0: c0 27 60 5c clr [ %i5 + 0x5c ]
rtems_interrupt_enable (level);
400064f4: 7f ff ef d9 call 40002458 <sparc_enable_interrupts>
400064f8: 01 00 00 00 nop
400064fc: 30 80 00 31 b,a 400065c0 <rtems_termios_ioctl+0x48c>
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
40006500: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
40006504: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
40006508: 10 80 00 2e b 400065c0 <rtems_termios_ioctl+0x48c>
4000650c: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
40006510: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
40006514: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
40006518: 10 80 00 2a b 400065c0 <rtems_termios_ioctl+0x48c>
4000651c: 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) {
40006520: 82 10 63 04 or %g1, 0x304, %g1
40006524: 85 28 a0 05 sll %g2, 5, %g2
40006528: 84 00 40 02 add %g1, %g2, %g2
4000652c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40006530: 80 a0 60 00 cmp %g1, 0
40006534: 22 80 00 06 be,a 4000654c <rtems_termios_ioctl+0x418>
40006538: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4000653c: 9f c0 40 00 call %g1
40006540: 90 10 00 1d mov %i5, %o0
40006544: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
40006548: 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) {
4000654c: 05 10 00 7b sethi %hi(0x4001ec00), %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);
40006550: 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) {
40006554: 84 10 a3 04 or %g2, 0x304, %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);
40006558: 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) {
4000655c: 83 28 60 05 sll %g1, 5, %g1
40006560: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40006564: 80 a0 60 00 cmp %g1, 0
40006568: 02 80 00 16 be 400065c0 <rtems_termios_ioctl+0x48c>
4000656c: c0 27 60 d0 clr [ %i5 + 0xd0 ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
40006570: 9f c0 40 00 call %g1
40006574: 90 10 00 1d mov %i5, %o0
40006578: 10 80 00 12 b 400065c0 <rtems_termios_ioctl+0x48c>
4000657c: b0 10 00 08 mov %o0, %i0
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
40006580: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
40006584: 10 80 00 0f b 400065c0 <rtems_termios_ioctl+0x48c>
40006588: c4 20 40 00 st %g2, [ %g1 ]
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
4000658c: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
40006590: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
40006594: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
40006598: 3c 80 00 05 bpos,a 400065ac <rtems_termios_ioctl+0x478> <== NOT EXECUTED
4000659c: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
400065a0: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
400065a4: 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;
400065a8: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
400065ac: c6 07 60 24 ld [ %i5 + 0x24 ], %g3 <== NOT EXECUTED
400065b0: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
400065b4: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
400065b8: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
400065bc: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
400065c0: 40 00 06 d3 call 4000810c <rtems_semaphore_release>
400065c4: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
400065c8: 81 c7 e0 08 ret
400065cc: 81 e8 00 00 restore
40005ae8 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
40005ae8: 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(
40005aec: 03 10 00 7c sethi %hi(0x4001f000), %g1
40005af0: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 4001f330 <rtems_termios_ttyMutex>
40005af4: 92 10 20 00 clr %o1
40005af8: 40 00 09 3c call 40007fe8 <rtems_semaphore_obtain>
40005afc: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005b00: b8 92 20 00 orcc %o0, 0, %i4
40005b04: 12 80 01 09 bne 40005f28 <rtems_termios_open+0x440> <== NEVER TAKEN
40005b08: 03 10 00 7c sethi %hi(0x4001f000), %g1
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40005b0c: e0 00 63 38 ld [ %g1 + 0x338 ], %l0 ! 4001f338 <rtems_termios_ttyHead>
40005b10: 10 80 00 0a b 40005b38 <rtems_termios_open+0x50>
40005b14: ba 10 00 10 mov %l0, %i5
if ((tty->major == major) && (tty->minor == minor))
40005b18: 80 a0 40 18 cmp %g1, %i0
40005b1c: 32 80 00 07 bne,a 40005b38 <rtems_termios_open+0x50>
40005b20: fa 07 40 00 ld [ %i5 ], %i5
40005b24: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005b28: 80 a0 40 19 cmp %g1, %i1
40005b2c: 22 80 00 d0 be,a 40005e6c <rtems_termios_open+0x384> <== ALWAYS TAKEN
40005b30: 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) {
40005b34: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
40005b38: 80 a7 60 00 cmp %i5, 0
40005b3c: 32 bf ff f7 bne,a 40005b18 <rtems_termios_open+0x30>
40005b40: c2 07 60 0c ld [ %i5 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40005b44: 10 80 00 f2 b 40005f0c <rtems_termios_open+0x424>
40005b48: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
40005b4c: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1
40005b50: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
40005b54: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
40005b58: 7f ff fa 07 call 40004374 <malloc>
40005b5c: 01 00 00 00 nop
40005b60: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
40005b64: 80 a2 20 00 cmp %o0, 0
40005b68: 02 80 00 16 be 40005bc0 <rtems_termios_open+0xd8>
40005b6c: a2 10 00 08 mov %o0, %l1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
40005b70: 03 10 00 79 sethi %hi(0x4001e400), %g1
40005b74: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 4001e7b4 <rtems_termios_raw_output_size>
40005b78: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
40005b7c: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
40005b80: 7f ff f9 fd call 40004374 <malloc>
40005b84: 01 00 00 00 nop
40005b88: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
40005b8c: 80 a2 20 00 cmp %o0, 0
40005b90: 02 80 00 0a be 40005bb8 <rtems_termios_open+0xd0>
40005b94: a4 10 00 08 mov %o0, %l2
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
40005b98: 03 10 00 79 sethi %hi(0x4001e400), %g1
40005b9c: 7f ff f9 f6 call 40004374 <malloc>
40005ba0: d0 00 63 b8 ld [ %g1 + 0x3b8 ], %o0 ! 4001e7b8 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
40005ba4: 80 a2 20 00 cmp %o0, 0
40005ba8: 12 80 00 0e bne 40005be0 <rtems_termios_open+0xf8>
40005bac: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
40005bb0: 7f ff f9 1d call 40004024 <free>
40005bb4: 90 10 00 12 mov %l2, %o0
free((void *)(tty->rawInBuf.theBuf));
40005bb8: 7f ff f9 1b call 40004024 <free>
40005bbc: 90 10 00 11 mov %l1, %o0
free(tty);
40005bc0: 7f ff f9 19 call 40004024 <free>
40005bc4: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
40005bc8: 03 10 00 7c sethi %hi(0x4001f000), %g1
40005bcc: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 4001f330 <rtems_termios_ttyMutex>
40005bd0: 40 00 09 4f call 4000810c <rtems_semaphore_release>
40005bd4: b8 10 20 1a mov 0x1a, %i4
return RTEMS_NO_MEMORY;
40005bd8: 81 c7 e0 08 ret
40005bdc: 91 e8 00 1c restore %g0, %i4, %o0
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
40005be0: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
40005be4: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
40005be8: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
40005bec: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
40005bf0: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
40005bf4: e0 27 40 00 st %l0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
40005bf8: 80 a4 20 00 cmp %l0, 0
40005bfc: 02 80 00 03 be 40005c08 <rtems_termios_open+0x120>
40005c00: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
40005c04: fa 24 20 04 st %i5, [ %l0 + 4 ]
rtems_termios_ttyHead = tty;
40005c08: 03 10 00 7c sethi %hi(0x4001f000), %g1
40005c0c: fa 20 63 38 st %i5, [ %g1 + 0x338 ] ! 4001f338 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
40005c10: 03 10 00 7c sethi %hi(0x4001f000), %g1
40005c14: c4 00 63 34 ld [ %g1 + 0x334 ], %g2 ! 4001f334 <rtems_termios_ttyTail>
40005c18: 80 a0 a0 00 cmp %g2, 0
40005c1c: 22 80 00 02 be,a 40005c24 <rtems_termios_open+0x13c>
40005c20: fa 20 63 34 st %i5, [ %g1 + 0x334 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
40005c24: 21 10 00 79 sethi %hi(0x4001e400), %l0
40005c28: d0 4c 23 bc ldsb [ %l0 + 0x3bc ], %o0 ! 4001e7bc <c.6875>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40005c2c: 03 15 14 9a sethi %hi(0x54526800), %g1
40005c30: 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;
40005c34: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
40005c38: f0 27 60 0c st %i0, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40005c3c: 90 12 00 01 or %o0, %g1, %o0
40005c40: 92 10 20 01 mov 1, %o1
40005c44: 94 10 20 54 mov 0x54, %o2
40005c48: 96 10 20 00 clr %o3
40005c4c: 40 00 08 4a call 40007d74 <rtems_semaphore_create>
40005c50: 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)
40005c54: 80 a2 20 00 cmp %o0, 0
40005c58: 22 80 00 03 be,a 40005c64 <rtems_termios_open+0x17c>
40005c5c: d0 4c 23 bc ldsb [ %l0 + 0x3bc ], %o0
40005c60: 30 80 00 a4 b,a 40005ef0 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
40005c64: 03 15 14 9b sethi %hi(0x54526c00), %g1
40005c68: 82 10 63 00 or %g1, 0x300, %g1 ! 54526f00 <RAM_END+0x14126f00>
40005c6c: 92 10 20 01 mov 1, %o1
40005c70: 90 12 00 01 or %o0, %g1, %o0
40005c74: 94 10 20 54 mov 0x54, %o2
40005c78: 96 10 20 00 clr %o3
40005c7c: 40 00 08 3e call 40007d74 <rtems_semaphore_create>
40005c80: 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)
40005c84: 80 a2 20 00 cmp %o0, 0
40005c88: 22 80 00 03 be,a 40005c94 <rtems_termios_open+0x1ac>
40005c8c: d0 4c 23 bc ldsb [ %l0 + 0x3bc ], %o0
40005c90: 30 80 00 98 b,a 40005ef0 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
40005c94: 03 15 14 9e sethi %hi(0x54527800), %g1
40005c98: 92 10 20 00 clr %o1
40005c9c: 90 12 00 01 or %o0, %g1, %o0
40005ca0: 94 10 20 20 mov 0x20, %o2
40005ca4: 96 10 20 00 clr %o3
40005ca8: 40 00 08 33 call 40007d74 <rtems_semaphore_create>
40005cac: 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)
40005cb0: 80 a2 20 00 cmp %o0, 0
40005cb4: 22 80 00 03 be,a 40005cc0 <rtems_termios_open+0x1d8>
40005cb8: c0 27 60 94 clr [ %i5 + 0x94 ]
40005cbc: 30 80 00 8d b,a 40005ef0 <rtems_termios_open+0x408>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
40005cc0: 90 07 60 98 add %i5, 0x98, %o0
40005cc4: 92 10 00 1b mov %i3, %o1
40005cc8: 40 00 29 d8 call 40010428 <memcpy>
40005ccc: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40005cd0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005cd4: 80 a0 60 02 cmp %g1, 2
40005cd8: 32 80 00 1b bne,a 40005d44 <rtems_termios_open+0x25c>
40005cdc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
40005ce0: d0 4c 23 bc ldsb [ %l0 + 0x3bc ], %o0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
40005ce4: 03 15 1e 15 sethi %hi(0x54785400), %g1
40005ce8: 92 10 20 0a mov 0xa, %o1
40005cec: 90 12 00 01 or %o0, %g1, %o0
40005cf0: 94 10 24 00 mov 0x400, %o2
40005cf4: 96 10 25 00 mov 0x500, %o3
40005cf8: 98 10 20 00 clr %o4
40005cfc: 40 00 09 46 call 40008214 <rtems_task_create>
40005d00: 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)
40005d04: 80 a2 20 00 cmp %o0, 0
40005d08: 22 80 00 03 be,a 40005d14 <rtems_termios_open+0x22c> <== ALWAYS TAKEN
40005d0c: d0 4c 23 bc ldsb [ %l0 + 0x3bc ], %o0
40005d10: 30 80 00 78 b,a 40005ef0 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
40005d14: 03 14 9e 15 sethi %hi(0x52785400), %g1
40005d18: 92 10 20 09 mov 9, %o1
40005d1c: 90 12 00 01 or %o0, %g1, %o0
40005d20: 94 10 24 00 mov 0x400, %o2
40005d24: 96 10 25 00 mov 0x500, %o3
40005d28: 98 10 20 00 clr %o4
40005d2c: 40 00 09 3a call 40008214 <rtems_task_create>
40005d30: 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)
40005d34: 80 a2 20 00 cmp %o0, 0
40005d38: 22 80 00 03 be,a 40005d44 <rtems_termios_open+0x25c> <== ALWAYS TAKEN
40005d3c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005d40: 30 80 00 6c b,a 40005ef0 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
40005d44: 80 a0 60 00 cmp %g1, 0
40005d48: 02 80 00 07 be 40005d64 <rtems_termios_open+0x27c>
40005d4c: 03 10 00 79 sethi %hi(0x4001e400), %g1
40005d50: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005d54: 80 a0 60 02 cmp %g1, 2
40005d58: 12 80 00 0f bne 40005d94 <rtems_termios_open+0x2ac>
40005d5c: 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),
40005d60: 03 10 00 79 sethi %hi(0x4001e400), %g1
40005d64: d0 48 63 bc ldsb [ %g1 + 0x3bc ], %o0 ! 4001e7bc <c.6875>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
40005d68: 03 15 14 9c sethi %hi(0x54527000), %g1
40005d6c: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x14127200>
40005d70: 92 10 20 00 clr %o1
40005d74: 90 12 00 01 or %o0, %g1, %o0
40005d78: 94 10 20 24 mov 0x24, %o2
40005d7c: 96 10 20 00 clr %o3
40005d80: 40 00 07 fd call 40007d74 <rtems_semaphore_create>
40005d84: 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)
40005d88: 80 a2 20 00 cmp %o0, 0
40005d8c: 12 80 00 59 bne 40005ef0 <rtems_termios_open+0x408> <== NEVER TAKEN
40005d90: 03 00 00 09 sethi %hi(0x2400), %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40005d94: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
40005d98: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
40005d9c: 03 00 00 06 sethi %hi(0x1800), %g1
40005da0: 82 10 60 05 or %g1, 5, %g1 ! 1805 <PROM_START+0x1805>
40005da4: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
40005da8: 82 10 28 bd mov 0x8bd, %g1
40005dac: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
tty->termios.c_lflag =
40005db0: 03 00 00 20 sethi %hi(0x8000), %g1
40005db4: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
40005db8: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
40005dbc: 82 10 20 03 mov 3, %g1
40005dc0: c2 2f 60 41 stb %g1, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
40005dc4: 82 10 20 1c mov 0x1c, %g1
40005dc8: c2 2f 60 42 stb %g1, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
40005dcc: 82 10 20 7f mov 0x7f, %g1
40005dd0: c2 2f 60 43 stb %g1, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
40005dd4: 82 10 20 15 mov 0x15, %g1
40005dd8: c2 2f 60 44 stb %g1, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
40005ddc: 82 10 20 04 mov 4, %g1
40005de0: 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';
40005de4: 82 10 20 11 mov 0x11, %g1
40005de8: c2 2f 60 49 stb %g1, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
40005dec: 82 10 20 13 mov 0x13, %g1
40005df0: c2 2f 60 4a stb %g1, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
40005df4: 82 10 20 1a mov 0x1a, %g1
40005df8: c2 2f 60 4b stb %g1, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
40005dfc: 82 10 20 12 mov 0x12, %g1
40005e00: c2 2f 60 4d stb %g1, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
40005e04: 82 10 20 0f mov 0xf, %g1
40005e08: c2 2f 60 4e stb %g1, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
40005e0c: 82 10 20 17 mov 0x17, %g1
40005e10: c2 2f 60 4f stb %g1, [ %i5 + 0x4f ]
tty->termios.c_cc[VLNEXT] = '\026';
40005e14: 82 10 20 16 mov 0x16, %g1
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
40005e18: 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';
40005e1c: 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;
40005e20: 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';
40005e24: 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;
40005e28: 83 30 60 01 srl %g1, 1, %g1
40005e2c: c2 27 60 bc st %g1, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
40005e30: 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';
40005e34: 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;
40005e38: 85 28 60 01 sll %g1, 1, %g2
40005e3c: 82 00 80 01 add %g2, %g1, %g1
40005e40: 83 30 60 02 srl %g1, 2, %g1
40005e44: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
40005e48: 03 10 00 79 sethi %hi(0x4001e400), %g1
40005e4c: c4 08 63 bc ldub [ %g1 + 0x3bc ], %g2 ! 4001e7bc <c.6875>
40005e50: c6 48 63 bc ldsb [ %g1 + 0x3bc ], %g3
40005e54: 80 a0 e0 7a cmp %g3, 0x7a
40005e58: 12 80 00 03 bne 40005e64 <rtems_termios_open+0x37c>
40005e5c: 84 00 a0 01 inc %g2
c = 'a';
40005e60: 84 10 20 61 mov 0x61, %g2
40005e64: c4 28 63 bc stb %g2, [ %g1 + 0x3bc ]
}
args->iop->data1 = tty;
40005e68: c2 06 80 00 ld [ %i2 ], %g1
40005e6c: fa 20 60 30 st %i5, [ %g1 + 0x30 ]
if (!tty->refcount++) {
40005e70: c2 07 60 08 ld [ %i5 + 8 ], %g1
40005e74: 84 00 60 01 add %g1, 1, %g2
40005e78: 80 a0 60 00 cmp %g1, 0
40005e7c: 12 80 00 1f bne 40005ef8 <rtems_termios_open+0x410>
40005e80: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
40005e84: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40005e88: 80 a0 60 00 cmp %g1, 0
40005e8c: 02 80 00 05 be 40005ea0 <rtems_termios_open+0x3b8> <== ALWAYS TAKEN
40005e90: 90 10 00 18 mov %i0, %o0
(*tty->device.firstOpen)(major, minor, arg);
40005e94: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005e98: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005e9c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40005ea0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005ea4: 80 a0 60 02 cmp %g1, 2
40005ea8: 12 80 00 15 bne 40005efc <rtems_termios_open+0x414>
40005eac: 03 10 00 7c sethi %hi(0x4001f000), %g1
sc = rtems_task_start(
40005eb0: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
40005eb4: 13 10 00 1d sethi %hi(0x40007400), %o1
40005eb8: 94 10 00 1d mov %i5, %o2
40005ebc: 40 00 09 7b call 400084a8 <rtems_task_start>
40005ec0: 92 12 60 9c or %o1, 0x9c, %o1
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40005ec4: 80 a2 20 00 cmp %o0, 0
40005ec8: 22 80 00 03 be,a 40005ed4 <rtems_termios_open+0x3ec> <== ALWAYS TAKEN
40005ecc: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
40005ed0: 30 80 00 08 b,a 40005ef0 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
40005ed4: 13 10 00 16 sethi %hi(0x40005800), %o1
40005ed8: 94 10 00 1d mov %i5, %o2
40005edc: 40 00 09 73 call 400084a8 <rtems_task_start>
40005ee0: 92 12 62 14 or %o1, 0x214, %o1
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40005ee4: 80 a2 20 00 cmp %o0, 0
40005ee8: 02 80 00 05 be 40005efc <rtems_termios_open+0x414> <== ALWAYS TAKEN
40005eec: 03 10 00 7c sethi %hi(0x4001f000), %g1
rtems_fatal_error_occurred (sc);
40005ef0: 40 00 0a 1b call 4000875c <rtems_fatal_error_occurred>
40005ef4: 01 00 00 00 nop
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40005ef8: 03 10 00 7c sethi %hi(0x4001f000), %g1
40005efc: 40 00 08 84 call 4000810c <rtems_semaphore_release>
40005f00: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 4001f330 <rtems_termios_ttyMutex>
return RTEMS_SUCCESSFUL;
40005f04: 81 c7 e0 08 ret
40005f08: 91 e8 00 1c restore %g0, %i4, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40005f0c: 7f ff f7 93 call 40003d58 <calloc>
40005f10: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
40005f14: ba 92 20 00 orcc %o0, 0, %i5
40005f18: 32 bf ff 0d bne,a 40005b4c <rtems_termios_open+0x64>
40005f1c: 03 10 00 79 sethi %hi(0x4001e400), %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);
40005f20: 10 bf ff 2b b 40005bcc <rtems_termios_open+0xe4>
40005f24: 03 10 00 7c sethi %hi(0x4001f000), %g1
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
return RTEMS_SUCCESSFUL;
}
40005f28: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
40005f2c: 81 c7 e0 08 ret <== NOT EXECUTED
40005f30: 81 e8 00 00 restore <== NOT EXECUTED
400065d0 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
400065d0: 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) {
400065d4: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
400065d8: 80 a0 60 00 cmp %g1, 0
400065dc: 12 80 00 08 bne 400065fc <rtems_termios_puts+0x2c>
400065e0: 92 10 00 18 mov %i0, %o1
(*tty->device.write)(tty->minor, buf, len);
400065e4: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
400065e8: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
400065ec: 9f c0 40 00 call %g1
400065f0: 94 10 00 19 mov %i1, %o2
return;
400065f4: 81 c7 e0 08 ret
400065f8: 81 e8 00 00 restore
}
newHead = tty->rawOutBuf.Head;
400065fc: fa 06 a0 80 ld [ %i2 + 0x80 ], %i5
/*
* Send characters to device-specific code
*/
void
rtems_termios_puts (
40006600: 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;
40006604: 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) {
40006608: 10 80 00 36 b 400066e0 <rtems_termios_puts+0x110>
4000660c: 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;
40006610: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
40006614: 40 00 4a 4f call 40018f50 <.urem>
40006618: 90 07 60 01 add %i5, 1, %o0
4000661c: 10 80 00 0d b 40006650 <rtems_termios_puts+0x80>
40006620: ba 10 00 08 mov %o0, %i5
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
40006624: 7f ff ef 8d call 40002458 <sparc_enable_interrupts>
40006628: 90 10 00 1c mov %i4, %o0
sc = rtems_semaphore_obtain(
4000662c: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
40006630: 92 10 20 00 clr %o1
40006634: 40 00 06 6d call 40007fe8 <rtems_semaphore_obtain>
40006638: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4000663c: 80 a2 20 00 cmp %o0, 0
40006640: 02 80 00 04 be 40006650 <rtems_termios_puts+0x80> <== ALWAYS TAKEN
40006644: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
40006648: 40 00 08 45 call 4000875c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000664c: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
40006650: 7f ff ef 7e call 40002448 <sparc_disable_interrupts>
40006654: 01 00 00 00 nop
40006658: 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) {
4000665c: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
40006660: 80 a7 40 01 cmp %i5, %g1
40006664: 22 bf ff f0 be,a 40006624 <rtems_termios_puts+0x54>
40006668: 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++;
4000666c: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
40006670: c6 0e 00 00 ldub [ %i0 ], %g3
40006674: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
40006678: b0 06 20 01 inc %i0
4000667c: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
40006680: 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;
40006684: fa 26 a0 80 st %i5, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
40006688: 80 a0 60 00 cmp %g1, 0
4000668c: 12 80 00 13 bne 400066d8 <rtems_termios_puts+0x108>
40006690: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
40006694: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
40006698: 80 88 60 10 btst 0x10, %g1
4000669c: 12 80 00 0b bne 400066c8 <rtems_termios_puts+0xf8> <== NEVER TAKEN
400066a0: 01 00 00 00 nop
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
400066a4: 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)(
400066a8: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
400066ac: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
400066b0: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
400066b4: 92 02 40 02 add %o1, %g2, %o1
400066b8: 9f c0 40 00 call %g1
400066bc: 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;
400066c0: 10 80 00 06 b 400066d8 <rtems_termios_puts+0x108>
400066c4: 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;
400066c8: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
400066cc: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
400066d0: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
400066d4: e0 26 a0 94 st %l0, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
400066d8: 7f ff ef 60 call 40002458 <sparc_enable_interrupts>
400066dc: 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) {
400066e0: 80 a6 00 19 cmp %i0, %i1
400066e4: 12 bf ff cb bne 40006610 <rtems_termios_puts+0x40>
400066e8: 01 00 00 00 nop
400066ec: 81 c7 e0 08 ret
400066f0: 81 e8 00 00 restore
40006de4 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40006de4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40006de8: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
40006dec: 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;
40006df0: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40006df4: 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);
40006df8: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
40006dfc: 92 10 20 00 clr %o1
40006e00: 40 00 04 7a call 40007fe8 <rtems_semaphore_obtain>
40006e04: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40006e08: b0 92 20 00 orcc %o0, 0, %i0
40006e0c: 12 80 00 dd bne 40007180 <rtems_termios_read+0x39c> <== NEVER TAKEN
40006e10: 03 10 00 7b sethi %hi(0x4001ec00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
40006e14: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40006e18: 85 28 a0 05 sll %g2, 5, %g2
40006e1c: 82 10 63 04 or %g1, 0x304, %g1
40006e20: 82 00 40 02 add %g1, %g2, %g1
40006e24: c2 00 60 08 ld [ %g1 + 8 ], %g1
40006e28: 80 a0 60 00 cmp %g1, 0
40006e2c: 02 80 00 06 be 40006e44 <rtems_termios_read+0x60>
40006e30: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
40006e34: 9f c0 40 00 call %g1
40006e38: 92 10 00 1c mov %i4, %o1
40006e3c: 10 80 00 ce b 40007174 <rtems_termios_read+0x390>
40006e40: b0 10 00 08 mov %o0, %i0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
40006e44: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40006e48: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40006e4c: 80 a0 80 01 cmp %g2, %g1
40006e50: 12 80 00 bf bne 4000714c <rtems_termios_read+0x368> <== NEVER TAKEN
40006e54: 80 a6 e0 00 cmp %i3, 0
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
40006e58: 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;
40006e5c: c0 27 60 20 clr [ %i5 + 0x20 ]
tty->read_start_column = tty->column;
40006e60: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
if (tty->device.pollRead != NULL &&
40006e64: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40006e68: 80 a0 60 00 cmp %g1, 0
40006e6c: 02 80 00 4c be 40006f9c <rtems_termios_read+0x1b8>
40006e70: c0 27 60 24 clr [ %i5 + 0x24 ]
40006e74: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006e78: 80 a0 60 00 cmp %g1, 0
40006e7c: 32 80 00 49 bne,a 40006fa0 <rtems_termios_read+0x1bc>
40006e80: 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) {
40006e84: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40006e88: 80 88 60 02 btst 2, %g1
40006e8c: 02 80 00 13 be 40006ed8 <rtems_termios_read+0xf4>
40006e90: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40006e94: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40006e98: 9f c0 40 00 call %g1
40006e9c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
40006ea0: 80 a2 20 00 cmp %o0, 0
40006ea4: 16 80 00 06 bge 40006ebc <rtems_termios_read+0xd8>
40006ea8: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
40006eac: 40 00 05 9b call 40008518 <rtems_task_wake_after>
40006eb0: 90 10 20 01 mov 1, %o0
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40006eb4: 10 bf ff f9 b 40006e98 <rtems_termios_read+0xb4>
40006eb8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
40006ebc: 7f ff ff 88 call 40006cdc <siproc>
40006ec0: 92 10 00 1d mov %i5, %o1
40006ec4: 80 a2 20 00 cmp %o0, 0
40006ec8: 22 bf ff f4 be,a 40006e98 <rtems_termios_read+0xb4>
40006ecc: 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)) {
40006ed0: 10 80 00 9f b 4000714c <rtems_termios_read+0x368>
40006ed4: 80 a6 e0 00 cmp %i3, 0
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
40006ed8: 40 00 02 92 call 40007920 <rtems_clock_get_ticks_since_boot>
40006edc: 01 00 00 00 nop
40006ee0: b2 10 00 08 mov %o0, %i1
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40006ee4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40006ee8: 9f c0 40 00 call %g1
40006eec: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
40006ef0: 80 a2 20 00 cmp %o0, 0
40006ef4: 36 80 00 1c bge,a 40006f64 <rtems_termios_read+0x180>
40006ef8: 90 0a 20 ff and %o0, 0xff, %o0
if (tty->termios.c_cc[VMIN]) {
40006efc: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
40006f00: 80 a0 60 00 cmp %g1, 0
40006f04: 02 80 00 0d be 40006f38 <rtems_termios_read+0x154>
40006f08: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
40006f0c: 80 88 60 ff btst 0xff, %g1
40006f10: 32 80 00 06 bne,a 40006f28 <rtems_termios_read+0x144> <== ALWAYS TAKEN
40006f14: 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);
40006f18: 40 00 05 80 call 40008518 <rtems_task_wake_after>
40006f1c: 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);
40006f20: 10 bf ff f2 b 40006ee8 <rtems_termios_read+0x104>
40006f24: 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) {
40006f28: 80 a0 60 00 cmp %g1, 0
40006f2c: 02 bf ff fb be 40006f18 <rtems_termios_read+0x134>
40006f30: 01 00 00 00 nop
40006f34: 30 80 00 04 b,a 40006f44 <rtems_termios_read+0x160>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
40006f38: 80 88 60 ff btst 0xff, %g1
40006f3c: 02 80 00 84 be 4000714c <rtems_termios_read+0x368> <== NEVER TAKEN
40006f40: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
40006f44: 40 00 02 77 call 40007920 <rtems_clock_get_ticks_since_boot>
40006f48: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
40006f4c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
40006f50: 90 22 00 19 sub %o0, %i1, %o0
40006f54: 80 a2 00 01 cmp %o0, %g1
40006f58: 08 bf ff f0 bleu 40006f18 <rtems_termios_read+0x134>
40006f5c: 80 a6 e0 00 cmp %i3, 0
40006f60: 30 80 00 7b b,a 4000714c <rtems_termios_read+0x368>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
40006f64: 7f ff ff 5e call 40006cdc <siproc>
40006f68: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
40006f6c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
40006f70: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40006f74: 80 a0 80 01 cmp %g2, %g1
40006f78: 16 80 00 74 bge 40007148 <rtems_termios_read+0x364>
40006f7c: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
40006f80: 22 bf ff da be,a 40006ee8 <rtems_termios_read+0x104> <== NEVER TAKEN
40006f84: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40006f88: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
40006f8c: 80 a0 60 00 cmp %g1, 0
40006f90: 22 bf ff d6 be,a 40006ee8 <rtems_termios_read+0x104> <== NEVER TAKEN
40006f94: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40006f98: 30 bf ff d0 b,a 40006ed8 <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;
40006f9c: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
rtems_status_code sc;
int wait = 1;
40006fa0: 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))) {
40006fa4: 23 10 00 79 sethi %hi(0x4001e400), %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);
40006fa8: 10 80 00 4b b 400070d4 <rtems_termios_read+0x2f0>
40006fac: 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;
40006fb0: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
40006fb4: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
40006fb8: 40 00 47 e6 call 40018f50 <.urem>
40006fbc: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
40006fc0: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
40006fc4: e0 08 40 08 ldub [ %g1 + %o0 ], %l0
tty->rawInBuf.Head = newHead;
40006fc8: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
40006fcc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
40006fd0: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
40006fd4: 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)
40006fd8: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
40006fdc: 40 00 47 dd call 40018f50 <.urem>
40006fe0: 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)
40006fe4: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
40006fe8: 80 a2 00 01 cmp %o0, %g1
40006fec: 3a 80 00 27 bcc,a 40007088 <rtems_termios_read+0x2a4> <== NEVER TAKEN
40006ff0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
40006ff4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006ff8: 82 08 7f fe and %g1, -2, %g1
40006ffc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
40007000: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40007004: 82 08 62 02 and %g1, 0x202, %g1
40007008: 80 a0 62 02 cmp %g1, 0x202
4000700c: 12 80 00 11 bne 40007050 <rtems_termios_read+0x26c> <== ALWAYS TAKEN
40007010: 01 00 00 00 nop
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
40007014: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
40007018: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000701c: 22 80 00 07 be,a 40007038 <rtems_termios_read+0x254> <== NOT EXECUTED
40007020: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
40007024: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40007028: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
4000702c: 02 80 00 09 be 40007050 <rtems_termios_read+0x26c> <== NOT EXECUTED
40007030: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
40007034: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40007038: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000703c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
40007040: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007044: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40007048: 10 80 00 10 b 40007088 <rtems_termios_read+0x2a4> <== NOT EXECUTED
4000704c: 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) {
40007050: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40007054: 80 88 61 00 btst 0x100, %g1
40007058: 22 80 00 0c be,a 40007088 <rtems_termios_read+0x2a4> <== ALWAYS TAKEN
4000705c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
40007060: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40007064: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
40007068: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
4000706c: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
40007070: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40007074: 22 80 00 05 be,a 40007088 <rtems_termios_read+0x2a4> <== NOT EXECUTED
40007078: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
4000707c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007080: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40007084: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
40007088: 92 10 00 1d mov %i5, %o1
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
4000708c: 80 88 60 02 btst 2, %g1
40007090: 02 80 00 09 be 400070b4 <rtems_termios_read+0x2d0> <== NEVER TAKEN
40007094: 90 0c 20 ff and %l0, 0xff, %o0
if (siproc (c, tty))
40007098: 7f ff ff 11 call 40006cdc <siproc>
4000709c: 01 00 00 00 nop
400070a0: 80 a2 20 00 cmp %o0, 0
400070a4: 22 80 00 0c be,a 400070d4 <rtems_termios_read+0x2f0>
400070a8: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
wait = 0;
400070ac: 10 80 00 09 b 400070d0 <rtems_termios_read+0x2ec>
400070b0: b2 10 20 00 clr %i1
} else {
siproc (c, tty);
400070b4: 7f ff ff 0a call 40006cdc <siproc> <== NOT EXECUTED
400070b8: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
400070bc: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
400070c0: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
400070c4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
400070c8: 36 80 00 02 bge,a 400070d0 <rtems_termios_read+0x2ec> <== NOT EXECUTED
400070cc: b2 10 20 00 clr %i1 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
400070d0: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400070d4: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
400070d8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
400070dc: 80 a0 80 01 cmp %g2, %g1
400070e0: 12 80 00 07 bne 400070fc <rtems_termios_read+0x318>
400070e4: c2 04 63 b8 ld [ %l1 + 0x3b8 ], %g1
}
/*
* Wait for characters
*/
if ( wait ) {
400070e8: 80 a6 60 00 cmp %i1, 0
400070ec: 02 80 00 18 be 4000714c <rtems_termios_read+0x368>
400070f0: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
400070f4: 10 80 00 08 b 40007114 <rtems_termios_read+0x330>
400070f8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400070fc: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
40007100: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40007104: 80 a0 80 01 cmp %g2, %g1
40007108: 0a bf ff aa bcs 40006fb0 <rtems_termios_read+0x1cc> <== ALWAYS TAKEN
4000710c: 80 a6 60 00 cmp %i1, 0
40007110: 30 bf ff f7 b,a 400070ec <rtems_termios_read+0x308> <== NOT EXECUTED
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
40007114: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
40007118: 40 00 03 b4 call 40007fe8 <rtems_semaphore_obtain>
4000711c: 94 10 00 10 mov %l0, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
40007120: 80 a2 20 00 cmp %o0, 0
40007124: 02 bf ff ec be 400070d4 <rtems_termios_read+0x2f0> <== ALWAYS TAKEN
40007128: 80 a6 e0 00 cmp %i3, 0
4000712c: 30 80 00 08 b,a 4000714c <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--;
40007130: 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++];
40007134: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
40007138: 82 00 60 01 inc %g1
4000713c: c4 2e 80 00 stb %g2, [ %i2 ]
40007140: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
40007144: b4 06 a0 01 inc %i2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
40007148: 80 a6 e0 00 cmp %i3, 0
4000714c: 22 80 00 08 be,a 4000716c <rtems_termios_read+0x388>
40007150: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40007154: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40007158: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
4000715c: 80 a0 40 02 cmp %g1, %g2
40007160: 26 bf ff f4 bl,a 40007130 <rtems_termios_read+0x34c>
40007164: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
40007168: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
4000716c: b6 20 40 1b sub %g1, %i3, %i3
40007170: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
40007174: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
40007178: 40 00 03 e5 call 4000810c <rtems_semaphore_release>
4000717c: c0 27 60 e4 clr [ %i5 + 0xe4 ]
return sc;
}
40007180: 81 c7 e0 08 ret
40007184: 81 e8 00 00 restore
40005830 <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)
{
40005830: 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))
40005834: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40005838: 82 08 64 03 and %g1, 0x403, %g1
4000583c: 80 a0 64 01 cmp %g1, 0x401
40005840: 12 80 00 0f bne 4000587c <rtems_termios_refill_transmitter+0x4c><== ALWAYS TAKEN
40005844: 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);
40005848: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
4000584c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40005850: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
40005854: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005858: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
4000585c: 7f ff f2 fb call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
40005860: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40005864: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
40005868: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000586c: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40005870: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40005874: 10 80 00 12 b 400058bc <rtems_termios_refill_transmitter+0x8c><== NOT EXECUTED
40005878: 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) {
4000587c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40005880: 82 08 60 03 and %g1, 3, %g1
40005884: 80 a0 60 02 cmp %g1, 2
40005888: 12 80 00 12 bne 400058d0 <rtems_termios_refill_transmitter+0xa0><== ALWAYS TAKEN
4000588c: 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);
40005890: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
40005894: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40005898: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000589c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
400058a0: 7f ff f2 ea call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
400058a4: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
400058a8: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
400058ac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400058b0: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
400058b4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400058b8: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
400058bc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
400058c0: 7f ff f2 e6 call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
400058c4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
400058c8: 81 c7 e0 08 ret
400058cc: 81 e8 00 00 restore
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
400058d0: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
400058d4: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
400058d8: 80 a0 80 01 cmp %g2, %g1
400058dc: 12 80 00 0a bne 40005904 <rtems_termios_refill_transmitter+0xd4>
400058e0: 01 00 00 00 nop
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
400058e4: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
400058e8: 80 a0 60 02 cmp %g1, 2
400058ec: 12 bf ff f7 bne 400058c8 <rtems_termios_refill_transmitter+0x98><== ALWAYS TAKEN
400058f0: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
400058f4: 40 00 0a 06 call 4000810c <rtems_semaphore_release> <== NOT EXECUTED
400058f8: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
400058fc: 81 c7 e0 08 ret <== NOT EXECUTED
40005900: 81 e8 00 00 restore <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
40005904: 7f ff f2 d1 call 40002448 <sparc_disable_interrupts>
40005908: 01 00 00 00 nop
len = tty->t_dqlen;
4000590c: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
40005910: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
40005914: 7f ff f2 d1 call 40002458 <sparc_enable_interrupts>
40005918: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
4000591c: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
40005920: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
40005924: 40 00 4d 8b call 40018f50 <.urem>
40005928: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
4000592c: 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;
40005930: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
40005934: 80 a0 60 02 cmp %g1, 2
40005938: 12 80 00 04 bne 40005948 <rtems_termios_refill_transmitter+0x118>
4000593c: b8 10 00 08 mov %o0, %i4
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
40005940: 40 00 09 f3 call 4000810c <rtems_semaphore_release>
40005944: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
}
if (newTail == tty->rawOutBuf.Head) {
40005948: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
4000594c: 80 a7 00 01 cmp %i4, %g1
40005950: 12 80 00 0b bne 4000597c <rtems_termios_refill_transmitter+0x14c>
40005954: 01 00 00 00 nop
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
40005958: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
4000595c: 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) {
40005960: 80 a0 60 00 cmp %g1, 0
40005964: 02 80 00 29 be 40005a08 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
40005968: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
4000596c: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
40005970: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005974: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
40005978: 30 80 00 24 b,a 40005a08 <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))
4000597c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005980: 82 08 62 10 and %g1, 0x210, %g1
40005984: 80 a0 62 10 cmp %g1, 0x210
40005988: 12 80 00 0c bne 400059b8 <rtems_termios_refill_transmitter+0x188><== ALWAYS TAKEN
4000598c: 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);
40005990: 7f ff f2 ae call 40002448 <sparc_disable_interrupts> <== NOT EXECUTED
40005994: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
40005998: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
4000599c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
400059a0: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
400059a4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400059a8: c2 27 60 94 st %g1, [ %i5 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
400059ac: 7f ff f2 ab call 40002458 <sparc_enable_interrupts> <== NOT EXECUTED
400059b0: b0 10 20 00 clr %i0 <== NOT EXECUTED
400059b4: 30 80 00 15 b,a 40005a08 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
400059b8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
400059bc: 80 a7 00 01 cmp %i4, %g1
400059c0: 08 80 00 04 bleu 400059d0 <rtems_termios_refill_transmitter+0x1a0>
400059c4: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
400059c8: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
400059cc: 30 80 00 02 b,a 400059d4 <rtems_termios_refill_transmitter+0x1a4>
else
nToSend = tty->rawOutBuf.Head - newTail;
400059d0: 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)) {
400059d4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400059d8: 80 88 66 00 btst 0x600, %g1
400059dc: 02 80 00 03 be 400059e8 <rtems_termios_refill_transmitter+0x1b8>
400059e0: b0 26 00 1c sub %i0, %i4, %i0
nToSend = 1;
400059e4: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
400059e8: 82 10 20 01 mov 1, %g1
(*tty->device.write)(
400059ec: 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*/
400059f0: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
(*tty->device.write)(
400059f4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
400059f8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
400059fc: 92 02 40 1c add %o1, %i4, %o1
40005a00: 9f c0 40 00 call %g1
40005a04: 94 10 00 18 mov %i0, %o2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40005a08: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
40005a0c: 81 c7 e0 08 ret
40005a10: 81 e8 00 00 restore
4000749c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
4000749c: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400074a0: 90 10 20 03 mov 3, %o0
400074a4: 92 10 20 02 mov 2, %o1
400074a8: 94 10 20 00 clr %o2
400074ac: 40 00 01 40 call 400079ac <rtems_event_receive>
400074b0: 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) {
400074b4: c2 07 bf fc ld [ %fp + -4 ], %g1
400074b8: 80 88 60 01 btst 1, %g1
400074bc: 22 80 00 06 be,a 400074d4 <rtems_termios_rxdaemon+0x38> <== ALWAYS TAKEN
400074c0: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
400074c4: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
400074c8: 40 00 03 9d call 4000833c <rtems_task_delete> <== NOT EXECUTED
400074cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
400074d0: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
400074d4: 9f c0 40 00 call %g1
400074d8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
400074dc: 80 a2 3f ff cmp %o0, -1
400074e0: 22 bf ff f1 be,a 400074a4 <rtems_termios_rxdaemon+0x8>
400074e4: 90 10 20 03 mov 3, %o0
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
400074e8: d0 2f bf fb stb %o0, [ %fp + -5 ]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
400074ec: 92 07 bf fb add %fp, -5, %o1
400074f0: 90 10 00 18 mov %i0, %o0
400074f4: 7f ff ff 2a call 4000719c <rtems_termios_enqueue_raw_characters>
400074f8: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400074fc: 10 bf ff ea b 400074a4 <rtems_termios_rxdaemon+0x8>
40007500: 90 10 20 03 mov 3, %o0
40005a14 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
40005a14: 9d e3 bf 98 save %sp, -104, %sp
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40005a18: 3b 10 00 7b sethi %hi(0x4001ec00), %i5
40005a1c: ba 17 63 04 or %i5, 0x304, %i5 ! 4001ef04 <rtems_termios_linesw>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40005a20: 90 10 20 03 mov 3, %o0
40005a24: 92 10 20 02 mov 2, %o1
40005a28: 94 10 20 00 clr %o2
40005a2c: 40 00 07 e0 call 400079ac <rtems_event_receive>
40005a30: 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) {
40005a34: c2 07 bf fc ld [ %fp + -4 ], %g1
40005a38: 80 88 60 01 btst 1, %g1
40005a3c: 22 80 00 06 be,a 40005a54 <rtems_termios_txdaemon+0x40> <== ALWAYS TAKEN
40005a40: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
40005a44: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40005a48: 40 00 0a 3d call 4000833c <rtems_task_delete> <== NOT EXECUTED
40005a4c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40005a50: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
40005a54: 83 28 60 05 sll %g1, 5, %g1
40005a58: 82 07 40 01 add %i5, %g1, %g1
40005a5c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40005a60: 80 a0 60 00 cmp %g1, 0
40005a64: 02 80 00 04 be 40005a74 <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
40005a68: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
40005a6c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005a70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
40005a74: 7f ff ff 6f call 40005830 <rtems_termios_refill_transmitter>
40005a78: 90 10 00 18 mov %i0, %o0
}
40005a7c: 10 bf ff ea b 40005a24 <rtems_termios_txdaemon+0x10>
40005a80: 90 10 20 03 mov 3, %o0
40006d24 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
40006d24: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40006d28: c2 06 00 00 ld [ %i0 ], %g1
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
40006d2c: b8 10 00 18 mov %i0, %i4
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40006d30: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40006d34: 92 10 20 00 clr %o1
40006d38: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
40006d3c: 40 00 04 ab call 40007fe8 <rtems_semaphore_obtain>
40006d40: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40006d44: b0 92 20 00 orcc %o0, 0, %i0
40006d48: 12 80 00 25 bne 40006ddc <rtems_termios_write+0xb8> <== NEVER TAKEN
40006d4c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
40006d50: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40006d54: 85 28 a0 05 sll %g2, 5, %g2
40006d58: 82 10 63 04 or %g1, 0x304, %g1
40006d5c: 82 00 40 02 add %g1, %g2, %g1
40006d60: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006d64: 80 a0 60 00 cmp %g1, 0
40006d68: 02 80 00 06 be 40006d80 <rtems_termios_write+0x5c>
40006d6c: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
40006d70: 9f c0 40 00 call %g1
40006d74: 92 10 00 1c mov %i4, %o1
40006d78: 10 80 00 17 b 40006dd4 <rtems_termios_write+0xb0>
40006d7c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
40006d80: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
40006d84: 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) {
40006d88: 80 88 60 01 btst 1, %g1
40006d8c: f4 07 20 14 ld [ %i4 + 0x14 ], %i2
40006d90: 12 80 00 07 bne 40006dac <rtems_termios_write+0x88> <== ALWAYS TAKEN
40006d94: 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);
40006d98: 10 80 00 0a b 40006dc0 <rtems_termios_write+0x9c> <== NOT EXECUTED
40006d9c: 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);
40006da0: 92 10 00 1d mov %i5, %o1
40006da4: 7f ff fe 54 call 400066f4 <oproc>
40006da8: 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--)
40006dac: 80 a6 c0 1a cmp %i3, %i2
40006db0: 32 bf ff fc bne,a 40006da0 <rtems_termios_write+0x7c>
40006db4: 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;
40006db8: 10 80 00 06 b 40006dd0 <rtems_termios_write+0xac>
40006dbc: 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);
40006dc0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40006dc4: 7f ff fe 03 call 400065d0 <rtems_termios_puts> <== NOT EXECUTED
40006dc8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
40006dcc: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
40006dd0: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
40006dd4: 40 00 04 ce call 4000810c <rtems_semaphore_release>
40006dd8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
40006ddc: 81 c7 e0 08 ret
40006de0: 81 e8 00 00 restore
40018c48 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
40018c48: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
40018c4c: 11 10 00 fc sethi %hi(0x4003f000), %o0
40018c50: 92 10 00 18 mov %i0, %o1
40018c54: 90 12 21 78 or %o0, 0x178, %o0
40018c58: 40 00 0c 3b call 4001bd44 <_Objects_Get>
40018c5c: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40018c60: c2 07 bf fc ld [ %fp + -4 ], %g1
40018c64: 80 a0 60 00 cmp %g1, 0
40018c68: 12 80 00 0c bne 40018c98 <rtems_timer_cancel+0x50>
40018c6c: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
40018c70: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40018c74: 80 a0 60 04 cmp %g1, 4
40018c78: 02 80 00 04 be 40018c88 <rtems_timer_cancel+0x40> <== NEVER TAKEN
40018c7c: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
40018c80: 40 00 13 b2 call 4001db48 <_Watchdog_Remove>
40018c84: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
40018c88: 40 00 0f da call 4001cbf0 <_Thread_Enable_dispatch>
40018c8c: b0 10 20 00 clr %i0
40018c90: 81 c7 e0 08 ret
40018c94: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40018c98: 81 c7 e0 08 ret
40018c9c: 91 e8 20 04 restore %g0, 4, %o0
40019158 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40019158: 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;
4001915c: 03 10 00 fc sethi %hi(0x4003f000), %g1
40019160: f8 00 61 b8 ld [ %g1 + 0x1b8 ], %i4 ! 4003f1b8 <_Timer_server>
if ( !timer_server )
40019164: 80 a7 20 00 cmp %i4, 0
40019168: 02 80 00 3c be 40019258 <rtems_timer_server_fire_when+0x100>
4001916c: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
40019170: 21 10 00 f9 sethi %hi(0x4003e400), %l0
40019174: 82 14 23 58 or %l0, 0x358, %g1 ! 4003e758 <_TOD>
40019178: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
4001917c: 80 a0 a0 00 cmp %g2, 0
40019180: 02 80 00 36 be 40019258 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
40019184: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( !routine )
40019188: 80 a6 a0 00 cmp %i2, 0
4001918c: 02 80 00 33 be 40019258 <rtems_timer_server_fire_when+0x100>
40019190: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
40019194: 7f ff f3 7f call 40015f90 <_TOD_Validate>
40019198: 90 10 00 19 mov %i1, %o0
4001919c: 80 8a 20 ff btst 0xff, %o0
400191a0: 02 80 00 2e be 40019258 <rtems_timer_server_fire_when+0x100>
400191a4: 82 10 20 14 mov 0x14, %g1
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
400191a8: 7f ff f3 40 call 40015ea8 <_TOD_To_seconds>
400191ac: 90 10 00 19 mov %i1, %o0
400191b0: b2 10 00 08 mov %o0, %i1
400191b4: d0 1c 23 58 ldd [ %l0 + 0x358 ], %o0
400191b8: 94 10 20 00 clr %o2
400191bc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400191c0: 40 00 4f e1 call 4002d144 <__divdi3>
400191c4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
400191c8: 80 a6 40 09 cmp %i1, %o1
400191cc: 08 80 00 23 bleu 40019258 <rtems_timer_server_fire_when+0x100>
400191d0: 82 10 20 14 mov 0x14, %g1
400191d4: 11 10 00 fc sethi %hi(0x4003f000), %o0
400191d8: 92 10 00 18 mov %i0, %o1
400191dc: 90 12 21 78 or %o0, 0x178, %o0
400191e0: 40 00 0a d9 call 4001bd44 <_Objects_Get>
400191e4: 94 07 bf fc add %fp, -4, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
400191e8: c2 07 bf fc ld [ %fp + -4 ], %g1
400191ec: 80 a0 60 00 cmp %g1, 0
400191f0: 12 80 00 19 bne 40019254 <rtems_timer_server_fire_when+0xfc>
400191f4: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
400191f8: 40 00 12 54 call 4001db48 <_Watchdog_Remove>
400191fc: 90 02 20 10 add %o0, 0x10, %o0
40019200: d0 1c 23 58 ldd [ %l0 + 0x358 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
40019204: 82 10 20 03 mov 3, %g1
40019208: 94 10 20 00 clr %o2
4001920c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40019210: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
40019214: f4 27 60 2c st %i2, [ %i5 + 0x2c ]
the_watchdog->id = id;
40019218: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
4001921c: f6 27 60 34 st %i3, [ %i5 + 0x34 ]
40019220: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40019224: 40 00 4f c8 call 4002d144 <__divdi3>
40019228: 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 );
4001922c: 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();
40019230: 92 26 40 09 sub %i1, %o1, %o1
(*timer_server->schedule_operation)( timer_server, the_timer );
40019234: 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();
40019238: d2 27 60 1c st %o1, [ %i5 + 0x1c ]
(*timer_server->schedule_operation)( timer_server, the_timer );
4001923c: 9f c0 40 00 call %g1
40019240: 92 10 00 1d mov %i5, %o1
_Thread_Enable_dispatch();
40019244: 40 00 0e 6b call 4001cbf0 <_Thread_Enable_dispatch>
40019248: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4001924c: 10 80 00 03 b 40019258 <rtems_timer_server_fire_when+0x100>
40019250: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40019254: 82 10 20 04 mov 4, %g1
}
40019258: 81 c7 e0 08 ret
4001925c: 91 e8 00 01 restore %g0, %g1, %o0
40003dcc <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
40003dcc: 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) {
40003dd0: 03 08 00 00 sethi %hi(0x20000000), %g1
40003dd4: 80 8e 00 01 btst %i0, %g1
40003dd8: 12 80 00 0e bne 40003e10 <rtems_verror+0x44>
40003ddc: 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 */
40003de0: 03 10 00 7a sethi %hi(0x4001e800), %g1
40003de4: c2 00 61 38 ld [ %g1 + 0x138 ], %g1 ! 4001e938 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
40003de8: 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 */
40003dec: d0 00 60 08 ld [ %g1 + 8 ], %o0
40003df0: 40 00 30 40 call 4000fef0 <fflush>
40003df4: b8 2f 40 1c andn %i5, %i4, %i4
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
40003df8: 03 10 00 00 sethi %hi(0x40000000), %g1
40003dfc: 80 8f 40 01 btst %i5, %g1
40003e00: 12 80 00 15 bne 40003e54 <rtems_verror+0x88>
40003e04: 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);
40003e08: 10 80 00 17 b 40003e64 <rtems_verror+0x98>
40003e0c: 37 10 00 7a sethi %hi(0x4001e800), %i3
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
40003e10: 05 10 00 7c sethi %hi(0x4001f000), %g2
40003e14: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 4001f2f0 <rtems_panic_in_progress>
40003e18: 86 00 60 01 add %g1, 1, %g3
40003e1c: 80 a0 60 00 cmp %g1, 0
40003e20: 02 80 00 06 be 40003e38 <rtems_verror+0x6c> <== ALWAYS TAKEN
40003e24: c6 20 a2 f0 st %g3, [ %g2 + 0x2f0 ]
*
* 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;
40003e28: 03 10 00 7d sethi %hi(0x4001f400), %g1 <== NOT EXECUTED
40003e2c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 4001f480 <_Thread_Dispatch_disable_level><== NOT EXECUTED
++level;
40003e30: 84 00 a0 01 inc %g2 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
40003e34: c4 20 60 80 st %g2, [ %g1 + 0x80 ] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
40003e38: 03 10 00 7c sethi %hi(0x4001f000), %g1
40003e3c: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 4001f2f0 <rtems_panic_in_progress>
40003e40: 80 a0 60 02 cmp %g1, 2
40003e44: 04 bf ff e7 ble 40003de0 <rtems_verror+0x14> <== ALWAYS TAKEN
40003e48: b0 10 20 00 clr %i0
40003e4c: 81 c7 e0 08 ret <== NOT EXECUTED
40003e50: 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;
40003e54: 40 00 2f 24 call 4000fae4 <__errno>
40003e58: 01 00 00 00 nop
40003e5c: 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);
40003e60: 37 10 00 7a sethi %hi(0x4001e800), %i3
40003e64: c2 06 e1 38 ld [ %i3 + 0x138 ], %g1 ! 4001e938 <_impure_ptr>
40003e68: 92 10 00 19 mov %i1, %o1
40003e6c: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40003e70: 40 00 44 b8 call 40015150 <vfprintf>
40003e74: 94 10 00 1a mov %i2, %o2
if (status)
40003e78: 80 a7 20 00 cmp %i4, 0
40003e7c: 02 80 00 0c be 40003eac <rtems_verror+0xe0>
40003e80: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
40003e84: c2 06 e1 38 ld [ %i3 + 0x138 ], %g1
40003e88: 90 10 00 1c mov %i4, %o0
40003e8c: 7f ff ff ca call 40003db4 <rtems_status_text>
40003e90: f6 00 60 0c ld [ %g1 + 0xc ], %i3
40003e94: 13 10 00 72 sethi %hi(0x4001c800), %o1
40003e98: 94 10 00 08 mov %o0, %o2
40003e9c: 92 12 63 f8 or %o1, 0x3f8, %o1
40003ea0: 40 00 31 10 call 400102e0 <fprintf>
40003ea4: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
40003ea8: b0 06 00 08 add %i0, %o0, %i0
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
40003eac: 80 a7 60 00 cmp %i5, 0
40003eb0: 22 80 00 1c be,a 40003f20 <rtems_verror+0x154>
40003eb4: 3b 10 00 7a sethi %hi(0x4001e800), %i5
if ((local_errno > 0) && *strerror(local_errno))
40003eb8: 80 a7 60 00 cmp %i5, 0
40003ebc: 04 80 00 11 ble 40003f00 <rtems_verror+0x134>
40003ec0: 03 10 00 7a sethi %hi(0x4001e800), %g1
40003ec4: 40 00 34 87 call 400110e0 <strerror>
40003ec8: 90 10 00 1d mov %i5, %o0
40003ecc: c2 4a 00 00 ldsb [ %o0 ], %g1
40003ed0: 80 a0 60 00 cmp %g1, 0
40003ed4: 02 80 00 0b be 40003f00 <rtems_verror+0x134> <== NEVER TAKEN
40003ed8: 03 10 00 7a sethi %hi(0x4001e800), %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
40003edc: c2 00 61 38 ld [ %g1 + 0x138 ], %g1 ! 4001e938 <_impure_ptr>
40003ee0: 90 10 00 1d mov %i5, %o0
40003ee4: 40 00 34 7f call 400110e0 <strerror>
40003ee8: f8 00 60 0c ld [ %g1 + 0xc ], %i4
40003eec: 13 10 00 73 sethi %hi(0x4001cc00), %o1
40003ef0: 94 10 00 08 mov %o0, %o2
40003ef4: 92 12 60 08 or %o1, 8, %o1
40003ef8: 10 80 00 07 b 40003f14 <rtems_verror+0x148>
40003efc: 90 10 00 1c mov %i4, %o0
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40003f00: c2 00 61 38 ld [ %g1 + 0x138 ], %g1
40003f04: 13 10 00 73 sethi %hi(0x4001cc00), %o1
40003f08: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40003f0c: 92 12 60 18 or %o1, 0x18, %o1
40003f10: 94 10 00 1d mov %i5, %o2
40003f14: 40 00 30 f3 call 400102e0 <fprintf>
40003f18: 3b 10 00 7a sethi %hi(0x4001e800), %i5
40003f1c: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
40003f20: c2 07 61 38 ld [ %i5 + 0x138 ], %g1
40003f24: 13 10 00 73 sethi %hi(0x4001cc00), %o1
40003f28: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40003f2c: 40 00 30 ed call 400102e0 <fprintf>
40003f30: 92 12 60 30 or %o1, 0x30, %o1
(void) fflush(stderr);
40003f34: c2 07 61 38 ld [ %i5 + 0x138 ], %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");
40003f38: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stderr);
40003f3c: 40 00 2f ed call 4000fef0 <fflush>
40003f40: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
40003f44: 81 c7 e0 08 ret
40003f48: 81 e8 00 00 restore
4002445c <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
4002445c: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
40024460: 37 1f ff ff sethi %hi(0x7ffffc00), %i3
int sign = 0;
40024464: b8 10 20 00 clr %i4
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
40024468: b6 16 e3 ff or %i3, 0x3ff, %i3
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
4002446c: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40024470: 21 10 01 82 sethi %hi(0x40060800), %l0
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
40024474: 23 10 01 82 sethi %hi(0x40060800), %l1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40024478: c2 06 20 04 ld [ %i0 + 4 ], %g1
4002447c: 82 00 7f ff add %g1, -1, %g1
40024480: 80 a0 60 00 cmp %g1, 0
40024484: 16 80 00 07 bge 400244a0 <scanInt+0x44> <== ALWAYS TAKEN
40024488: c2 26 20 04 st %g1, [ %i0 + 4 ]
4002448c: d0 04 21 60 ld [ %l0 + 0x160 ], %o0 <== NOT EXECUTED
40024490: 40 00 61 f8 call 4003cc70 <__srget_r> <== NOT EXECUTED
40024494: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
40024498: 10 80 00 07 b 400244b4 <scanInt+0x58> <== NOT EXECUTED
4002449c: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
400244a0: c4 06 00 00 ld [ %i0 ], %g2
400244a4: d0 08 80 00 ldub [ %g2 ], %o0
400244a8: 84 00 a0 01 inc %g2
400244ac: c4 26 00 00 st %g2, [ %i0 ]
if (c == ':')
400244b0: 80 a2 20 3a cmp %o0, 0x3a
400244b4: 02 80 00 21 be 40024538 <scanInt+0xdc>
400244b8: 80 a7 20 00 cmp %i4, 0
break;
if (sign == 0) {
400244bc: 12 80 00 08 bne 400244dc <scanInt+0x80>
400244c0: c4 04 61 50 ld [ %l1 + 0x150 ], %g2
if (c == '-') {
400244c4: 80 a2 20 2d cmp %o0, 0x2d
400244c8: 12 80 00 05 bne 400244dc <scanInt+0x80>
400244cc: b8 10 20 01 mov 1, %i4
sign = -1;
limit++;
400244d0: b6 06 e0 01 inc %i3
continue;
400244d4: 10 bf ff e9 b 40024478 <scanInt+0x1c>
400244d8: b8 10 3f ff mov -1, %i4
}
sign = 1;
}
if (!isdigit(c))
400244dc: 84 00 80 08 add %g2, %o0, %g2
400244e0: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
400244e4: 80 88 a0 04 btst 4, %g2
400244e8: 02 80 00 1d be 4002455c <scanInt+0x100>
400244ec: b4 02 3f d0 add %o0, -48, %i2
return 0;
d = c - '0';
if ((i > (limit / 10))
400244f0: 92 10 20 0a mov 0xa, %o1
400244f4: 40 00 b2 1e call 40050d6c <.udiv>
400244f8: 90 10 00 1b mov %i3, %o0
400244fc: 80 a7 40 08 cmp %i5, %o0
40024500: 38 80 00 15 bgu,a 40024554 <scanInt+0xf8>
40024504: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
40024508: 12 80 00 08 bne 40024528 <scanInt+0xcc>
4002450c: 83 2f 60 01 sll %i5, 1, %g1
40024510: 90 10 00 1b mov %i3, %o0
40024514: 40 00 b2 c2 call 4005101c <.urem>
40024518: 92 10 20 0a mov 0xa, %o1
4002451c: 80 a6 80 08 cmp %i2, %o0
40024520: 18 80 00 0f bgu 4002455c <scanInt+0x100> <== ALWAYS TAKEN
40024524: 83 2f 60 01 sll %i5, 1, %g1
return 0;
i = i * 10 + d;
40024528: bb 2f 60 03 sll %i5, 3, %i5
4002452c: ba 00 40 1d add %g1, %i5, %i5
40024530: 10 bf ff d2 b 40024478 <scanInt+0x1c>
40024534: ba 06 80 1d add %i2, %i5, %i5
}
if (sign == 0)
40024538: 02 80 00 07 be 40024554 <scanInt+0xf8> <== NEVER TAKEN
4002453c: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
40024540: 90 10 00 1c mov %i4, %o0
40024544: 92 10 00 1d mov %i5, %o1
40024548: 40 00 b1 cf call 40050c84 <.umul>
4002454c: b0 10 20 01 mov 1, %i0
40024550: d0 26 40 00 st %o0, [ %i1 ]
return 1;
40024554: 81 c7 e0 08 ret
40024558: 81 e8 00 00 restore
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
4002455c: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
40024560: 81 c7 e0 08 ret
40024564: 81 e8 00 00 restore
40024658 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
40024658: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4002465c: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
40024660: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40024664: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40024668: 90 10 00 18 mov %i0, %o0
4002466c: 92 10 00 19 mov %i1, %o1
40024670: 94 07 a0 4c add %fp, 0x4c, %o2
40024674: 7f ff ff bd call 40024568 <scanString>
40024678: 96 07 a0 50 add %fp, 0x50, %o3
4002467c: 80 a2 20 00 cmp %o0, 0
40024680: 12 80 00 04 bne 40024690 <scangr+0x38>
40024684: 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;
40024688: 81 c7 e0 08 ret
4002468c: 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)
40024690: 92 06 60 04 add %i1, 4, %o1
40024694: 94 07 a0 4c add %fp, 0x4c, %o2
40024698: 96 07 a0 50 add %fp, 0x50, %o3
4002469c: 7f ff ff b3 call 40024568 <scanString>
400246a0: 98 10 20 00 clr %o4
400246a4: 80 a2 20 00 cmp %o0, 0
400246a8: 02 bf ff f8 be 40024688 <scangr+0x30> <== NEVER TAKEN
400246ac: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
400246b0: 7f ff ff 6b call 4002445c <scanInt>
400246b4: 92 07 bf f8 add %fp, -8, %o1
400246b8: 80 a2 20 00 cmp %o0, 0
400246bc: 02 bf ff f3 be 40024688 <scangr+0x30> <== NEVER TAKEN
400246c0: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
400246c4: 92 07 bf fc add %fp, -4, %o1
400246c8: 94 07 a0 4c add %fp, 0x4c, %o2
400246cc: 96 07 a0 50 add %fp, 0x50, %o3
400246d0: 7f ff ff a6 call 40024568 <scanString>
400246d4: 98 10 20 01 mov 1, %o4
400246d8: 80 a2 20 00 cmp %o0, 0
400246dc: 02 bf ff eb be 40024688 <scangr+0x30> <== NEVER TAKEN
400246e0: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400246e4: 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;
400246e8: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400246ec: 84 10 00 03 mov %g3, %g2
400246f0: 10 80 00 05 b 40024704 <scangr+0xac>
400246f4: 82 10 20 01 mov 1, %g1
400246f8: 84 00 a0 01 inc %g2
if(*cp == ',')
memcount++;
400246fc: 80 a0 00 04 cmp %g0, %g4
40024700: 82 60 7f ff subx %g1, -1, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40024704: c8 48 80 00 ldsb [ %g2 ], %g4
40024708: 80 a1 20 00 cmp %g4, 0
4002470c: 32 bf ff fb bne,a 400246f8 <scangr+0xa0>
40024710: 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))
40024714: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
40024718: 83 28 60 02 sll %g1, 2, %g1
4002471c: 82 00 60 13 add %g1, 0x13, %g1
40024720: 80 a0 80 01 cmp %g2, %g1
40024724: 0a bf ff d9 bcs 40024688 <scangr+0x30> <== NEVER TAKEN
40024728: 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++) {
4002472c: 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);
40024730: 82 00 60 0f add %g1, 0xf, %g1
40024734: 82 08 7f f0 and %g1, -16, %g1
40024738: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
4002473c: c6 20 40 00 st %g3, [ %g1 ]
}
/**
* Extract a single group record from the database
*/
static int scangr(
40024740: 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++) {
40024744: 10 80 00 0a b 4002476c <scangr+0x114>
40024748: 82 00 60 01 inc %g1
if(*cp == ',') {
4002474c: 32 80 00 08 bne,a 4002476c <scangr+0x114>
40024750: 82 00 60 01 inc %g1
*cp = '\0';
40024754: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
40024758: c8 06 60 0c ld [ %i1 + 0xc ], %g4
4002475c: 87 28 a0 02 sll %g2, 2, %g3
40024760: 84 00 a0 01 inc %g2
40024764: c2 21 00 03 st %g1, [ %g4 + %g3 ]
40024768: 82 00 60 01 inc %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
4002476c: c6 48 7f ff ldsb [ %g1 + -1 ], %g3
40024770: 80 a0 e0 00 cmp %g3, 0
40024774: 32 bf ff f6 bne,a 4002474c <scangr+0xf4>
40024778: 80 a0 e0 2c cmp %g3, 0x2c
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
4002477c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40024780: 85 28 a0 02 sll %g2, 2, %g2
40024784: c0 20 40 02 clr [ %g1 + %g2 ]
return 1;
}
40024788: 81 c7 e0 08 ret
4002478c: 91 e8 20 01 restore %g0, 1, %o0
40024790 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40024790: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40024794: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40024798: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
4002479c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
400247a0: 90 10 00 18 mov %i0, %o0
400247a4: 92 10 00 19 mov %i1, %o1
400247a8: 94 07 a0 4c add %fp, 0x4c, %o2
400247ac: 7f ff ff 6f call 40024568 <scanString>
400247b0: 96 07 a0 50 add %fp, 0x50, %o3
400247b4: 80 a2 20 00 cmp %o0, 0
400247b8: 12 80 00 04 bne 400247c8 <scanpw+0x38>
400247bc: 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;
400247c0: 81 c7 e0 08 ret
400247c4: 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)
400247c8: 92 06 60 04 add %i1, 4, %o1
400247cc: 94 07 a0 4c add %fp, 0x4c, %o2
400247d0: 96 07 a0 50 add %fp, 0x50, %o3
400247d4: 7f ff ff 65 call 40024568 <scanString>
400247d8: 98 10 20 00 clr %o4
400247dc: 80 a2 20 00 cmp %o0, 0
400247e0: 02 bf ff f8 be 400247c0 <scanpw+0x30> <== NEVER TAKEN
400247e4: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
400247e8: 7f ff ff 1d call 4002445c <scanInt>
400247ec: 92 07 bf f8 add %fp, -8, %o1
400247f0: 80 a2 20 00 cmp %o0, 0
400247f4: 02 bf ff f3 be 400247c0 <scanpw+0x30>
400247f8: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
400247fc: 7f ff ff 18 call 4002445c <scanInt>
40024800: 92 07 bf fc add %fp, -4, %o1
40024804: 80 a2 20 00 cmp %o0, 0
40024808: 02 bf ff ee be 400247c0 <scanpw+0x30>
4002480c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
40024810: 92 06 60 0c add %i1, 0xc, %o1
40024814: 94 07 a0 4c add %fp, 0x4c, %o2
40024818: 96 07 a0 50 add %fp, 0x50, %o3
4002481c: 7f ff ff 53 call 40024568 <scanString>
40024820: 98 10 20 00 clr %o4
40024824: 80 a2 20 00 cmp %o0, 0
40024828: 02 bf ff e6 be 400247c0 <scanpw+0x30> <== NEVER TAKEN
4002482c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
40024830: 92 06 60 10 add %i1, 0x10, %o1
40024834: 94 07 a0 4c add %fp, 0x4c, %o2
40024838: 96 07 a0 50 add %fp, 0x50, %o3
4002483c: 7f ff ff 4b call 40024568 <scanString>
40024840: 98 10 20 00 clr %o4
40024844: 80 a2 20 00 cmp %o0, 0
40024848: 02 bf ff de be 400247c0 <scanpw+0x30> <== NEVER TAKEN
4002484c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
40024850: 92 06 60 14 add %i1, 0x14, %o1
40024854: 94 07 a0 4c add %fp, 0x4c, %o2
40024858: 96 07 a0 50 add %fp, 0x50, %o3
4002485c: 7f ff ff 43 call 40024568 <scanString>
40024860: 98 10 20 00 clr %o4
40024864: 80 a2 20 00 cmp %o0, 0
40024868: 02 bf ff d6 be 400247c0 <scanpw+0x30> <== NEVER TAKEN
4002486c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
40024870: 92 06 60 18 add %i1, 0x18, %o1
40024874: 94 07 a0 4c add %fp, 0x4c, %o2
40024878: 96 07 a0 50 add %fp, 0x50, %o3
4002487c: 7f ff ff 3b call 40024568 <scanString>
40024880: 98 10 20 01 mov 1, %o4
40024884: 80 a2 20 00 cmp %o0, 0
40024888: 02 bf ff ce be 400247c0 <scanpw+0x30>
4002488c: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
40024890: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
40024894: c2 07 bf fc ld [ %fp + -4 ], %g1
40024898: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
4002489c: 81 c7 e0 08 ret
400248a0: 91 e8 20 01 restore %g0, 1, %o0
40008348 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
40008348: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
4000834c: 80 a6 20 04 cmp %i0, 4
40008350: 18 80 00 06 bgu 40008368 <sched_get_priority_max+0x20>
40008354: 82 10 20 01 mov 1, %g1
40008358: b1 28 40 18 sll %g1, %i0, %i0
4000835c: 80 8e 20 17 btst 0x17, %i0
40008360: 12 80 00 08 bne 40008380 <sched_get_priority_max+0x38> <== ALWAYS TAKEN
40008364: 03 10 00 7c sethi %hi(0x4001f000), %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40008368: 40 00 20 0e call 400103a0 <__errno>
4000836c: b0 10 3f ff mov -1, %i0
40008370: 82 10 20 16 mov 0x16, %g1
40008374: c2 22 00 00 st %g1, [ %o0 ]
40008378: 81 c7 e0 08 ret
4000837c: 81 e8 00 00 restore
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
40008380: f0 08 61 2c ldub [ %g1 + 0x12c ], %i0
}
40008384: 81 c7 e0 08 ret
40008388: 91 ee 3f ff restore %i0, -1, %o0
4000838c <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
4000838c: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
40008390: 80 a6 20 04 cmp %i0, 4
40008394: 18 80 00 06 bgu 400083ac <sched_get_priority_min+0x20>
40008398: 82 10 20 01 mov 1, %g1
4000839c: 83 28 40 18 sll %g1, %i0, %g1
400083a0: 80 88 60 17 btst 0x17, %g1
400083a4: 12 80 00 06 bne 400083bc <sched_get_priority_min+0x30> <== ALWAYS TAKEN
400083a8: b0 10 20 01 mov 1, %i0
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
400083ac: 40 00 1f fd call 400103a0 <__errno>
400083b0: b0 10 3f ff mov -1, %i0
400083b4: 82 10 20 16 mov 0x16, %g1
400083b8: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
400083bc: 81 c7 e0 08 ret
400083c0: 81 e8 00 00 restore
400083c4 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
400083c4: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
400083c8: 80 a6 20 00 cmp %i0, 0
400083cc: 02 80 00 0b be 400083f8 <sched_rr_get_interval+0x34> <== NEVER TAKEN
400083d0: 80 a6 60 00 cmp %i1, 0
400083d4: 7f ff ef ff call 400043d0 <getpid>
400083d8: 01 00 00 00 nop
400083dc: 80 a6 00 08 cmp %i0, %o0
400083e0: 02 80 00 06 be 400083f8 <sched_rr_get_interval+0x34>
400083e4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
400083e8: 40 00 1f ee call 400103a0 <__errno>
400083ec: 01 00 00 00 nop
400083f0: 10 80 00 07 b 4000840c <sched_rr_get_interval+0x48>
400083f4: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
if ( !interval )
400083f8: 12 80 00 08 bne 40008418 <sched_rr_get_interval+0x54>
400083fc: 03 10 00 7f sethi %hi(0x4001fc00), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
40008400: 40 00 1f e8 call 400103a0 <__errno>
40008404: 01 00 00 00 nop
40008408: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4000840c: c2 22 00 00 st %g1, [ %o0 ]
40008410: 81 c7 e0 08 ret
40008414: 91 e8 3f ff restore %g0, -1, %o0
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
40008418: d0 00 62 30 ld [ %g1 + 0x230 ], %o0
4000841c: 92 10 00 19 mov %i1, %o1
40008420: 40 00 0e 63 call 4000bdac <_Timespec_From_ticks>
40008424: b0 10 20 00 clr %i0
return 0;
}
40008428: 81 c7 e0 08 ret
4000842c: 81 e8 00 00 restore
40008de0 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
40008de0: 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;
40008de4: 03 10 00 8f sethi %hi(0x40023c00), %g1
40008de8: c4 00 62 80 ld [ %g1 + 0x280 ], %g2 ! 40023e80 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40008dec: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
40008df0: 84 00 a0 01 inc %g2
40008df4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40008df8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40008dfc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
40008e00: c4 20 62 80 st %g2, [ %g1 + 0x280 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
40008e04: b4 8e 62 00 andcc %i1, 0x200, %i2
40008e08: 02 80 00 05 be 40008e1c <sem_open+0x3c>
40008e0c: b8 10 20 00 clr %i4
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
40008e10: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40008e14: 82 07 a0 4c add %fp, 0x4c, %g1
40008e18: 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 );
40008e1c: 37 10 00 90 sethi %hi(0x40024000), %i3
40008e20: 92 10 00 18 mov %i0, %o1
40008e24: 90 16 e1 44 or %i3, 0x144, %o0
40008e28: 94 07 bf f0 add %fp, -16, %o2
40008e2c: 7f ff fe 7e call 40008824 <_POSIX_Name_to_id>
40008e30: 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 ) {
40008e34: ba 92 20 00 orcc %o0, 0, %i5
40008e38: 22 80 00 0e be,a 40008e70 <sem_open+0x90>
40008e3c: 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) ) ) {
40008e40: 80 a7 60 02 cmp %i5, 2
40008e44: 12 80 00 04 bne 40008e54 <sem_open+0x74>
40008e48: 80 a6 a0 00 cmp %i2, 0
40008e4c: 12 80 00 20 bne 40008ecc <sem_open+0xec>
40008e50: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
40008e54: 40 00 0d b7 call 4000c530 <_Thread_Enable_dispatch>
40008e58: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
40008e5c: 40 00 22 eb call 40011a08 <__errno>
40008e60: 01 00 00 00 nop
40008e64: fa 22 00 00 st %i5, [ %o0 ]
40008e68: 81 c7 e0 08 ret
40008e6c: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
40008e70: 80 a6 6a 00 cmp %i1, 0xa00
40008e74: 12 80 00 0a bne 40008e9c <sem_open+0xbc>
40008e78: d2 07 bf f0 ld [ %fp + -16 ], %o1
_Thread_Enable_dispatch();
40008e7c: 40 00 0d ad call 4000c530 <_Thread_Enable_dispatch>
40008e80: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
40008e84: 40 00 22 e1 call 40011a08 <__errno>
40008e88: 01 00 00 00 nop
40008e8c: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
40008e90: c2 22 00 00 st %g1, [ %o0 ]
40008e94: 81 c7 e0 08 ret
40008e98: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
40008e9c: 94 07 bf f8 add %fp, -8, %o2
40008ea0: 40 00 09 ea call 4000b648 <_Objects_Get>
40008ea4: 90 16 e1 44 or %i3, 0x144, %o0
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
40008ea8: 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 );
40008eac: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
40008eb0: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
40008eb4: 40 00 0d 9f call 4000c530 <_Thread_Enable_dispatch>
40008eb8: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
40008ebc: 40 00 0d 9d call 4000c530 <_Thread_Enable_dispatch>
40008ec0: 01 00 00 00 nop
goto return_id;
40008ec4: 10 80 00 0d b 40008ef8 <sem_open+0x118>
40008ec8: 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(
40008ecc: 94 10 20 00 clr %o2
40008ed0: 96 10 00 1c mov %i4, %o3
40008ed4: 98 07 bf f4 add %fp, -12, %o4
40008ed8: 40 00 19 40 call 4000f3d8 <_POSIX_Semaphore_Create_support>
40008edc: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
40008ee0: 40 00 0d 94 call 4000c530 <_Thread_Enable_dispatch>
40008ee4: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
40008ee8: 80 a7 7f ff cmp %i5, -1
40008eec: 22 80 00 04 be,a 40008efc <sem_open+0x11c> <== NEVER TAKEN
40008ef0: 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;
40008ef4: f0 07 bf f4 ld [ %fp + -12 ], %i0
40008ef8: b0 06 20 08 add %i0, 8, %i0
#endif
}
40008efc: 81 c7 e0 08 ret
40008f00: 81 e8 00 00 restore
40008340 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
40008340: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
40008344: 80 a6 a0 00 cmp %i2, 0
40008348: 02 80 00 0a be 40008370 <sigaction+0x30>
4000834c: 83 2e 20 02 sll %i0, 2, %g1
*oact = _POSIX_signals_Vectors[ sig ];
40008350: 85 2e 20 04 sll %i0, 4, %g2
40008354: 82 20 80 01 sub %g2, %g1, %g1
40008358: 13 10 00 6b sethi %hi(0x4001ac00), %o1
4000835c: 90 10 00 1a mov %i2, %o0
40008360: 92 12 62 70 or %o1, 0x270, %o1
40008364: 94 10 20 0c mov 0xc, %o2
40008368: 40 00 23 56 call 400110c0 <memcpy>
4000836c: 92 02 40 01 add %o1, %g1, %o1
if ( !sig )
40008370: 80 a6 20 00 cmp %i0, 0
40008374: 32 80 00 03 bne,a 40008380 <sigaction+0x40>
40008378: 82 06 3f ff add %i0, -1, %g1
4000837c: 30 80 00 06 b,a 40008394 <sigaction+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
40008380: 80 a0 60 1f cmp %g1, 0x1f
40008384: 18 80 00 04 bgu 40008394 <sigaction+0x54>
40008388: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
4000838c: 12 80 00 08 bne 400083ac <sigaction+0x6c>
40008390: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
40008394: 40 00 21 10 call 400107d4 <__errno>
40008398: 01 00 00 00 nop
4000839c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
400083a0: c2 22 00 00 st %g1, [ %o0 ]
400083a4: 10 80 00 20 b 40008424 <sigaction+0xe4>
400083a8: 82 10 3f ff mov -1, %g1
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
400083ac: 02 80 00 1e be 40008424 <sigaction+0xe4> <== NEVER TAKEN
400083b0: 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 );
400083b4: 7f ff e9 09 call 400027d8 <sparc_disable_interrupts>
400083b8: 01 00 00 00 nop
400083bc: b8 10 00 08 mov %o0, %i4
if ( act->sa_handler == SIG_DFL ) {
400083c0: c2 06 60 08 ld [ %i1 + 8 ], %g1
400083c4: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
400083c8: 80 a0 60 00 cmp %g1, 0
400083cc: 12 80 00 0a bne 400083f4 <sigaction+0xb4>
400083d0: ba 17 62 70 or %i5, 0x270, %i5
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
400083d4: 83 2e 20 02 sll %i0, 2, %g1
400083d8: 13 10 00 64 sethi %hi(0x40019000), %o1
400083dc: b1 2e 20 04 sll %i0, 4, %i0
400083e0: 92 12 63 6c or %o1, 0x36c, %o1
400083e4: b0 26 00 01 sub %i0, %g1, %i0
400083e8: 90 07 40 18 add %i5, %i0, %o0
400083ec: 10 80 00 09 b 40008410 <sigaction+0xd0>
400083f0: 92 02 40 18 add %o1, %i0, %o1
} else {
_POSIX_signals_Clear_process_signals( sig );
400083f4: 40 00 16 5f call 4000dd70 <_POSIX_signals_Clear_process_signals>
400083f8: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
400083fc: 83 2e 20 02 sll %i0, 2, %g1
40008400: 92 10 00 19 mov %i1, %o1
40008404: b1 2e 20 04 sll %i0, 4, %i0
40008408: 90 26 00 01 sub %i0, %g1, %o0
4000840c: 90 07 40 08 add %i5, %o0, %o0
40008410: 40 00 23 2c call 400110c0 <memcpy>
40008414: 94 10 20 0c mov 0xc, %o2
}
_ISR_Enable( level );
40008418: 7f ff e8 f4 call 400027e8 <sparc_enable_interrupts>
4000841c: 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;
40008420: 82 10 20 00 clr %g1
}
40008424: 81 c7 e0 08 ret
40008428: 91 e8 00 01 restore %g0, %g1, %o0
40008884 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
40008884: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
40008888: 80 a6 20 00 cmp %i0, 0
4000888c: 02 80 00 0e be 400088c4 <sigtimedwait+0x40>
40008890: 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 ) {
40008894: 02 80 00 10 be 400088d4 <sigtimedwait+0x50>
40008898: b6 10 20 00 clr %i3
if ( !_Timespec_Is_valid( timeout ) )
4000889c: 40 00 0e ac call 4000c34c <_Timespec_Is_valid>
400088a0: 90 10 00 1a mov %i2, %o0
400088a4: 80 8a 20 ff btst 0xff, %o0
400088a8: 02 80 00 07 be 400088c4 <sigtimedwait+0x40>
400088ac: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
400088b0: 40 00 0e b9 call 4000c394 <_Timespec_To_ticks>
400088b4: 90 10 00 1a mov %i2, %o0
if ( !interval )
400088b8: b6 92 20 00 orcc %o0, 0, %i3
400088bc: 12 80 00 07 bne 400088d8 <sigtimedwait+0x54> <== ALWAYS TAKEN
400088c0: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
400088c4: 40 00 21 90 call 40010f04 <__errno>
400088c8: 01 00 00 00 nop
400088cc: 10 80 00 63 b 40008a58 <sigtimedwait+0x1d4>
400088d0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
400088d4: 80 a6 60 00 cmp %i1, 0
400088d8: 22 80 00 02 be,a 400088e0 <sigtimedwait+0x5c>
400088dc: b2 07 bf f4 add %fp, -12, %i1
the_thread = _Thread_Executing;
400088e0: 21 10 00 6d sethi %hi(0x4001b400), %l0
400088e4: a0 14 22 20 or %l0, 0x220, %l0 ! 4001b620 <_Per_CPU_Information>
400088e8: fa 04 20 10 ld [ %l0 + 0x10 ], %i5
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
400088ec: 7f ff e8 98 call 40002b4c <sparc_disable_interrupts>
400088f0: f8 07 61 50 ld [ %i5 + 0x150 ], %i4
400088f4: b4 10 00 08 mov %o0, %i2
if ( *set & api->signals_pending ) {
400088f8: c4 06 00 00 ld [ %i0 ], %g2
400088fc: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
40008900: 80 88 80 01 btst %g2, %g1
40008904: 22 80 00 12 be,a 4000894c <sigtimedwait+0xc8>
40008908: 03 10 00 6e sethi %hi(0x4001b800), %g1
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
4000890c: 7f ff ff c6 call 40008824 <_POSIX_signals_Get_lowest>
40008910: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals(
40008914: 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 );
40008918: 92 10 00 08 mov %o0, %o1
4000891c: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
40008920: 96 10 20 00 clr %o3
40008924: 90 10 00 1c mov %i4, %o0
40008928: 40 00 17 2d call 4000e5dc <_POSIX_signals_Clear_signals>
4000892c: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
40008930: 7f ff e8 8b call 40002b5c <sparc_enable_interrupts>
40008934: 90 10 00 1a mov %i2, %o0
the_info->si_code = SI_USER;
40008938: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
4000893c: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
40008940: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
40008944: 10 80 00 47 b 40008a60 <sigtimedwait+0x1dc>
40008948: fa 06 40 00 ld [ %i1 ], %i5
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
4000894c: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
40008950: 80 88 80 01 btst %g2, %g1
40008954: 22 80 00 12 be,a 4000899c <sigtimedwait+0x118>
40008958: 82 10 3f ff mov -1, %g1
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
4000895c: 7f ff ff b2 call 40008824 <_POSIX_signals_Get_lowest>
40008960: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40008964: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
40008968: ba 10 00 08 mov %o0, %i5
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
4000896c: 96 10 20 01 mov 1, %o3
40008970: 90 10 00 1c mov %i4, %o0
40008974: 92 10 00 1d mov %i5, %o1
40008978: 40 00 17 19 call 4000e5dc <_POSIX_signals_Clear_signals>
4000897c: 98 10 20 00 clr %o4
_ISR_Enable( level );
40008980: 7f ff e8 77 call 40002b5c <sparc_enable_interrupts>
40008984: 90 10 00 1a mov %i2, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
40008988: 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;
4000898c: fa 26 40 00 st %i5, [ %i1 ]
the_info->si_code = SI_USER;
40008990: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
40008994: 10 80 00 33 b 40008a60 <sigtimedwait+0x1dc>
40008998: c0 26 60 08 clr [ %i1 + 8 ]
return signo;
}
the_info->si_signo = -1;
4000899c: 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;
400089a0: 03 10 00 6c sethi %hi(0x4001b000), %g1
400089a4: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 4001b110 <_Thread_Dispatch_disable_level>
++level;
400089a8: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400089ac: c4 20 61 10 st %g2, [ %g1 + 0x110 ]
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
400089b0: 82 10 20 04 mov 4, %g1
400089b4: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
the_thread->Wait.option = *set;
400089b8: c2 06 00 00 ld [ %i0 ], %g1
the_thread->Wait.return_argument = the_info;
400089bc: 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;
400089c0: 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;
400089c4: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
400089c8: 35 10 00 6e sethi %hi(0x4001b800), %i2
400089cc: b4 16 a0 0c or %i2, 0xc, %i2 ! 4001b80c <_POSIX_signals_Wait_queue>
400089d0: f4 27 60 44 st %i2, [ %i5 + 0x44 ]
400089d4: 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 );
400089d8: 7f ff e8 61 call 40002b5c <sparc_enable_interrupts>
400089dc: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
400089e0: 90 10 00 1a mov %i2, %o0
400089e4: 92 10 00 1b mov %i3, %o1
400089e8: 15 10 00 30 sethi %hi(0x4000c000), %o2
400089ec: 40 00 0d 08 call 4000be0c <_Thread_queue_Enqueue_with_handler>
400089f0: 94 12 a1 78 or %o2, 0x178, %o2 ! 4000c178 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
400089f4: 40 00 0b d0 call 4000b934 <_Thread_Enable_dispatch>
400089f8: 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 );
400089fc: d2 06 40 00 ld [ %i1 ], %o1
40008a00: 90 10 00 1c mov %i4, %o0
40008a04: 94 10 00 19 mov %i1, %o2
40008a08: 96 10 20 00 clr %o3
40008a0c: 40 00 16 f4 call 4000e5dc <_POSIX_signals_Clear_signals>
40008a10: 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)
40008a14: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
40008a18: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40008a1c: 80 a0 60 04 cmp %g1, 4
40008a20: 12 80 00 09 bne 40008a44 <sigtimedwait+0x1c0>
40008a24: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
40008a28: fa 06 40 00 ld [ %i1 ], %i5
40008a2c: 82 07 7f ff add %i5, -1, %g1
40008a30: a3 2c 40 01 sll %l1, %g1, %l1
40008a34: c2 06 00 00 ld [ %i0 ], %g1
40008a38: 80 8c 40 01 btst %l1, %g1
40008a3c: 12 80 00 09 bne 40008a60 <sigtimedwait+0x1dc>
40008a40: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
40008a44: 40 00 21 30 call 40010f04 <__errno>
40008a48: 01 00 00 00 nop
40008a4c: 03 10 00 6d sethi %hi(0x4001b400), %g1
40008a50: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 4001b630 <_Per_CPU_Information+0x10>
40008a54: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40008a58: c2 22 00 00 st %g1, [ %o0 ]
return -1;
40008a5c: ba 10 3f ff mov -1, %i5
}
return the_info->si_signo;
}
40008a60: 81 c7 e0 08 ret
40008a64: 91 e8 00 1d restore %g0, %i5, %o0
4000a79c <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
4000a79c: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
4000a7a0: 92 10 20 00 clr %o1
4000a7a4: 90 10 00 18 mov %i0, %o0
4000a7a8: 7f ff ff 80 call 4000a5a8 <sigtimedwait>
4000a7ac: 94 10 20 00 clr %o2
if ( status != -1 ) {
4000a7b0: 80 a2 3f ff cmp %o0, -1
4000a7b4: 02 80 00 06 be 4000a7cc <sigwait+0x30>
4000a7b8: 80 a6 60 00 cmp %i1, 0
if ( sig )
4000a7bc: 32 80 00 09 bne,a 4000a7e0 <sigwait+0x44> <== ALWAYS TAKEN
4000a7c0: d0 26 40 00 st %o0, [ %i1 ]
*sig = status;
return 0;
4000a7c4: 81 c7 e0 08 ret <== NOT EXECUTED
4000a7c8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
return errno;
4000a7cc: 40 00 20 60 call 4001294c <__errno>
4000a7d0: 01 00 00 00 nop
4000a7d4: f0 02 00 00 ld [ %o0 ], %i0
4000a7d8: 81 c7 e0 08 ret
4000a7dc: 81 e8 00 00 restore
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
4000a7e0: b0 10 20 00 clr %i0
}
return errno;
}
4000a7e4: 81 c7 e0 08 ret
4000a7e8: 81 e8 00 00 restore
40006cdc <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
40006cdc: 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)) {
40006ce0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006ce4: 80 88 6e 78 btst 0xe78, %g1
40006ce8: 02 80 00 0d be 40006d1c <siproc+0x40> <== NEVER TAKEN
40006cec: 94 10 20 00 clr %o2
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40006cf0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
40006cf4: 40 00 04 bd call 40007fe8 <rtems_semaphore_obtain>
40006cf8: 92 10 20 00 clr %o1
i = iproc (c, tty);
40006cfc: 90 10 00 18 mov %i0, %o0
40006d00: 7f ff ff 6b call 40006aac <iproc>
40006d04: 92 10 00 19 mov %i1, %o1
40006d08: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
40006d0c: 40 00 05 00 call 4000810c <rtems_semaphore_release>
40006d10: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
40006d14: 81 c7 e0 08 ret
40006d18: 81 e8 00 00 restore
}
else {
i = iproc (c, tty);
40006d1c: 7f ff ff 64 call 40006aac <iproc> <== NOT EXECUTED
40006d20: 81 e8 00 00 restore <== NOT EXECUTED
4000f10c <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 )
{
4000f10c: 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 ) {
4000f110: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000f114: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000f118: 80 a6 40 01 cmp %i1, %g1
4000f11c: 12 80 00 7f bne 4000f318 <sparse_disk_ioctl+0x20c>
4000f120: fa 06 20 3c ld [ %i0 + 0x3c ], %i5
rtems_blkdev_request *r = argp;
switch ( r->req ) {
4000f124: e8 06 80 00 ld [ %i2 ], %l4
4000f128: 80 a5 20 01 cmp %l4, 1
4000f12c: 18 80 00 95 bgu 4000f380 <sparse_disk_ioctl+0x274> <== NEVER TAKEN
4000f130: 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 );
4000f134: d0 07 40 00 ld [ %i5 ], %o0
4000f138: 94 10 20 00 clr %o2
4000f13c: 7f ff eb a8 call 40009fdc <rtems_semaphore_obtain>
4000f140: 25 10 00 3c sethi %hi(0x4000f000), %l2
static int sparse_disk_read_write(
rtems_sparse_disk *sparse_disk,
rtems_blkdev_request *req,
const bool read )
{
int rv = 0;
4000f144: 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;
4000f148: 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(
4000f14c: 10 80 00 63 b 4000f2d8 <sparse_disk_ioctl+0x1cc>
4000f150: a4 14 a0 d8 or %l2, 0xd8, %l2
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
4000f154: 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];
4000f158: 84 00 a0 18 add %g2, 0x18, %g2
4000f15c: 82 06 80 02 add %i2, %g2, %g1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
4000f160: 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;
4000f164: ea 00 60 08 ld [ %g1 + 8 ], %l5
block = scatter_gather->block;
buff_size = scatter_gather->length;
4000f168: 10 80 00 54 b 4000f2b8 <sparse_disk_ioctl+0x1ac>
4000f16c: 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 = {
4000f170: c0 27 bf fc clr [ %fp + -4 ]
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
4000f174: 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 )
4000f178: 80 a5 20 00 cmp %l4, 0
4000f17c: 12 80 00 1a bne 4000f1e4 <sparse_disk_ioctl+0xd8>
4000f180: a2 05 40 13 add %l5, %l3, %l1
4000f184: 80 a7 00 01 cmp %i4, %g1
4000f188: 08 80 00 03 bleu 4000f194 <sparse_disk_ioctl+0x88>
4000f18c: b6 10 00 1c mov %i4, %i3
4000f190: 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(
4000f194: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
4000f198: d4 07 60 08 ld [ %i5 + 8 ], %o2
4000f19c: 90 07 bf f8 add %fp, -8, %o0
4000f1a0: 96 10 20 08 mov 8, %o3
4000f1a4: 40 00 31 c6 call 4001b8bc <bsearch>
4000f1a8: 98 10 00 12 mov %l2, %o4
4000f1ac: 82 10 00 08 mov %o0, %g1
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
4000f1b0: 80 a0 60 00 cmp %g1, 0
4000f1b4: 02 80 00 07 be 4000f1d0 <sparse_disk_ioctl+0xc4>
4000f1b8: 90 10 00 11 mov %l1, %o0
memcpy( buffer, key->data, bytes_to_copy );
4000f1bc: d2 00 60 04 ld [ %g1 + 4 ], %o1
4000f1c0: 40 00 34 86 call 4001c3d8 <memcpy>
4000f1c4: 94 10 00 1b mov %i3, %o2
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000f1c8: 10 80 00 3a b 4000f2b0 <sparse_disk_ioctl+0x1a4>
4000f1cc: 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 );
4000f1d0: d2 0f 60 14 ldub [ %i5 + 0x14 ], %o1
4000f1d4: 40 00 34 be call 4001c4cc <memset>
4000f1d8: 94 10 00 1c mov %i4, %o2
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000f1dc: 10 80 00 35 b 4000f2b0 <sparse_disk_ioctl+0x1a4>
4000f1e0: b2 06 60 01 inc %i1
4000f1e4: 80 a7 00 01 cmp %i4, %g1
4000f1e8: 08 80 00 03 bleu 4000f1f4 <sparse_disk_ioctl+0xe8>
4000f1ec: a0 10 00 1c mov %i4, %l0
4000f1f0: 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(
4000f1f4: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
4000f1f8: d4 07 60 08 ld [ %i5 + 8 ], %o2
4000f1fc: 90 07 bf f8 add %fp, -8, %o0
4000f200: 96 10 20 08 mov 8, %o3
4000f204: 40 00 31 ae call 4001b8bc <bsearch>
4000f208: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
4000f20c: b6 92 20 00 orcc %o0, 0, %i3
4000f210: 32 80 00 23 bne,a 4000f29c <sparse_disk_ioctl+0x190>
4000f214: d0 06 e0 04 ld [ %i3 + 4 ], %o0
4000f218: 10 80 00 08 b 4000f238 <sparse_disk_ioctl+0x12c>
4000f21c: 84 10 20 00 clr %g2
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
if ( buffer[i] != sparse_disk->fill_pattern )
4000f220: 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 ) {
4000f224: 82 00 60 01 inc %g1
if ( buffer[i] != sparse_disk->fill_pattern )
4000f228: 84 18 c0 02 xor %g3, %g2, %g2
4000f22c: 80 a0 00 02 cmp %g0, %g2
4000f230: 10 80 00 03 b 4000f23c <sparse_disk_ioctl+0x130>
4000f234: 84 40 20 00 addx %g0, 0, %g2
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
4000f238: 82 10 20 00 clr %g1
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000f23c: 80 a0 40 10 cmp %g1, %l0
4000f240: 1a 80 00 05 bcc 4000f254 <sparse_disk_ioctl+0x148>
4000f244: 86 18 a0 01 xor %g2, 1, %g3
4000f248: 80 88 e0 ff btst 0xff, %g3
4000f24c: 32 bf ff f5 bne,a 4000f220 <sparse_disk_ioctl+0x114>
4000f250: c6 0c 40 01 ldub [ %l1 + %g1 ], %g3
if ( buffer[i] != sparse_disk->fill_pattern )
block_needs_writing = true;
}
if ( block_needs_writing ) {
4000f254: 80 88 a0 ff btst 0xff, %g2
4000f258: 22 80 00 15 be,a 4000f2ac <sparse_disk_ioctl+0x1a0>
4000f25c: 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 ) {
4000f260: d2 07 60 08 ld [ %i5 + 8 ], %o1
4000f264: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000f268: 80 a2 40 01 cmp %o1, %g1
4000f26c: 1a 80 00 10 bcc 4000f2ac <sparse_disk_ioctl+0x1a0> <== NEVER TAKEN
4000f270: b6 10 3f ff mov -1, %i3
key = &sparse_disk->key_table[sparse_disk->used_count];
4000f274: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
4000f278: 83 2a 60 03 sll %o1, 3, %g1
key->block = block;
4000f27c: f2 22 00 01 st %i1, [ %o0 + %g1 ]
++sparse_disk->used_count;
4000f280: 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];
4000f284: b6 02 00 01 add %o0, %g1, %i3
key->block = block;
++sparse_disk->used_count;
4000f288: d2 27 60 08 st %o1, [ %i5 + 8 ]
qsort( sparse_disk->key_table, sparse_disk->used_count,
4000f28c: 94 10 20 08 mov 8, %o2
4000f290: 40 00 34 d5 call 4001c5e4 <qsort>
4000f294: 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 );
4000f298: d0 06 e0 04 ld [ %i3 + 4 ], %o0
4000f29c: 92 10 00 11 mov %l1, %o1
4000f2a0: 40 00 34 4e call 4001c3d8 <memcpy>
4000f2a4: 94 10 00 10 mov %l0, %o2
else if ( block_needs_writing )
return -1;
return bytes_to_copy;
4000f2a8: b6 10 00 10 mov %l0, %i3
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000f2ac: b2 06 60 01 inc %i1
bytes_handled += rv;
4000f2b0: a6 04 c0 1b add %l3, %i3, %l3
buff_size -= rv;
4000f2b4: 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 ) ) {
4000f2b8: 80 a7 20 00 cmp %i4, 0
4000f2bc: 02 80 00 04 be 4000f2cc <sparse_disk_ioctl+0x1c0>
4000f2c0: 80 a6 e0 00 cmp %i3, 0
4000f2c4: 36 bf ff ab bge,a 4000f170 <sparse_disk_ioctl+0x64> <== ALWAYS TAKEN
4000f2c8: 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;
4000f2cc: 80 a6 e0 00 cmp %i3, 0
4000f2d0: 06 80 00 06 bl 4000f2e8 <sparse_disk_ioctl+0x1dc> <== NEVER TAKEN
4000f2d4: b0 06 20 01 inc %i0
( 0 <= rv ) && ( req_buffer < req->bufnum );
4000f2d8: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000f2dc: 80 a6 00 01 cmp %i0, %g1
4000f2e0: 0a bf ff 9d bcs 4000f154 <sparse_disk_ioctl+0x48>
4000f2e4: 85 2e 20 04 sll %i0, 4, %g2
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
4000f2e8: 7f ff eb 86 call 4000a100 <rtems_semaphore_release>
4000f2ec: 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);
4000f2f0: 90 10 00 1a mov %i2, %o0
4000f2f4: 92 10 20 1b mov 0x1b, %o1
if ( 0 > rv )
4000f2f8: 80 a6 e0 00 cmp %i3, 0
4000f2fc: 06 80 00 03 bl 4000f308 <sparse_disk_ioctl+0x1fc> <== NEVER TAKEN
4000f300: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000f304: 92 10 20 00 clr %o1
4000f308: 9f c0 40 00 call %g1
4000f30c: b0 10 20 00 clr %i0
4000f310: 81 c7 e0 08 ret
4000f314: 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 ) {
4000f318: 03 08 00 10 sethi %hi(0x20004000), %g1
4000f31c: 82 10 62 07 or %g1, 0x207, %g1 ! 20004207 <RAM_SIZE+0x1fc04207>
4000f320: 80 a6 40 01 cmp %i1, %g1
4000f324: 12 80 00 12 bne 4000f36c <sparse_disk_ioctl+0x260>
4000f328: 90 10 00 18 mov %i0, %o0
sc = rtems_semaphore_delete( sd->mutex );
4000f32c: 7f ff ea fd call 40009f20 <rtems_semaphore_delete>
4000f330: d0 07 40 00 ld [ %i5 ], %o0
if ( RTEMS_SUCCESSFUL != sc )
4000f334: 80 a2 20 00 cmp %o0, 0
4000f338: 22 80 00 05 be,a 4000f34c <sparse_disk_ioctl+0x240> <== ALWAYS TAKEN
4000f33c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
rtems_fatal_error_occurred( 0xdeadbeef );
4000f340: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
4000f344: 7f ff ec ff call 4000a740 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000f348: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
sd->mutex = RTEMS_ID_NONE;
4000f34c: c0 27 40 00 clr [ %i5 ]
if ( NULL != sd->delete_handler )
4000f350: 80 a0 60 00 cmp %g1, 0
4000f354: 02 bf ff ef be 4000f310 <sparse_disk_ioctl+0x204> <== NEVER TAKEN
4000f358: b0 10 20 00 clr %i0
( *sd->delete_handler )( sd );
4000f35c: 9f c0 40 00 call %g1
4000f360: 90 10 00 1d mov %i5, %o0
4000f364: 81 c7 e0 08 ret
4000f368: 81 e8 00 00 restore
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
4000f36c: 92 10 00 19 mov %i1, %o1
4000f370: 40 00 0b 2f call 4001202c <rtems_blkdev_ioctl>
4000f374: 94 10 00 1a mov %i2, %o2
4000f378: 81 c7 e0 08 ret
4000f37c: 91 e8 00 08 restore %g0, %o0, %o0
}
errno = EINVAL;
4000f380: 40 00 31 71 call 4001b944 <__errno> <== NOT EXECUTED
4000f384: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000f388: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000f38c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
4000f390: 81 c7 e0 08 ret <== NOT EXECUTED
4000f394: 81 e8 00 00 restore <== NOT EXECUTED
40006354 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
40006354: 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;
40006358: c4 06 21 48 ld [ %i0 + 0x148 ], %g2
if ( this_reent ) {
4000635c: 80 a0 a0 00 cmp %g2, 0
40006360: 02 80 00 0c be 40006390 <sync_per_thread+0x3c> <== NEVER TAKEN
40006364: 3b 10 00 63 sethi %hi(0x40018c00), %i5
current_reent = _Thread_Executing->libc_reent;
40006368: ba 17 63 30 or %i5, 0x330, %i5 ! 40018f30 <_Per_CPU_Information>
4000636c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
40006370: 13 10 00 18 sethi %hi(0x40006000), %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;
40006374: f8 00 61 48 ld [ %g1 + 0x148 ], %i4
_Thread_Executing->libc_reent = this_reent;
40006378: c4 20 61 48 st %g2, [ %g1 + 0x148 ]
_fwalk (t->libc_reent, sync_wrapper);
4000637c: d0 06 21 48 ld [ %i0 + 0x148 ], %o0
40006380: 40 00 2c 25 call 40011414 <_fwalk>
40006384: 92 12 63 98 or %o1, 0x398, %o1
_Thread_Executing->libc_reent = current_reent;
40006388: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000638c: f8 20 61 48 st %i4, [ %g1 + 0x148 ]
40006390: 81 c7 e0 08 ret
40006394: 81 e8 00 00 restore
40007618 <sysconf>:
*/
long sysconf(
int name
)
{
40007618: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
4000761c: 80 a6 20 02 cmp %i0, 2
40007620: 12 80 00 09 bne 40007644 <sysconf+0x2c>
40007624: 03 10 00 5d sethi %hi(0x40017400), %g1
return (TOD_MICROSECONDS_PER_SECOND /
40007628: 03 10 00 57 sethi %hi(0x40015c00), %g1
4000762c: d2 00 60 44 ld [ %g1 + 0x44 ], %o1 ! 40015c44 <Configuration+0xc>
40007630: 11 00 03 d0 sethi %hi(0xf4000), %o0
40007634: 40 00 30 64 call 400137c4 <.udiv>
40007638: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
4000763c: 81 c7 e0 08 ret
40007640: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
40007644: 80 a6 20 04 cmp %i0, 4
40007648: 02 80 00 13 be 40007694 <sysconf+0x7c>
4000764c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
40007650: 80 a6 20 33 cmp %i0, 0x33
40007654: 02 80 00 10 be 40007694 <sysconf+0x7c>
40007658: 90 10 24 00 mov 0x400, %o0
return 1024;
if ( name == _SC_PAGESIZE )
4000765c: 80 a6 20 08 cmp %i0, 8
40007660: 02 80 00 0d be 40007694 <sysconf+0x7c>
40007664: 11 00 00 04 sethi %hi(0x1000), %o0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
40007668: 80 a6 20 4f cmp %i0, 0x4f
4000766c: 02 80 00 0a be 40007694 <sysconf+0x7c> <== NEVER TAKEN
40007670: 90 10 20 20 mov 0x20, %o0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
40007674: 80 a6 22 03 cmp %i0, 0x203
40007678: 02 80 00 07 be 40007694 <sysconf+0x7c> <== NEVER TAKEN
4000767c: 90 10 20 00 clr %o0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40007680: 40 00 20 de call 4000f9f8 <__errno>
40007684: 01 00 00 00 nop
40007688: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
4000768c: c2 22 00 00 st %g1, [ %o0 ]
40007690: 90 10 3f ff mov -1, %o0
}
40007694: b0 10 00 08 mov %o0, %i0
40007698: 81 c7 e0 08 ret
4000769c: 81 e8 00 00 restore
400137f0 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
400137f0: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
400137f4: 80 a6 60 00 cmp %i1, 0
400137f8: 02 80 00 10 be 40013838 <tcsetattr+0x48>
400137fc: 80 a6 60 01 cmp %i1, 1
40013800: 02 80 00 08 be 40013820 <tcsetattr+0x30>
40013804: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
40013808: 40 00 10 b2 call 40017ad0 <__errno>
4001380c: b0 10 3f ff mov -1, %i0
40013810: 82 10 20 86 mov 0x86, %g1
40013814: c2 22 00 00 st %g1, [ %o0 ]
40013818: 81 c7 e0 08 ret
4001381c: 81 e8 00 00 restore
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
40013820: 92 10 20 03 mov 3, %o1
40013824: 40 00 0d 4b call 40016d50 <ioctl>
40013828: 94 10 20 00 clr %o2
4001382c: 80 a2 20 00 cmp %o0, 0
40013830: 26 80 00 04 bl,a 40013840 <tcsetattr+0x50> <== NEVER TAKEN
40013834: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
40013838: 40 00 0d 46 call 40016d50 <ioctl>
4001383c: 93 e8 20 02 restore %g0, 2, %o1
}
}
40013840: 81 c7 e0 08 ret <== NOT EXECUTED
40013844: 81 e8 00 00 restore <== NOT EXECUTED
40008f04 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
40008f04: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
40008f08: 80 a6 20 01 cmp %i0, 1
40008f0c: 12 80 00 13 bne 40008f58 <timer_create+0x54>
40008f10: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
40008f14: 02 80 00 11 be 40008f58 <timer_create+0x54>
40008f18: 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) {
40008f1c: 02 80 00 13 be 40008f68 <timer_create+0x64>
40008f20: 03 10 00 8f sethi %hi(0x40023c00), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
40008f24: c2 06 40 00 ld [ %i1 ], %g1
40008f28: 82 00 7f ff add %g1, -1, %g1
40008f2c: 80 a0 60 01 cmp %g1, 1
40008f30: 28 80 00 03 bleu,a 40008f3c <timer_create+0x38> <== ALWAYS TAKEN
40008f34: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008f38: 30 80 00 08 b,a 40008f58 <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 )
40008f3c: 80 a0 60 00 cmp %g1, 0
40008f40: 32 80 00 03 bne,a 40008f4c <timer_create+0x48> <== ALWAYS TAKEN
40008f44: 82 00 7f ff add %g1, -1, %g1
40008f48: 30 80 00 04 b,a 40008f58 <timer_create+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
40008f4c: 80 a0 60 1f cmp %g1, 0x1f
40008f50: 28 80 00 06 bleu,a 40008f68 <timer_create+0x64> <== ALWAYS TAKEN
40008f54: 03 10 00 8f sethi %hi(0x40023c00), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
40008f58: 40 00 22 ac call 40011a08 <__errno>
40008f5c: 01 00 00 00 nop
40008f60: 10 80 00 10 b 40008fa0 <timer_create+0x9c>
40008f64: 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;
40008f68: c4 00 62 80 ld [ %g1 + 0x280 ], %g2
++level;
40008f6c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008f70: c4 20 62 80 st %g2, [ %g1 + 0x280 ]
* 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 );
40008f74: 11 10 00 90 sethi %hi(0x40024000), %o0
40008f78: 40 00 08 6e call 4000b130 <_Objects_Allocate>
40008f7c: 90 12 21 84 or %o0, 0x184, %o0 ! 40024184 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
40008f80: 80 a2 20 00 cmp %o0, 0
40008f84: 12 80 00 0a bne 40008fac <timer_create+0xa8>
40008f88: 82 10 20 02 mov 2, %g1
_Thread_Enable_dispatch();
40008f8c: 40 00 0d 69 call 4000c530 <_Thread_Enable_dispatch>
40008f90: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
40008f94: 40 00 22 9d call 40011a08 <__errno>
40008f98: 01 00 00 00 nop
40008f9c: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
40008fa0: c2 22 00 00 st %g1, [ %o0 ]
40008fa4: 81 c7 e0 08 ret
40008fa8: 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;
40008fac: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
40008fb0: 03 10 00 90 sethi %hi(0x40024000), %g1
40008fb4: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 400243e0 <_Per_CPU_Information+0x10>
if ( evp != NULL ) {
40008fb8: 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;
40008fbc: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
40008fc0: 02 80 00 08 be 40008fe0 <timer_create+0xdc>
40008fc4: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
40008fc8: c2 06 40 00 ld [ %i1 ], %g1
40008fcc: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
40008fd0: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008fd4: c2 22 20 44 st %g1, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
40008fd8: c2 06 60 08 ld [ %i1 + 8 ], %g1
40008fdc: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008fe0: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008fe4: 07 10 00 90 sethi %hi(0x40024000), %g3
40008fe8: c6 00 e1 a0 ld [ %g3 + 0x1a0 ], %g3 ! 400241a0 <_POSIX_Timer_Information+0x1c>
}
ptimer->overrun = 0;
40008fec: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
40008ff0: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
40008ff4: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
40008ff8: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
40008ffc: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40009000: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
40009004: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
40009008: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
4000900c: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40009010: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40009014: 85 28 a0 02 sll %g2, 2, %g2
40009018: 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;
4000901c: 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;
40009020: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
40009024: 40 00 0d 43 call 4000c530 <_Thread_Enable_dispatch>
40009028: b0 10 20 00 clr %i0
return 0;
}
4000902c: 81 c7 e0 08 ret
40009030: 81 e8 00 00 restore
40007b0c <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
40007b0c: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
40007b10: 80 a6 a0 00 cmp %i2, 0
40007b14: 02 80 00 80 be 40007d14 <timer_settime+0x208> <== NEVER TAKEN
40007b18: 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) ) ) {
40007b1c: 40 00 0f 36 call 4000b7f4 <_Timespec_Is_valid>
40007b20: 90 06 a0 08 add %i2, 8, %o0
40007b24: 80 8a 20 ff btst 0xff, %o0
40007b28: 02 80 00 7b be 40007d14 <timer_settime+0x208>
40007b2c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
40007b30: 40 00 0f 31 call 4000b7f4 <_Timespec_Is_valid>
40007b34: 90 10 00 1a mov %i2, %o0
40007b38: 80 8a 20 ff btst 0xff, %o0
40007b3c: 02 80 00 76 be 40007d14 <timer_settime+0x208> <== NEVER TAKEN
40007b40: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
40007b44: 12 80 00 74 bne 40007d14 <timer_settime+0x208>
40007b48: 90 07 bf f0 add %fp, -16, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
40007b4c: 92 10 00 1a mov %i2, %o1
40007b50: 40 00 24 66 call 40010ce8 <memcpy>
40007b54: 94 10 20 10 mov 0x10, %o2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
40007b58: 80 a6 60 04 cmp %i1, 4
40007b5c: 12 80 00 1f bne 40007bd8 <timer_settime+0xcc>
40007b60: 11 10 00 80 sethi %hi(0x40020000), %o0
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40007b64: 90 07 bf e0 add %fp, -32, %o0
40007b68: 13 10 00 7f sethi %hi(0x4001fc00), %o1
40007b6c: 40 00 06 74 call 4000953c <_TOD_Get_with_nanoseconds>
40007b70: 92 12 62 28 or %o1, 0x228, %o1 ! 4001fe28 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40007b74: 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);
40007b78: 94 10 20 00 clr %o2
40007b7c: 90 10 00 1c mov %i4, %o0
40007b80: 92 10 00 1d mov %i5, %o1
40007b84: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007b88: 40 00 48 92 call 40019dd0 <__divdi3>
40007b8c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007b90: 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);
40007b94: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007b98: 90 10 00 1c mov %i4, %o0
40007b9c: 92 10 00 1d mov %i5, %o1
40007ba0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007ba4: 40 00 49 76 call 4001a17c <__moddi3>
40007ba8: 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 ) )
40007bac: 90 07 bf f8 add %fp, -8, %o0
40007bb0: d2 27 bf ec st %o1, [ %fp + -20 ]
40007bb4: 40 00 0f 22 call 4000b83c <_Timespec_Less_than>
40007bb8: 92 07 bf e8 add %fp, -24, %o1
40007bbc: 80 8a 20 ff btst 0xff, %o0
40007bc0: 12 80 00 55 bne 40007d14 <timer_settime+0x208>
40007bc4: 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 );
40007bc8: 90 07 bf e8 add %fp, -24, %o0
40007bcc: 40 00 0f 2c call 4000b87c <_Timespec_Subtract>
40007bd0: 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 *)
40007bd4: 11 10 00 80 sethi %hi(0x40020000), %o0
40007bd8: 92 10 00 18 mov %i0, %o1
40007bdc: 90 12 21 a4 or %o0, 0x1a4, %o0
40007be0: 40 00 08 fe call 40009fd8 <_Objects_Get>
40007be4: 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 ) {
40007be8: c2 07 bf dc ld [ %fp + -36 ], %g1
40007bec: 80 a0 60 00 cmp %g1, 0
40007bf0: 12 80 00 49 bne 40007d14 <timer_settime+0x208>
40007bf4: 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 ) {
40007bf8: c2 07 bf f8 ld [ %fp + -8 ], %g1
40007bfc: 80 a0 60 00 cmp %g1, 0
40007c00: 12 80 00 14 bne 40007c50 <timer_settime+0x144>
40007c04: c2 07 bf fc ld [ %fp + -4 ], %g1
40007c08: 80 a0 60 00 cmp %g1, 0
40007c0c: 12 80 00 11 bne 40007c50 <timer_settime+0x144>
40007c10: 01 00 00 00 nop
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
40007c14: 40 00 10 28 call 4000bcb4 <_Watchdog_Remove>
40007c18: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
40007c1c: 80 a6 e0 00 cmp %i3, 0
40007c20: 02 80 00 05 be 40007c34 <timer_settime+0x128>
40007c24: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
40007c28: 92 06 60 54 add %i1, 0x54, %o1
40007c2c: 40 00 24 2f call 40010ce8 <memcpy>
40007c30: 94 10 20 10 mov 0x10, %o2
/* The new data are set */
ptimer->timer_data = normalize;
40007c34: 90 06 60 54 add %i1, 0x54, %o0
40007c38: 92 07 bf f0 add %fp, -16, %o1
40007c3c: 40 00 24 2b call 40010ce8 <memcpy>
40007c40: 94 10 20 10 mov 0x10, %o2
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
40007c44: 82 10 20 04 mov 4, %g1
40007c48: 10 80 00 2f b 40007d04 <timer_settime+0x1f8>
40007c4c: 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 );
40007c50: 40 00 0f 1c call 4000b8c0 <_Timespec_To_ticks>
40007c54: 90 10 00 1a mov %i2, %o0
40007c58: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
40007c5c: 40 00 0f 19 call 4000b8c0 <_Timespec_To_ticks>
40007c60: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
40007c64: 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 );
40007c68: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
40007c6c: 17 10 00 1f sethi %hi(0x40007c00), %o3
40007c70: 90 06 60 10 add %i1, 0x10, %o0
40007c74: 96 12 e1 2c or %o3, 0x12c, %o3
40007c78: 40 00 18 08 call 4000dc98 <_POSIX_Timer_Insert_helper>
40007c7c: 98 10 00 19 mov %i1, %o4
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
40007c80: 80 8a 20 ff btst 0xff, %o0
40007c84: 02 80 00 20 be 40007d04 <timer_settime+0x1f8>
40007c88: 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 )
40007c8c: 02 80 00 05 be 40007ca0 <timer_settime+0x194>
40007c90: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
40007c94: 92 06 60 54 add %i1, 0x54, %o1
40007c98: 40 00 24 14 call 40010ce8 <memcpy>
40007c9c: 94 10 20 10 mov 0x10, %o2
ptimer->timer_data = normalize;
40007ca0: 94 10 20 10 mov 0x10, %o2
40007ca4: 92 07 bf f0 add %fp, -16, %o1
40007ca8: 40 00 24 10 call 40010ce8 <memcpy>
40007cac: 90 06 60 54 add %i1, 0x54, %o0
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
40007cb0: 82 10 20 03 mov 3, %g1
40007cb4: 90 07 bf e0 add %fp, -32, %o0
40007cb8: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
40007cbc: 13 10 00 7f sethi %hi(0x4001fc00), %o1
40007cc0: 40 00 06 1f call 4000953c <_TOD_Get_with_nanoseconds>
40007cc4: 92 12 62 28 or %o1, 0x228, %o1 ! 4001fe28 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40007cc8: 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);
40007ccc: 94 10 20 00 clr %o2
40007cd0: 90 10 00 1c mov %i4, %o0
40007cd4: 92 10 00 1d mov %i5, %o1
40007cd8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007cdc: 40 00 48 3d call 40019dd0 <__divdi3>
40007ce0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007ce4: 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);
40007ce8: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007cec: 94 10 20 00 clr %o2
40007cf0: 92 10 00 1d mov %i5, %o1
40007cf4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007cf8: 40 00 49 21 call 4001a17c <__moddi3>
40007cfc: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
40007d00: 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();
40007d04: 40 00 0c 36 call 4000addc <_Thread_Enable_dispatch>
40007d08: b0 10 20 00 clr %i0
40007d0c: 81 c7 e0 08 ret
40007d10: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
40007d14: 40 00 21 a4 call 400103a4 <__errno>
40007d18: b0 10 3f ff mov -1, %i0
40007d1c: 82 10 20 16 mov 0x16, %g1
40007d20: c2 22 00 00 st %g1, [ %o0 ]
}
40007d24: 81 c7 e0 08 ret
40007d28: 81 e8 00 00 restore
400079dc <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
400079dc: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
400079e0: 3b 10 00 66 sethi %hi(0x40019800), %i5
400079e4: ba 17 62 f8 or %i5, 0x2f8, %i5 ! 40019af8 <_POSIX_signals_Ualarm_timer>
400079e8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400079ec: 80 a0 60 00 cmp %g1, 0
400079f0: 12 80 00 0a bne 40007a18 <ualarm+0x3c>
400079f4: b8 10 00 18 mov %i0, %i4
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400079f8: 03 10 00 1e sethi %hi(0x40007800), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400079fc: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
40007a00: 82 10 61 b0 or %g1, 0x1b0, %g1
the_watchdog->id = id;
40007a04: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40007a08: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40007a0c: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
40007a10: 10 80 00 1b b 40007a7c <ualarm+0xa0>
40007a14: 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 );
40007a18: 40 00 0f 92 call 4000b860 <_Watchdog_Remove>
40007a1c: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
40007a20: 90 02 3f fe add %o0, -2, %o0
40007a24: 80 a2 20 01 cmp %o0, 1
40007a28: 18 80 00 15 bgu 40007a7c <ualarm+0xa0> <== NEVER TAKEN
40007a2c: 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);
40007a30: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40007a34: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
40007a38: 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);
40007a3c: 90 02 00 01 add %o0, %g1, %o0
40007a40: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
40007a44: 40 00 0e 4d call 4000b378 <_Timespec_From_ticks>
40007a48: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
40007a4c: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
40007a50: 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;
40007a54: 85 28 60 03 sll %g1, 3, %g2
40007a58: 87 28 60 08 sll %g1, 8, %g3
40007a5c: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
40007a60: 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;
40007a64: b1 28 a0 06 sll %g2, 6, %i0
40007a68: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
40007a6c: 40 00 34 d5 call 40014dc0 <.div>
40007a70: 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;
40007a74: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
40007a78: 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 ) {
40007a7c: 80 a7 20 00 cmp %i4, 0
40007a80: 02 80 00 19 be 40007ae4 <ualarm+0x108>
40007a84: 3b 00 03 d0 sethi %hi(0xf4000), %i5
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
40007a88: 90 10 00 1c mov %i4, %o0
40007a8c: 40 00 34 cb call 40014db8 <.udiv>
40007a90: 92 17 62 40 or %i5, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40007a94: 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;
40007a98: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40007a9c: 40 00 35 73 call 40015068 <.urem>
40007aa0: 90 10 00 1c mov %i4, %o0
40007aa4: 85 2a 20 07 sll %o0, 7, %g2
40007aa8: 83 2a 20 02 sll %o0, 2, %g1
40007aac: 82 20 80 01 sub %g2, %g1, %g1
40007ab0: 90 00 40 08 add %g1, %o0, %o0
40007ab4: 91 2a 20 03 sll %o0, 3, %o0
40007ab8: d0 27 bf fc st %o0, [ %fp + -4 ]
ticks = _Timespec_To_ticks( &tp );
40007abc: 40 00 0e 44 call 4000b3cc <_Timespec_To_ticks>
40007ac0: 90 07 bf f8 add %fp, -8, %o0
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
40007ac4: 40 00 0e 42 call 4000b3cc <_Timespec_To_ticks>
40007ac8: 90 07 bf f8 add %fp, -8, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40007acc: 13 10 00 66 sethi %hi(0x40019800), %o1
40007ad0: 92 12 62 f8 or %o1, 0x2f8, %o1 ! 40019af8 <_POSIX_signals_Ualarm_timer>
40007ad4: d0 22 60 0c st %o0, [ %o1 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40007ad8: 11 10 00 64 sethi %hi(0x40019000), %o0
40007adc: 40 00 0f 09 call 4000b700 <_Watchdog_Insert>
40007ae0: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 400192a8 <_Watchdog_Ticks_chain>
}
return remaining;
}
40007ae4: 81 c7 e0 08 ret
40007ae8: 81 e8 00 00 restore
400075a4 <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 )
{
400075a4: 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 =
400075a8: 94 10 20 18 mov 0x18, %o2
400075ac: 92 10 00 18 mov %i0, %o1
400075b0: 7f ff f7 01 call 400051b4 <rtems_filesystem_eval_path_start>
400075b4: 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;
400075b8: 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)(
400075bc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400075c0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400075c4: 9f c0 40 00 call %g1
400075c8: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
400075cc: 80 8a 20 ff btst 0xff, %o0
400075d0: 02 80 00 26 be 40007668 <unmount+0xc4>
400075d4: 03 10 00 5a sethi %hi(0x40016800), %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;
400075d8: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 400169c0 <rtems_current_user_env>
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
400075dc: c4 00 40 00 ld [ %g1 ], %g2
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
400075e0: c2 00 60 04 ld [ %g1 + 4 ], %g1
400075e4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400075e8: 80 a7 40 01 cmp %i5, %g1
400075ec: 22 80 00 06 be,a 40007604 <unmount+0x60>
400075f0: 82 10 20 01 mov 1, %g1
400075f4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400075f8: 82 1f 40 01 xor %i5, %g1, %g1
400075fc: 80 a0 00 01 cmp %g0, %g1
40007600: 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 ) ) {
40007604: 80 a0 60 00 cmp %g1, 0
40007608: 12 80 00 14 bne 40007658 <unmount+0xb4>
4000760c: 01 00 00 00 nop
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
40007610: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40007614: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
40007618: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000761c: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
40007620: 9f c0 40 00 call %g1
40007624: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40007628: b0 92 20 00 orcc %o0, 0, %i0
4000762c: 12 80 00 14 bne 4000767c <unmount+0xd8>
40007630: 01 00 00 00 nop
rtems_id self_task_id = rtems_task_self();
40007634: 40 00 03 f6 call 4000860c <rtems_task_self>
40007638: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
4000763c: 7f ff eb 56 call 40002394 <sparc_disable_interrupts>
40007640: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
40007644: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
40007648: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
4000764c: 7f ff eb 56 call 400023a4 <sparc_enable_interrupts>
40007650: 01 00 00 00 nop
40007654: 30 80 00 0a b,a 4000767c <unmount+0xd8>
}
} else {
errno = EBUSY;
40007658: 40 00 21 42 call 4000fb60 <__errno>
4000765c: 01 00 00 00 nop
40007660: 10 80 00 05 b 40007674 <unmount+0xd0>
40007664: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10>
rv = -1;
}
} else {
errno = EACCES;
40007668: 40 00 21 3e call 4000fb60 <__errno>
4000766c: 01 00 00 00 nop
40007670: 82 10 20 0d mov 0xd, %g1 ! d <PROM_START+0xd>
40007674: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
40007678: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000767c: 7f ff f7 0a call 400052a4 <rtems_filesystem_eval_path_cleanup>
40007680: 90 07 bf c8 add %fp, -56, %o0
if ( rv == 0 ) {
40007684: 80 a6 20 00 cmp %i0, 0
40007688: 12 80 00 0b bne 400076b4 <unmount+0x110>
4000768c: 11 20 00 00 sethi %hi(0x80000000), %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40007690: 92 10 20 00 clr %o1
40007694: 94 10 20 00 clr %o2
40007698: 40 00 03 19 call 400082fc <rtems_event_system_receive>
4000769c: 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 ) {
400076a0: 80 a2 20 00 cmp %o0, 0
400076a4: 02 80 00 04 be 400076b4 <unmount+0x110> <== ALWAYS TAKEN
400076a8: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
400076ac: 40 00 04 77 call 40008888 <rtems_fatal_error_occurred> <== NOT EXECUTED
400076b0: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
}
}
return rv;
}
400076b4: 81 c7 e0 08 ret
400076b8: 81 e8 00 00 restore
4001bd10 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
4001bd10: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001bd14: 03 10 00 79 sethi %hi(0x4001e400), %g1
4001bd18: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 4001e774 <rtems_libio_number_iops>
4001bd1c: 80 a6 00 01 cmp %i0, %g1
4001bd20: 1a 80 00 16 bcc 4001bd78 <write+0x68>
4001bd24: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
4001bd28: b1 2e 20 06 sll %i0, 6, %i0
4001bd2c: b0 26 00 01 sub %i0, %g1, %i0
4001bd30: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001bd34: d0 00 62 f4 ld [ %g1 + 0x2f4 ], %o0 ! 4001f2f4 <rtems_libio_iops>
4001bd38: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001bd3c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001bd40: 80 88 61 00 btst 0x100, %g1
4001bd44: 02 80 00 0d be 4001bd78 <write+0x68>
4001bd48: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001bd4c: 12 80 00 06 bne 4001bd64 <write+0x54> <== ALWAYS TAKEN
4001bd50: 80 a6 a0 00 cmp %i2, 0
4001bd54: 7f ff cf 64 call 4000fae4 <__errno> <== NOT EXECUTED
4001bd58: 01 00 00 00 nop <== NOT EXECUTED
4001bd5c: 10 80 00 0a b 4001bd84 <write+0x74> <== NOT EXECUTED
4001bd60: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
4001bd64: 02 80 00 10 be 4001bda4 <write+0x94>
4001bd68: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001bd6c: 80 88 60 04 btst 4, %g1
4001bd70: 32 80 00 08 bne,a 4001bd90 <write+0x80>
4001bd74: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001bd78: 7f ff cf 5b call 4000fae4 <__errno>
4001bd7c: 01 00 00 00 nop
4001bd80: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4001bd84: c2 22 00 00 st %g1, [ %o0 ]
4001bd88: 81 c7 e0 08 ret
4001bd8c: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
4001bd90: 92 10 00 19 mov %i1, %o1
4001bd94: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4001bd98: 9f c0 40 00 call %g1
4001bd9c: 94 10 00 1a mov %i2, %o2
4001bda0: b0 10 00 08 mov %o0, %i0
}
4001bda4: 81 c7 e0 08 ret
4001bda8: 81 e8 00 00 restore
400084a8 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
400084a8: 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 );
400084ac: 03 10 00 5f sethi %hi(0x40017c00), %g1
400084b0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 ! 40017c14 <rtems_libio_number_iops>
400084b4: 80 a6 00 01 cmp %i0, %g1
400084b8: 2a 80 00 03 bcs,a 400084c4 <writev+0x1c>
400084bc: 83 2e 20 03 sll %i0, 3, %g1
400084c0: 30 80 00 0c b,a 400084f0 <writev+0x48>
iop = rtems_libio_iop( fd );
400084c4: b1 2e 20 06 sll %i0, 6, %i0
400084c8: b0 26 00 01 sub %i0, %g1, %i0
400084cc: 03 10 00 61 sethi %hi(0x40018400), %g1
400084d0: f8 00 63 70 ld [ %g1 + 0x370 ], %i4 ! 40018770 <rtems_libio_iops>
400084d4: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
400084d8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
400084dc: 80 88 61 00 btst 0x100, %g1
400084e0: 02 80 00 04 be 400084f0 <writev+0x48>
400084e4: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
400084e8: 12 80 00 06 bne 40008500 <writev+0x58> <== ALWAYS TAKEN
400084ec: 80 a6 60 00 cmp %i1, 0
400084f0: 40 00 1f cc call 40010420 <__errno>
400084f4: 01 00 00 00 nop
400084f8: 10 80 00 20 b 40008578 <writev+0xd0>
400084fc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
40008500: 02 80 00 1b be 4000856c <writev+0xc4>
40008504: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
40008508: 04 80 00 19 ble 4000856c <writev+0xc4>
4000850c: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
40008510: 24 80 00 03 ble,a 4000851c <writev+0x74> <== ALWAYS TAKEN
40008514: b5 2e a0 03 sll %i2, 3, %i2
40008518: 30 80 00 15 b,a 4000856c <writev+0xc4> <== NOT EXECUTED
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
4000851c: 82 10 20 00 clr %g1
40008520: 86 10 20 01 mov 1, %g3
40008524: 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 )
40008528: c8 06 40 01 ld [ %i1 + %g1 ], %g4
4000852c: 80 a1 20 00 cmp %g4, 0
40008530: 02 80 00 0f be 4000856c <writev+0xc4>
40008534: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
40008538: c8 01 20 04 ld [ %g4 + 4 ], %g4
all_zeros = false;
4000853c: 80 a0 00 04 cmp %g0, %g4
40008540: ba 40 3f ff addx %g0, -1, %i5
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
40008544: 88 81 00 02 addcc %g4, %g2, %g4
40008548: 0c 80 00 09 bneg 4000856c <writev+0xc4>
4000854c: 86 08 c0 1d and %g3, %i5, %g3
40008550: 80 a1 00 02 cmp %g4, %g2
40008554: 06 80 00 03 bl 40008560 <writev+0xb8>
40008558: ba 10 20 01 mov 1, %i5
4000855c: ba 10 20 00 clr %i5
40008560: 80 8f 60 ff btst 0xff, %i5
40008564: 02 80 00 07 be 40008580 <writev+0xd8>
40008568: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
4000856c: 40 00 1f ad call 40010420 <__errno>
40008570: 01 00 00 00 nop
40008574: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
40008578: 10 80 00 21 b 400085fc <writev+0x154>
4000857c: 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++ ) {
40008580: 80 a0 40 1a cmp %g1, %i2
40008584: 12 bf ff e9 bne 40008528 <writev+0x80>
40008588: 84 10 00 04 mov %g4, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
4000858c: 80 88 e0 ff btst 0xff, %g3
40008590: 12 80 00 19 bne 400085f4 <writev+0x14c>
40008594: b0 10 20 00 clr %i0
40008598: ba 10 20 00 clr %i5
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
4000859c: 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 )
400085a0: d4 06 e0 04 ld [ %i3 + 4 ], %o2
400085a4: 80 a2 a0 00 cmp %o2, 0
400085a8: 22 80 00 10 be,a 400085e8 <writev+0x140> <== NEVER TAKEN
400085ac: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
400085b0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
400085b4: d2 06 40 1d ld [ %i1 + %i5 ], %o1
400085b8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400085bc: 9f c0 40 00 call %g1
400085c0: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
400085c4: 80 a2 20 00 cmp %o0, 0
400085c8: 26 80 00 0b bl,a 400085f4 <writev+0x14c> <== NEVER TAKEN
400085cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
400085d0: 32 80 00 02 bne,a 400085d8 <writev+0x130> <== ALWAYS TAKEN
400085d4: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
400085d8: c2 06 e0 04 ld [ %i3 + 4 ], %g1
400085dc: 80 a2 00 01 cmp %o0, %g1
400085e0: 12 80 00 05 bne 400085f4 <writev+0x14c> <== NEVER TAKEN
400085e4: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
400085e8: 80 a7 40 1a cmp %i5, %i2
400085ec: 12 bf ff ed bne 400085a0 <writev+0xf8>
400085f0: b6 06 40 1d add %i1, %i5, %i3
400085f4: 81 c7 e0 08 ret
400085f8: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
400085fc: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
40008600: 81 c7 e0 08 ret
40008604: 81 e8 00 00 restore