RTEMS-5
Annotated Report
Fri Aug 10 13:13:33 2018
40017b94 <IMFS_LIMITS_AND_OPTIONS>:
40017b94: 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 ff ................
40017ba4: 00 00 00 ff 00 00 00 02 00 00 00 01 00 00 00 02 ................
40017bb4: 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 ................
40017bc4: 00 00 00 00 4e 4f 4e 42 4c 4f 43 4b 00 00 00 00 ....NONBLOCK....
40017bd4: 00 00 00 00 41 50 50 45 4e 44 00 00 52 45 41 44 ....APPEND..READ
40017be4: 00 00 00 00 57 52 49 54 45 00 00 00 52 45 41 44 ....WRITE...READ
40017bf4: 2f 57 52 49 54 45 00 00 /WRITE..
40010378 <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
)
{
40010378: 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;
4001037c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40010380: c4 00 60 08 ld [ %g1 + 8 ], %g2
40010384: f6 00 40 00 ld [ %g1 ], %i3
40010388: f8 00 60 04 ld [ %g1 + 4 ], %i4
4001038c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
40010390: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
40010394: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
jnode = (IMFS_jnode_t *)loc.node_access;
40010398: ba 10 00 02 mov %g2, %i5
loc = temp_mt_entry->mt_fs_root->location;
4001039c: c4 27 bf f0 st %g2, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
400103a0: 35 00 00 3c sethi %hi(0xf000), %i2
400103a4: c2 27 bf fc st %g1, [ %fp + -4 ]
400103a8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
loc->handlers = node->control->handlers;
400103ac: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
400103b0: c4 00 80 00 ld [ %g2 ], %g2
400103b4: c6 27 bf f8 st %g3, [ %fp + -8 ]
return S_ISDIR( node->st_mode );
400103b8: 82 08 40 1a and %g1, %i2, %g1
400103bc: f6 27 bf e8 st %i3, [ %fp + -24 ]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
400103c0: 37 00 00 10 sethi %hi(0x4000), %i3
loc = temp_mt_entry->mt_fs_root->location;
400103c4: f8 27 bf ec st %i4, [ %fp + -20 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
400103c8: 80 a0 40 1b cmp %g1, %i3
next = jnode->Parent;
400103cc: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc = temp_mt_entry->mt_fs_root->location;
400103d0: c8 27 bf f4 st %g4, [ %fp + -12 ]
loc.node_access = (void *)jnode;
400103d4: fa 27 bf f0 st %i5, [ %fp + -16 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
400103d8: 12 80 00 14 bne 40010428 <IMFS_fsunmount+0xb0>
<== NEVER TAKEN
400103dc: c4 27 bf f8 st %g2, [ %fp + -8 ]
return _Chain_Immutable_head( the_chain )->next;
400103e0: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
return &the_chain->Tail.Node;
400103e4: 82 07 60 44 add %i5, 0x44, %g1
400103e8: 80 a0 80 01 cmp %g2, %g1
400103ec: 02 80 00 10 be 4001042c <IMFS_fsunmount+0xb4>
400103f0: 92 07 bf e8 add %fp, -24, %o1
if ( IMFS_is_directory( jnode ) ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
400103f4: 80 a0 a0 00 cmp %g2, 0
400103f8: 02 80 00 23 be 40010484 <IMFS_fsunmount+0x10c>
<== NEVER TAKEN
400103fc: b8 10 00 02 mov %g2, %i4
40010400: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40010404: ba 10 00 1c mov %i4, %i5
loc->handlers = node->control->handlers;
40010408: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
4001040c: c4 00 80 00 ld [ %g2 ], %g2
next = jnode->Parent;
40010410: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
40010414: fa 27 bf f0 st %i5, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
40010418: 82 08 40 1a and %g1, %i2, %g1
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4001041c: 80 a0 40 1b cmp %g1, %i3
40010420: 02 bf ff f0 be 400103e0 <IMFS_fsunmount+0x68>
40010424: c4 27 bf f8 st %g2, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
40010428: 92 07 bf e8 add %fp, -24, %o1
4001042c: 7f ff d8 c3 call 40006738 <IMFS_rmnod>
40010430: 90 10 20 00 clr %o0
if ( result != 0 )
40010434: 80 a2 20 00 cmp %o0, 0
40010438: 12 80 00 15 bne 4001048c <IMFS_fsunmount+0x114>
<== NEVER TAKEN
4001043c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
IMFS_node_destroy( jnode );
40010440: 7f ff d8 5b call 400065ac <IMFS_node_destroy>
40010444: 90 10 00 1d mov %i5, %o0
if ( jnode != NULL ) {
40010448: 80 a7 20 00 cmp %i4, 0
4001044c: 02 80 00 0e be 40010484 <IMFS_fsunmount+0x10c>
40010450: 01 00 00 00 nop
40010454: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40010458: 84 08 40 1a and %g1, %i2, %g2
if ( IMFS_is_directory( jnode ) ) {
4001045c: 80 a0 80 1b cmp %g2, %i3
40010460: 32 bf ff ea bne,a 40010408 <IMFS_fsunmount+0x90>
<== NEVER TAKEN
40010464: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
40010468: c4 07 20 40 ld [ %i4 + 0x40 ], %g2
if ( jnode_has_children( jnode ) )
4001046c: 86 07 20 44 add %i4, 0x44, %g3
40010470: 80 a0 80 03 cmp %g2, %g3
40010474: 12 bf ff e1 bne 400103f8 <IMFS_fsunmount+0x80>
40010478: 80 a0 a0 00 cmp %g2, 0
} while (jnode != NULL);
4001047c: 10 bf ff e3 b 40010408 <IMFS_fsunmount+0x90>
40010480: ba 10 00 1c mov %i4, %i5
}
40010484: 81 c7 e0 08 ret
40010488: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xdeadbeef );
4001048c: 7f ff e6 17 call 40009ce8 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40010490: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
40010494: 01 00 00 00 nop
<== NOT EXECUTED
40003480 <IMFS_initialize_support>:
{
40003480: 9d e3 bf a0 save %sp, -96, %sp
IMFS_fs_info_t *fs_info = mount_data->fs_info;
40003484: fa 06 40 00 ld [ %i1 ], %i5
fs_info->mknod_controls = mount_data->mknod_controls;
40003488: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000348c: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
root_node = IMFS_initialize_node(
40003490: 9a 10 20 00 clr %o5
40003494: d2 00 40 00 ld [ %g1 ], %o1
40003498: 96 10 20 00 clr %o3
4000349c: 19 00 00 10 sethi %hi(0x4000), %o4
400034a0: 90 10 00 1d mov %i5, %o0
400034a4: 98 13 21 ed or %o4, 0x1ed, %o4
400034a8: 15 10 00 5b sethi %hi(0x40016c00), %o2
400034ac: 40 00 03 76 call 40004284 <IMFS_initialize_node>
400034b0: 94 12 a3 a0 or %o2, 0x3a0, %o2 ! 40016fa0 <_rodata_start+0x190>
mt_entry->ops = mount_data->ops;
400034b4: c2 06 60 04 ld [ %i1 + 4 ], %g1
loc->handlers = node->control->handlers;
400034b8: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
400034bc: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
400034c0: 03 10 00 5e sethi %hi(0x40017800), %g1
400034c4: 82 10 63 94 or %g1, 0x394, %g1 ! 40017b94 <IMFS_LIMITS_AND_OPTIONS>
mt_entry->fs_info = fs_info;
400034c8: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
400034cc: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
400034d0: c4 00 80 00 ld [ %g2 ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
400034d4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400034d8: d0 20 60 08 st %o0, [ %g1 + 8 ]
400034dc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
IMFS_determine_bytes_per_block(
400034e0: 03 10 00 65 sethi %hi(0x40019400), %g1
400034e4: c6 00 60 88 ld [ %g1 + 0x88 ], %g3 ! 40019488 <imfs_rq_memfile_bytes_per_block>
if (bit_mask == requested_bytes_per_block) {
400034e8: 80 a0 e0 10 cmp %g3, 0x10
400034ec: 02 80 00 0e be 40003524 <IMFS_initialize_support+0xa4>
400034f0: 80 a0 e0 0f cmp %g3, 0xf
if(bit_mask > requested_bytes_per_block)
400034f4: 04 80 00 0b ble 40003520 <IMFS_initialize_support+0xa0>
<== NEVER TAKEN
400034f8: 82 10 20 20 mov 0x20, %g1
400034fc: 84 10 20 05 mov 5, %g2
if (bit_mask == requested_bytes_per_block) {
40003500: 80 a0 c0 01 cmp %g3, %g1
40003504: 22 80 00 09 be,a 40003528 <IMFS_initialize_support+0xa8>
40003508: 03 10 00 6b sethi %hi(0x4001ac00), %g1
if(bit_mask > requested_bytes_per_block)
4000350c: 26 80 00 06 bl,a 40003524 <IMFS_initialize_support+0xa4>
<== NEVER TAKEN
40003510: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
40003514: 84 80 bf ff addcc %g2, -1, %g2
40003518: 12 bf ff fa bne 40003500 <IMFS_initialize_support+0x80>
<== ALWAYS TAKEN
4000351c: 83 28 60 01 sll %g1, 1, %g1
: default_bytes_per_block);
40003520: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
*dest_bytes_per_block = ((is_valid)
40003524: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40003528: c6 20 61 1c st %g3, [ %g1 + 0x11c ] ! 4001ad1c <imfs_memfile_bytes_per_block>
}
4000352c: 81 c7 e0 08 ret
40003530: 91 e8 20 00 restore %g0, 0, %o0
4000da40 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
4000da40: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000da44: 7f ff de a0 call 400054c4 <rtems_current_user_env_get>
4000da48: 01 00 00 00 nop
4000da4c: da 02 20 08 ld [ %o0 + 8 ], %o5
4000da50: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
4000da54: 03 00 00 3c sethi %hi(0xf000), %g1
4000da58: 05 00 00 18 sethi %hi(0x6000), %g2
4000da5c: 82 0e 40 01 and %i1, %g1, %g1
4000da60: 80 a0 40 02 cmp %g1, %g2
4000da64: 02 80 00 0c be 4000da94 <IMFS_make_generic_node+0x54>
<== NEVER TAKEN
4000da68: 94 10 20 78 mov 0x78, %o2
4000da6c: 08 80 00 1d bleu 4000dae0 <IMFS_make_generic_node+0xa0>
<== ALWAYS TAKEN
4000da70: 05 00 00 04 sethi %hi(0x1000), %g2
4000da74: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4000da78: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000da7c: 02 80 00 06 be 4000da94 <IMFS_make_generic_node+0x54>
<== NOT EXECUTED
4000da80: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
4000da84: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000da88: 12 80 00 1c bne 4000daf8 <IMFS_make_generic_node+0xb8>
<== NOT EXECUTED
4000da8c: 01 00 00 00 nop
<== NOT EXECUTED
if ( rv == 0 ) {
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 =
4000da90: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
4000da94: 92 10 00 18 mov %i0, %o1
4000da98: 7f ff e0 39 call 40005b7c <rtems_filesystem_eval_path_start>
4000da9c: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
4000daa0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000daa4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
4000daa8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000daac: 03 10 00 10 sethi %hi(0x40004000), %g1
4000dab0: 82 10 63 08 or %g1, 0x308, %g1 ! 40004308 <IMFS_node_clone>
4000dab4: 80 a0 80 01 cmp %g2, %g1
4000dab8: 02 80 00 16 be 4000db10 <IMFS_make_generic_node+0xd0>
<== ALWAYS TAKEN
4000dabc: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
4000dac0: 92 10 20 86 mov 0x86, %o1
<== NOT EXECUTED
4000dac4: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
4000dac8: 7f ff df 72 call 40005890 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000dacc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000dad0: 7f ff e0 37 call 40005bac <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000dad4: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
}
return rv;
}
4000dad8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dadc: 81 e8 00 00 restore
<== NOT EXECUTED
switch (mode & S_IFMT) {
4000dae0: 80 a0 40 02 cmp %g1, %g2
4000dae4: 02 bf ff eb be 4000da90 <IMFS_make_generic_node+0x50>
<== NEVER TAKEN
4000dae8: 05 00 00 08 sethi %hi(0x2000), %g2
4000daec: 80 a0 40 02 cmp %g1, %g2
4000daf0: 02 bf ff e9 be 4000da94 <IMFS_make_generic_node+0x54>
<== ALWAYS TAKEN
4000daf4: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
4000daf8: 40 00 05 1c call 4000ef68 <__errno>
<== NOT EXECUTED
4000dafc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000db00: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000db04: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000db08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db0c: 81 e8 00 00 restore
<== NOT EXECUTED
IMFS_jnode_t *new_node = IMFS_create_node(
4000db10: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000db14: 9a 10 00 19 mov %i1, %o5
4000db18: d8 07 bf d4 ld [ %fp + -44 ], %o4
4000db1c: d6 07 bf d0 ld [ %fp + -48 ], %o3
4000db20: 94 10 20 48 mov 0x48, %o2
4000db24: 92 10 00 1a mov %i2, %o1
4000db28: 7f ff ff a0 call 4000d9a8 <IMFS_create_node>
4000db2c: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
4000db30: 80 a2 20 00 cmp %o0, 0
4000db34: 02 bf ff e7 be 4000dad0 <IMFS_make_generic_node+0x90>
<== NEVER TAKEN
4000db38: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
4000db3c: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
4000db40: 7f ff ec 08 call 40008b60 <_Timecounter_Getbintime>
4000db44: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
4000db48: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
4000db4c: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
4000db50: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
4000db54: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
4000db58: 7f ff e0 15 call 40005bac <rtems_filesystem_eval_path_cleanup>
4000db5c: 90 07 bf c8 add %fp, -56, %o0
}
4000db60: 81 c7 e0 08 ret
4000db64: 81 e8 00 00 restore
40003f04 <IMFS_memfile_write>:
{
40003f04: 9d e3 bf 90 save %sp, -112, %sp
if ( last_byte > memfile->File.size ) {
40003f08: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
last_byte = start + my_length;
40003f0c: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > memfile->File.size ) {
40003f10: 80 a0 40 0b cmp %g1, %o3
40003f14: 0a 80 00 54 bcs 40004064 <IMFS_memfile_write+0x160>
<== ALWAYS TAKEN
40003f18: a0 10 00 18 mov %i0, %l0
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f1c: 23 10 00 6b sethi %hi(0x4001ac00), %l1
<== NOT EXECUTED
40003f20: e4 04 61 1c ld [ %l1 + 0x11c ], %l2 ! 4001ad1c <imfs_memfile_bytes_per_block>
40003f24: bb 3c a0 1f sra %l2, 0x1f, %i5
40003f28: 96 10 00 12 mov %l2, %o3
40003f2c: 94 10 00 1d mov %i5, %o2
40003f30: 92 10 00 1a mov %i2, %o1
40003f34: 40 00 48 b7 call 40016210 <__moddi3>
40003f38: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f3c: 94 10 00 1d mov %i5, %o2
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f40: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f44: 96 10 00 12 mov %l2, %o3
40003f48: 92 10 00 1a mov %i2, %o1
40003f4c: 40 00 48 26 call 40015fe4 <__divdi3>
40003f50: 90 10 00 19 mov %i1, %o0
40003f54: ba 10 00 12 mov %l2, %i5
40003f58: b4 10 00 09 mov %o1, %i2
if ( start_offset ) {
40003f5c: 80 a4 e0 00 cmp %l3, 0
40003f60: 12 80 00 1a bne 40003fc8 <IMFS_memfile_write+0xc4>
40003f64: b0 10 20 00 clr %i0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003f68: 80 a7 00 1d cmp %i4, %i5
40003f6c: 1a 80 00 0e bcc 40003fa4 <IMFS_memfile_write+0xa0>
40003f70: 92 10 00 1a mov %i2, %o1
if ( my_length ) {
40003f74: 10 80 00 29 b 40004018 <IMFS_memfile_write+0x114>
40003f78: 80 a7 20 00 cmp %i4, 0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40003f7c: 40 00 2c 29 call 4000f020 <memcpy>
40003f80: d0 02 00 00 ld [ %o0 ], %o0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003f84: c2 04 61 1c ld [ %l1 + 0x11c ], %g1
my_length -= to_copy;
40003f88: b8 27 00 1d sub %i4, %i5, %i4
src += to_copy;
40003f8c: b6 06 c0 1d add %i3, %i5, %i3
block++;
40003f90: b4 06 a0 01 inc %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003f94: 80 a0 40 1c cmp %g1, %i4
40003f98: 18 80 00 1f bgu 40004014 <IMFS_memfile_write+0x110>
40003f9c: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003fa0: 92 10 00 1a mov %i2, %o1
40003fa4: 94 10 20 00 clr %o2
40003fa8: 7f ff fd d4 call 400036f8 <IMFS_memfile_get_block_pointer>
40003fac: 90 10 00 10 mov %l0, %o0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40003fb0: 92 10 00 1b mov %i3, %o1
if ( !block_ptr )
40003fb4: 80 a2 20 00 cmp %o0, 0
40003fb8: 12 bf ff f1 bne 40003f7c <IMFS_memfile_write+0x78>
<== ALWAYS TAKEN
40003fbc: 94 10 00 1d mov %i5, %o2
}
40003fc0: 81 c7 e0 08 ret
<== NOT EXECUTED
40003fc4: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003fc8: 94 10 20 00 clr %o2
40003fcc: 7f ff fd cb call 400036f8 <IMFS_memfile_get_block_pointer>
40003fd0: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
40003fd4: 80 a2 20 00 cmp %o0, 0
40003fd8: 02 bf ff fa be 40003fc0 <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
40003fdc: a4 24 80 13 sub %l2, %l3, %l2
40003fe0: 80 a7 00 12 cmp %i4, %l2
40003fe4: 18 80 00 37 bgu 400040c0 <IMFS_memfile_write+0x1bc>
40003fe8: b0 10 00 1c mov %i4, %i0
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40003fec: d0 02 00 00 ld [ %o0 ], %o0
40003ff0: 92 10 00 1b mov %i3, %o1
40003ff4: 94 10 00 18 mov %i0, %o2
40003ff8: 90 02 00 13 add %o0, %l3, %o0
40003ffc: 40 00 2c 09 call 4000f020 <memcpy>
40004000: b6 06 c0 18 add %i3, %i0, %i3
block++;
40004004: b4 06 a0 01 inc %i2
40004008: fa 04 61 1c ld [ %l1 + 0x11c ], %i5
my_length -= to_copy;
4000400c: 10 bf ff d7 b 40003f68 <IMFS_memfile_write+0x64>
40004010: b8 27 00 18 sub %i4, %i0, %i4
if ( my_length ) {
40004014: 80 a7 20 00 cmp %i4, 0
40004018: 02 80 00 0c be 40004048 <IMFS_memfile_write+0x144>
4000401c: 94 10 20 00 clr %o2
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40004020: 92 10 00 1a mov %i2, %o1
40004024: 7f ff fd b5 call 400036f8 <IMFS_memfile_get_block_pointer>
40004028: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
4000402c: 80 a2 20 00 cmp %o0, 0
40004030: 02 bf ff e4 be 40003fc0 <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
40004034: 94 10 00 1c mov %i4, %o2
memcpy( &(*block_ptr)[ 0 ], src, my_length );
40004038: d0 02 00 00 ld [ %o0 ], %o0
4000403c: 92 10 00 1b mov %i3, %o1
40004040: 40 00 2b f8 call 4000f020 <memcpy>
40004044: b0 06 00 1c add %i0, %i4, %i0
_Timecounter_Getbintime( &now );
40004048: 40 00 12 c6 call 40008b60 <_Timecounter_Getbintime>
4000404c: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
40004050: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40004054: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
jnode->stat_ctime = now;
40004058: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
}
4000405c: 81 c7 e0 08 ret
40004060: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
40004064: 80 a6 60 00 cmp %i1, 0
40004068: 04 80 00 0b ble 40004094 <IMFS_memfile_write+0x190>
<== ALWAYS TAKEN
4000406c: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40004070: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004074: 92 0a 60 01 and %o1, 1, %o1
40004078: 7f ff fe 49 call 4000399c <IMFS_memfile_extend>
4000407c: 90 10 00 10 mov %l0, %o0
if ( status )
40004080: b0 92 20 00 orcc %o0, 0, %i0
40004084: 02 bf ff a7 be 40003f20 <IMFS_memfile_write+0x1c>
40004088: 23 10 00 6b sethi %hi(0x4001ac00), %l1
4000408c: 81 c7 e0 08 ret
40004090: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
40004094: 02 80 00 16 be 400040ec <IMFS_memfile_write+0x1e8>
<== ALWAYS TAKEN
40004098: 80 a6 80 01 cmp %i2, %g1
4000409c: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
400040a0: 94 10 20 00 clr %o2
<== NOT EXECUTED
400040a4: 92 0a 60 01 and %o1, 1, %o1
400040a8: 7f ff fe 3d call 4000399c <IMFS_memfile_extend>
400040ac: 90 10 00 10 mov %l0, %o0
if ( status )
400040b0: b0 92 20 00 orcc %o0, 0, %i0
400040b4: 02 bf ff 9b be 40003f20 <IMFS_memfile_write+0x1c>
400040b8: 23 10 00 6b sethi %hi(0x4001ac00), %l1
400040bc: 30 bf ff f4 b,a 4000408c <IMFS_memfile_write+0x188>
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400040c0: d0 02 00 00 ld [ %o0 ], %o0
400040c4: b0 10 00 12 mov %l2, %i0
400040c8: 92 10 00 1b mov %i3, %o1
400040cc: 94 10 00 18 mov %i0, %o2
400040d0: 90 02 00 13 add %o0, %l3, %o0
400040d4: 40 00 2b d3 call 4000f020 <memcpy>
400040d8: b6 06 c0 18 add %i3, %i0, %i3
block++;
400040dc: b4 06 a0 01 inc %i2
400040e0: fa 04 61 1c ld [ %l1 + 0x11c ], %i5
my_length -= to_copy;
400040e4: 10 bf ff a1 b 40003f68 <IMFS_memfile_write+0x64>
400040e8: b8 27 00 18 sub %i4, %i0, %i4
bool zero_fill = start > memfile->File.size;
400040ec: 18 bf ff e2 bgu 40004074 <IMFS_memfile_write+0x170>
400040f0: 94 10 20 00 clr %o2
400040f4: 10 bf ff ec b 400040a4 <IMFS_memfile_write+0x1a0>
400040f8: 92 10 20 00 clr %o1
40017680 <IMFS_mknod_control_device>:
40017680: 40 01 76 94 40 00 34 30 40 00 43 78 40 00 43 80 @.v.@.40@.Cx@.C.
40017690: 00 00 00 48 ...H
40017624 <IMFS_mknod_control_dir_default>:
40017624: 40 01 76 38 40 00 31 7c 40 00 31 94 40 00 43 80 @.v8@.1|@.1.@.C.
40017634: 00 00 00 50 ...P
400176d4 <IMFS_mknod_control_enosys>:
400176d4: 40 01 7b 54 40 00 34 64 40 00 43 78 40 00 43 80 @.{T@.4d@.Cx@.C.
400176e4: 00 00 00 40 ...@
40019228 <IMFS_mknod_control_fifo>:
40019228: 40 01 92 3c 40 00 39 24 40 00 47 68 40 00 47 70 @..<@.9$@.Gh@.Gp
40019238: 00 00 00 48 ...H
40017738 <IMFS_mknod_control_memfile>:
40017738: 40 01 77 4c 40 00 35 34 40 00 43 78 40 00 3d a0 @.wL@.54@.Cx@.=.
40017748: 00 00 00 58 ...X
40004210 <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40004210: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004214: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40004218: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
4000421c: 07 00 00 3c sethi %hi(0xf000), %g3
40004220: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40004224: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
40004228: 07 00 00 10 sethi %hi(0x4000), %g3
4000422c: 80 a0 40 03 cmp %g1, %g3
40004230: 12 80 00 0f bne 4000426c <IMFS_mount+0x5c>
40004234: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
40004238: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
4000423c: 80 a0 60 00 cmp %g1, 0
40004240: 12 80 00 05 bne 40004254 <IMFS_mount+0x44>
<== NEVER TAKEN
40004244: 01 00 00 00 nop
dir->mt_fs = mt_entry;
40004248: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
4000424c: 81 c7 e0 08 ret
40004250: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EBUSY;
40004254: 40 00 2b 45 call 4000ef68 <__errno>
<== NOT EXECUTED
40004258: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000425c: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40004260: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004264: 81 c7 e0 08 ret
<== NOT EXECUTED
40004268: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
4000426c: 40 00 2b 3f call 4000ef68 <__errno>
40004270: b0 10 3f ff mov -1, %i0
40004274: 82 10 20 14 mov 0x14, %g1
40004278: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
4000427c: 81 c7 e0 08 ret
40004280: 81 e8 00 00 restore
40003194 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40003194: 9d e3 bf a0 save %sp, -96, %sp
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
40003198: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
return &the_chain->Tail.Node;
4000319c: 82 06 20 44 add %i0, 0x44, %g1
400031a0: 80 a0 80 01 cmp %g2, %g1
400031a4: 12 80 00 0c bne 400031d4 <IMFS_node_remove_directory+0x40>
400031a8: 01 00 00 00 nop
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
400031ac: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
400031b0: 80 a0 60 00 cmp %g1, 0
400031b4: 02 80 00 0c be 400031e4 <IMFS_node_remove_directory+0x50>
<== ALWAYS TAKEN
400031b8: 01 00 00 00 nop
errno = EBUSY;
400031bc: 40 00 2f 6b call 4000ef68 <__errno>
<== NOT EXECUTED
400031c0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
400031c4: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400031c8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
400031cc: 81 c7 e0 08 ret
<== NOT EXECUTED
400031d0: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
400031d4: 40 00 2f 65 call 4000ef68 <__errno>
400031d8: b0 10 20 00 clr %i0
400031dc: 82 10 20 5a mov 0x5a, %g1
400031e0: c2 22 00 00 st %g1, [ %o0 ]
400031e4: 81 c7 e0 08 ret
400031e8: 81 e8 00 00 restore
40004648 <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004648: 80 a2 a0 00 cmp %o2, 0
4000464c: 02 80 00 16 be 400046a4 <IMFS_readlink+0x5c>
<== NEVER TAKEN
40004650: c6 02 20 08 ld [ %o0 + 8 ], %g3
40004654: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
40004658: c4 48 40 00 ldsb [ %g1 ], %g2
4000465c: 90 10 20 00 clr %o0
40004660: 80 a0 a0 00 cmp %g2, 0
40004664: 12 80 00 07 bne 40004680 <IMFS_readlink+0x38>
<== ALWAYS TAKEN
40004668: c2 08 40 00 ldub [ %g1 ], %g1
4000466c: 30 80 00 0c b,a 4000469c <IMFS_readlink+0x54>
<== NOT EXECUTED
40004670: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
40004674: 80 a0 a0 00 cmp %g2, 0
40004678: 02 80 00 07 be 40004694 <IMFS_readlink+0x4c>
4000467c: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = sym_link->name[i];
40004680: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004684: 90 02 20 01 inc %o0
40004688: 80 a2 80 08 cmp %o2, %o0
4000468c: 32 bf ff f9 bne,a 40004670 <IMFS_readlink+0x28>
40004690: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
}
40004694: 81 c3 e0 08 retl
40004698: 01 00 00 00 nop
4000469c: 81 c3 e0 08 retl
<== NOT EXECUTED
400046a0: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
400046a4: 81 c3 e0 08 retl
<== NOT EXECUTED
400046a8: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
400043ac <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400043ac: 9d e3 bf 90 save %sp, -112, %sp
IMFS_jnode_t *node = oldloc->node_access;
400043b0: 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 ) {
400043b4: c2 07 60 08 ld [ %i5 + 8 ], %g1
400043b8: 80 a0 60 00 cmp %g1, 0
400043bc: 02 80 00 36 be 40004494 <IMFS_rename+0xe8>
<== NEVER TAKEN
400043c0: f4 06 a0 08 ld [ %i2 + 8 ], %i2
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
400043c4: 80 a7 20 fe cmp %i4, 0xfe
400043c8: 18 80 00 27 bgu 40004464 <IMFS_rename+0xb8>
<== NEVER TAKEN
400043cc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
allocated_name = malloc( namelen );
400043d0: 40 00 02 3e call 40004cc8 <malloc>
400043d4: 90 10 00 1c mov %i4, %o0
if ( allocated_name == NULL ) {
400043d8: b2 92 20 00 orcc %o0, 0, %i1
400043dc: 02 80 00 28 be 4000447c <IMFS_rename+0xd0>
<== NEVER TAKEN
400043e0: 94 10 00 1c mov %i4, %o2
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( allocated_name, name, namelen );
400043e4: 40 00 2b 0f call 4000f020 <memcpy>
400043e8: 92 10 00 1b mov %i3, %o1
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
400043ec: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
400043f0: 80 88 60 01 btst 1, %g1
400043f4: 12 80 00 18 bne 40004454 <IMFS_rename+0xa8>
400043f8: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400043fc: c6 07 40 00 ld [ %i5 ], %g3
previous = the_node->previous;
40004400: c4 07 60 04 ld [ %i5 + 4 ], %g2
free( RTEMS_DECONST( char *, node->name ) );
}
node->name = allocated_name;
40004404: f2 27 60 0c st %i1, [ %i5 + 0xc ]
node->namelen = namelen;
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40004408: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
4000440c: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
return &the_chain->Tail.Node;
40004410: 88 06 a0 44 add %i2, 0x44, %g4
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40004414: c2 37 60 12 sth %g1, [ %i5 + 0x12 ]
_Timecounter_Getbintime( &now );
40004418: 90 07 bf f0 add %fp, -16, %o0
next->previous = previous;
4000441c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
40004420: b0 10 20 00 clr %i0
previous->next = next;
40004424: c6 20 80 00 st %g3, [ %g2 ]
Chain_Node *old_last;
_Assert( _Chain_Is_node_off_chain( the_node ) );
tail = _Chain_Tail( the_chain );
old_last = tail->previous;
40004428: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
entry_node->Parent = dir_node;
4000442c: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
40004430: c8 27 40 00 st %g4, [ %i5 ]
tail->previous = the_node;
40004434: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
old_last->next = the_node;
40004438: fa 20 40 00 st %i5, [ %g1 ]
_Timecounter_Getbintime( &now );
4000443c: 40 00 11 c9 call 40008b60 <_Timecounter_Getbintime>
40004440: c2 27 60 04 st %g1, [ %i5 + 4 ]
return now.sec;
40004444: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
40004448: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
}
4000444c: 81 c7 e0 08 ret
40004450: 81 e8 00 00 restore
free( RTEMS_DECONST( char *, node->name ) );
40004454: 40 00 01 0c call 40004884 <free>
40004458: d0 07 60 0c ld [ %i5 + 0xc ], %o0
4000445c: 10 bf ff e8 b 400043fc <IMFS_rename+0x50>
40004460: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40004464: 40 00 2a c1 call 4000ef68 <__errno>
<== NOT EXECUTED
40004468: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000446c: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40004470: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004474: 81 c7 e0 08 ret
<== NOT EXECUTED
40004478: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000447c: 40 00 2a bb call 4000ef68 <__errno>
<== NOT EXECUTED
40004480: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004484: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004488: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000448c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004490: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40004494: 40 00 2a b5 call 4000ef68 <__errno>
<== NOT EXECUTED
40004498: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000449c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400044a0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400044a4: 81 c7 e0 08 ret
<== NOT EXECUTED
400044a8: 81 e8 00 00 restore
<== NOT EXECUTED
400044ac <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
400044ac: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
400044b0: d0 06 60 08 ld [ %i1 + 8 ], %o0
node = (*node->control->node_remove)( node );
400044b4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400044b8: c2 00 60 08 ld [ %g1 + 8 ], %g1
400044bc: 9f c0 40 00 call %g1
400044c0: 01 00 00 00 nop
if ( node != NULL ) {
400044c4: 80 a2 20 00 cmp %o0, 0
400044c8: 22 80 00 11 be,a 4000450c <IMFS_rmnod+0x60>
400044cc: b0 10 3f ff mov -1, %i0
--node->reference_count;
400044d0: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
400044d4: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
400044d8: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
400044dc: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
400044e0: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
400044e4: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
400044e8: c2 02 20 08 ld [ %o0 + 8 ], %g1
400044ec: 80 a0 60 00 cmp %g1, 0
400044f0: 02 80 00 07 be 4000450c <IMFS_rmnod+0x60>
400044f4: b0 10 20 00 clr %i0
node->Parent = NULL;
400044f8: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
400044fc: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
40004500: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
40004504: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40004508: c4 20 40 00 st %g2, [ %g1 ]
4000450c: 81 c7 e0 08 ret
40004510: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
40004514: 81 c7 e0 08 ret
<== NOT EXECUTED
40004518: 81 e8 00 00 restore
<== NOT EXECUTED
400046ac <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400046ac: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400046b0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400046b4: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
400046b8: 07 00 00 3c sethi %hi(0xf000), %g3
400046bc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400046c0: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
400046c4: 07 00 00 10 sethi %hi(0x4000), %g3
400046c8: 80 a0 40 03 cmp %g1, %g3
400046cc: 12 80 00 0f bne 40004708 <IMFS_unmount+0x5c>
<== NEVER TAKEN
400046d0: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
400046d4: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
400046d8: 80 a0 40 18 cmp %g1, %i0
400046dc: 12 80 00 05 bne 400046f0 <IMFS_unmount+0x44>
<== NEVER TAKEN
400046e0: 01 00 00 00 nop
dir->mt_fs = NULL;
400046e4: c0 20 a0 4c clr [ %g2 + 0x4c ]
400046e8: 81 c7 e0 08 ret
400046ec: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EINVAL;
400046f0: 40 00 2a 1e call 4000ef68 <__errno>
<== NOT EXECUTED
400046f4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400046f8: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400046fc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004700: 81 c7 e0 08 ret
<== NOT EXECUTED
40004704: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004708: 40 00 2a 18 call 4000ef68 <__errno>
<== NOT EXECUTED
4000470c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004710: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40004714: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40004718: 81 c7 e0 08 ret
<== NOT EXECUTED
4000471c: 81 e8 00 00 restore
<== NOT EXECUTED
4000d9a0 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4000d9a0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000d9a4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000d988 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
ioctl_command_t command,
void *buffer
)
{
4000d988: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_control(
4000d98c: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000d990: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000d994: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d998: 40 00 01 d6 call 4000e0f0 <rtems_deviceio_control>
<== NOT EXECUTED
4000d99c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d958 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000d958: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_read(
4000d95c: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000d960: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000d964: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d968: 40 00 01 aa call 4000e010 <rtems_deviceio_read>
<== NOT EXECUTED
4000d96c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d970 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000d970: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_write(
4000d974: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000d978: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000d97c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d980: 40 00 01 c0 call 4000e080 <rtems_deviceio_write>
<== NOT EXECUTED
4000d984: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d7e8 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d7e8: 9d e3 bf 98 save %sp, -104, %sp
_Mutex_Acquire( mutex );
4000d7ec: 37 10 00 6d sethi %hi(0x4001b400), %i3
4000d7f0: 7f ff ee 18 call 40009050 <_Mutex_Acquire>
4000d7f4: 90 16 e0 20 or %i3, 0x20, %o0 ! 4001b420 <pipe_mutex>
pipe = *pipep;
4000d7f8: fa 06 00 00 ld [ %i0 ], %i5
if (pipe == NULL) {
4000d7fc: 80 a7 60 00 cmp %i5, 0
4000d800: 02 80 00 1a be 4000d868 <fifo_open+0x80>
4000d804: b8 10 00 18 mov %i0, %i4
4000d808: 7f ff ee 12 call 40009050 <_Mutex_Acquire>
4000d80c: 90 07 60 28 add %i5, 0x28, %o0
if (*pipep == NULL) {
4000d810: c2 07 00 00 ld [ %i4 ], %g1
4000d814: 80 a0 60 00 cmp %g1, 0
4000d818: 22 80 00 4c be,a 4000d948 <fifo_open+0x160>
<== NEVER TAKEN
4000d81c: fa 27 00 00 st %i5, [ %i4 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000d820: 7f ff ee 28 call 400090c0 <_Mutex_Release>
4000d824: 90 16 e0 20 or %i3, 0x20, %o0
4000d828: c2 06 60 08 ld [ %i1 + 8 ], %g1
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
4000d82c: fa 07 00 00 ld [ %i4 ], %i5
switch (LIBIO_ACCMODE(iop)) {
4000d830: 82 08 60 06 and %g1, 6, %g1
4000d834: 80 a0 60 04 cmp %g1, 4
4000d838: 02 80 00 4c be 4000d968 <fifo_open+0x180>
<== ALWAYS TAKEN
4000d83c: b6 07 60 28 add %i5, 0x28, %i3
4000d840: 80 a0 60 06 cmp %g1, 6
4000d844: 02 80 00 97 be 4000daa0 <fifo_open+0x2b8>
<== NEVER TAKEN
4000d848: 80 a0 60 02 cmp %g1, 2
4000d84c: 22 80 00 74 be,a 4000da1c <fifo_open+0x234>
<== ALWAYS TAKEN
4000d850: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
return 0;
4000d854: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d858: 7f ff ee 1a call 400090c0 <_Mutex_Release>
4000d85c: 90 10 00 1b mov %i3, %o0
4000d860: 81 c7 e0 08 ret
4000d864: 81 e8 00 00 restore
pipe = malloc(sizeof(pipe_control_t));
4000d868: 7f ff df 29 call 4000550c <malloc>
4000d86c: 90 10 20 44 mov 0x44, %o0
if (pipe == NULL)
4000d870: ba 92 20 00 orcc %o0, 0, %i5
4000d874: 02 80 00 be be 4000db6c <fifo_open+0x384>
<== NEVER TAKEN
4000d878: 94 10 20 3c mov 0x3c, %o2
memset(pipe, 0, sizeof(pipe_control_t));
4000d87c: 92 10 20 00 clr %o1
4000d880: 40 00 0c e2 call 40010c08 <memset>
4000d884: 90 07 60 08 add %i5, 8, %o0
pipe->Size = PIPE_BUF;
4000d888: 82 10 22 00 mov 0x200, %g1
4000d88c: c2 27 60 04 st %g1, [ %i5 + 4 ]
pipe->Buffer = malloc(pipe->Size);
4000d890: 7f ff df 1f call 4000550c <malloc>
4000d894: 90 10 22 00 mov 0x200, %o0
if (! pipe->Buffer)
4000d898: 80 a2 20 00 cmp %o0, 0
4000d89c: 02 80 00 ad be 4000db50 <fifo_open+0x368>
<== NEVER TAKEN
4000d8a0: d0 27 40 00 st %o0, [ %i5 ]
rtems_build_name ('P', 'I', 'r', c),
4000d8a4: 35 10 00 6d sethi %hi(0x4001b400), %i2
if (rtems_barrier_create(
4000d8a8: 03 14 12 5c sethi %hi(0x50497000), %g1
rtems_build_name ('P', 'I', 'r', c),
4000d8ac: d0 4e a0 1c ldsb [ %i2 + 0x1c ], %o0
if (rtems_barrier_create(
4000d8b0: 82 10 62 00 or %g1, 0x200, %g1
4000d8b4: 96 07 60 3c add %i5, 0x3c, %o3
4000d8b8: 94 10 20 00 clr %o2
4000d8bc: 92 10 20 00 clr %o1
4000d8c0: 40 00 03 e3 call 4000e84c <rtems_barrier_create>
4000d8c4: 90 12 00 01 or %o0, %g1, %o0
4000d8c8: 80 a2 20 00 cmp %o0, 0
4000d8cc: 12 80 00 9f bne 4000db48 <fifo_open+0x360>
<== NEVER TAKEN
4000d8d0: d0 4e a0 1c ldsb [ %i2 + 0x1c ], %o0
if (rtems_barrier_create(
4000d8d4: 03 14 12 5d sethi %hi(0x50497400), %g1
4000d8d8: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000d8dc: 96 07 60 40 add %i5, 0x40, %o3
4000d8e0: 94 10 20 00 clr %o2
4000d8e4: 92 10 20 00 clr %o1
4000d8e8: 40 00 03 d9 call 4000e84c <rtems_barrier_create>
4000d8ec: 90 12 00 01 or %o0, %g1, %o0
4000d8f0: 80 a2 20 00 cmp %o0, 0
4000d8f4: 12 80 00 93 bne 4000db40 <fifo_open+0x358>
<== NEVER TAKEN
4000d8f8: 03 10 00 65 sethi %hi(0x40019400), %g1
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
4000d8fc: c0 27 60 28 clr [ %i5 + 0x28 ]
4000d900: 82 10 63 c8 or %g1, 0x3c8, %g1
4000d904: c0 27 60 2c clr [ %i5 + 0x2c ]
4000d908: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
4000d90c: c0 27 60 30 clr [ %i5 + 0x30 ]
4000d910: c0 27 60 34 clr [ %i5 + 0x34 ]
if (c ++ == 'z')
4000d914: c4 4e a0 1c ldsb [ %i2 + 0x1c ], %g2
4000d918: 80 a0 a0 7a cmp %g2, 0x7a
4000d91c: 02 80 00 3d be 4000da10 <fifo_open+0x228>
<== NEVER TAKEN
4000d920: c2 0e a0 1c ldub [ %i2 + 0x1c ], %g1
4000d924: 82 00 60 01 inc %g1
_Mutex_Acquire( mutex );
4000d928: 90 07 60 28 add %i5, 0x28, %o0
4000d92c: 7f ff ed c9 call 40009050 <_Mutex_Acquire>
4000d930: c2 2e a0 1c stb %g1, [ %i2 + 0x1c ]
if (*pipep == NULL) {
4000d934: c2 07 00 00 ld [ %i4 ], %g1
4000d938: 80 a0 60 00 cmp %g1, 0
4000d93c: 12 bf ff b9 bne 4000d820 <fifo_open+0x38>
<== NEVER TAKEN
4000d940: 01 00 00 00 nop
*pipep = pipe;
4000d944: fa 27 00 00 st %i5, [ %i4 ]
_Mutex_Release( mutex );
4000d948: 7f ff ed de call 400090c0 <_Mutex_Release>
4000d94c: 90 16 e0 20 or %i3, 0x20, %o0
4000d950: c2 06 60 08 ld [ %i1 + 8 ], %g1
pipe = *pipep;
4000d954: fa 07 00 00 ld [ %i4 ], %i5
switch (LIBIO_ACCMODE(iop)) {
4000d958: 82 08 60 06 and %g1, 6, %g1
4000d95c: 80 a0 60 04 cmp %g1, 4
4000d960: 12 bf ff b8 bne 4000d840 <fifo_open+0x58>
<== ALWAYS TAKEN
4000d964: b6 07 60 28 add %i5, 0x28, %i3
if (pipe->Writers ++ == 0)
4000d968: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
pipe->writerCounter ++;
4000d96c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d970: 82 00 60 01 inc %g1
if (pipe->Writers ++ == 0)
4000d974: 86 00 a0 01 add %g2, 1, %g3
pipe->writerCounter ++;
4000d978: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000d97c: 80 a0 a0 00 cmp %g2, 0
4000d980: 02 80 00 61 be 4000db04 <fifo_open+0x31c>
<== ALWAYS TAKEN
4000d984: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000d988: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000d98c: 80 a0 60 00 cmp %g1, 0
4000d990: 12 bf ff b2 bne 4000d858 <fifo_open+0x70>
<== ALWAYS TAKEN
4000d994: b0 10 20 00 clr %i0
4000d998: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4000d99c: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
4000d9a0: 32 80 00 55 bne,a 4000daf4 <fifo_open+0x30c>
<== NOT EXECUTED
4000d9a4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (pipe->Readers == 0) {
4000d9a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000d9ac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000d9b0: 12 bf ff aa bne 4000d858 <fifo_open+0x70>
<== NOT EXECUTED
4000d9b4: b0 10 20 00 clr %i0
<== NOT EXECUTED
prevCounter = pipe->readerCounter;
4000d9b8: 10 80 00 08 b 4000d9d8 <fifo_open+0x1f0>
<== NOT EXECUTED
4000d9bc: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000d9c0: 7f ff ed a4 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000d9c4: 01 00 00 00 nop
<== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
4000d9c8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
<== NOT EXECUTED
4000d9cc: 80 a0 40 1a cmp %g1, %i2
<== NOT EXECUTED
4000d9d0: 12 bf ff a2 bne 4000d858 <fifo_open+0x70>
<== NOT EXECUTED
4000d9d4: b0 10 20 00 clr %i0
<== NOT EXECUTED
_Mutex_Release( mutex );
4000d9d8: 7f ff ed ba call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000d9dc: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
4000d9e0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
<== NOT EXECUTED
4000d9e4: 40 00 04 06 call 4000e9fc <rtems_barrier_wait>
<== NOT EXECUTED
4000d9e8: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000d9ec: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000d9f0: 02 bf ff f4 be 4000d9c0 <fifo_open+0x1d8>
<== NOT EXECUTED
4000d9f4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
err = -EINTR;
4000d9f8: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
4000d9fc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000da00: 7f ff ff 3a call 4000d6e8 <pipe_release>
<== NOT EXECUTED
4000da04: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return err;
4000da08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000da0c: 81 e8 00 00 restore
<== NOT EXECUTED
c = 'a';
4000da10: 82 10 20 61 mov 0x61, %g1
<== NOT EXECUTED
4000da14: 10 bf ff 7d b 4000d808 <fifo_open+0x20>
<== NOT EXECUTED
4000da18: c2 2e a0 1c stb %g1, [ %i2 + 0x1c ]
<== NOT EXECUTED
pipe->readerCounter ++;
4000da1c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000da20: 82 00 60 01 inc %g1
if (pipe->Readers ++ == 0)
4000da24: 86 00 a0 01 add %g2, 1, %g3
pipe->readerCounter ++;
4000da28: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000da2c: 80 a0 a0 00 cmp %g2, 0
4000da30: 02 80 00 3a be 4000db18 <fifo_open+0x330>
<== ALWAYS TAKEN
4000da34: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
if (pipe->Writers == 0) {
4000da38: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000da3c: 80 a0 60 00 cmp %g1, 0
4000da40: 12 bf ff 86 bne 4000d858 <fifo_open+0x70>
<== NEVER TAKEN
4000da44: b0 10 20 00 clr %i0
4000da48: c2 06 60 08 ld [ %i1 + 8 ], %g1
if (LIBIO_NODELAY(iop))
4000da4c: 80 88 60 01 btst 1, %g1
4000da50: 12 bf ff 82 bne 4000d858 <fifo_open+0x70>
<== ALWAYS TAKEN
4000da54: b0 10 20 00 clr %i0
prevCounter = pipe->writerCounter;
4000da58: 10 80 00 08 b 4000da78 <fifo_open+0x290>
<== NOT EXECUTED
4000da5c: f4 07 60 24 ld [ %i5 + 0x24 ], %i2
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000da60: 7f ff ed 7c call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000da64: 01 00 00 00 nop
<== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
4000da68: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
<== NOT EXECUTED
4000da6c: 80 a0 40 1a cmp %g1, %i2
<== NOT EXECUTED
4000da70: 12 bf ff 7a bne 4000d858 <fifo_open+0x70>
<== NOT EXECUTED
4000da74: b0 10 20 00 clr %i0
<== NOT EXECUTED
_Mutex_Release( mutex );
4000da78: 7f ff ed 92 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000da7c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
4000da80: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
<== NOT EXECUTED
4000da84: 40 00 03 de call 4000e9fc <rtems_barrier_wait>
<== NOT EXECUTED
4000da88: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000da8c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000da90: 02 bf ff f4 be 4000da60 <fifo_open+0x278>
<== NOT EXECUTED
4000da94: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
out_error:
4000da98: 10 bf ff d9 b 4000d9fc <fifo_open+0x214>
<== NOT EXECUTED
4000da9c: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
if (pipe->Readers ++ == 0)
4000daa0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
<== NOT EXECUTED
pipe->readerCounter ++;
4000daa4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
<== NOT EXECUTED
4000daa8: 82 00 60 01 inc %g1
<== NOT EXECUTED
if (pipe->Readers ++ == 0)
4000daac: 86 00 a0 01 add %g2, 1, %g3
<== NOT EXECUTED
pipe->readerCounter ++;
4000dab0: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
<== NOT EXECUTED
if (pipe->Readers ++ == 0)
4000dab4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000dab8: 02 80 00 1d be 4000db2c <fifo_open+0x344>
<== NOT EXECUTED
4000dabc: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
<== NOT EXECUTED
if (pipe->Writers ++ == 0)
4000dac0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
pipe->writerCounter ++;
4000dac4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
<== NOT EXECUTED
4000dac8: 82 00 60 01 inc %g1
<== NOT EXECUTED
if (pipe->Writers ++ == 0)
4000dacc: 86 00 a0 01 add %g2, 1, %g3
<== NOT EXECUTED
pipe->writerCounter ++;
4000dad0: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
<== NOT EXECUTED
if (pipe->Writers ++ == 0)
4000dad4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000dad8: 12 bf ff 5f bne 4000d854 <fifo_open+0x6c>
<== NOT EXECUTED
4000dadc: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
<== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
4000dae0: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
<== NOT EXECUTED
4000dae4: 40 00 03 b1 call 4000e9a8 <rtems_barrier_release>
<== NOT EXECUTED
4000dae8: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
return 0;
4000daec: 10 bf ff 5b b 4000d858 <fifo_open+0x70>
<== NOT EXECUTED
4000daf0: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000daf4: 7f ff ed 73 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000daf8: b0 10 3f fa mov -6, %i0
<== NOT EXECUTED
goto out_error;
4000dafc: 10 bf ff c1 b 4000da00 <fifo_open+0x218>
<== NOT EXECUTED
4000db00: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
4000db04: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000db08: 40 00 03 a8 call 4000e9a8 <rtems_barrier_release>
4000db0c: 92 07 bf fc add %fp, -4, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000db10: 10 bf ff 9f b 4000d98c <fifo_open+0x1a4>
4000db14: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
PIPE_WAKEUPWRITERS(pipe);
4000db18: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000db1c: 40 00 03 a3 call 4000e9a8 <rtems_barrier_release>
4000db20: 92 07 bf fc add %fp, -4, %o1
if (pipe->Writers == 0) {
4000db24: 10 bf ff c6 b 4000da3c <fifo_open+0x254>
4000db28: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
PIPE_WAKEUPWRITERS(pipe);
4000db2c: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
<== NOT EXECUTED
4000db30: 40 00 03 9e call 4000e9a8 <rtems_barrier_release>
<== NOT EXECUTED
4000db34: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
if (pipe->Writers ++ == 0)
4000db38: 10 bf ff e3 b 4000dac4 <fifo_open+0x2dc>
<== NOT EXECUTED
4000db3c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
rtems_barrier_delete(pipe->readBarrier);
4000db40: 40 00 03 6f call 4000e8fc <rtems_barrier_delete>
<== NOT EXECUTED
4000db44: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
<== NOT EXECUTED
free(pipe->Buffer);
4000db48: 7f ff dd 30 call 40005008 <free>
<== NOT EXECUTED
4000db4c: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
free(pipe);
4000db50: 7f ff dd 2e call 40005008 <free>
<== NOT EXECUTED
4000db54: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return err;
4000db58: b0 10 3f f4 mov -12, %i0
<== NOT EXECUTED
4000db5c: 7f ff ed 59 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000db60: 90 16 e0 20 or %i3, 0x20, %o0
<== NOT EXECUTED
4000db64: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db68: 81 e8 00 00 restore
<== NOT EXECUTED
return err;
4000db6c: b0 10 3f f4 mov -12, %i0
<== NOT EXECUTED
4000db70: 7f ff ed 54 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000db74: 90 16 e0 20 or %i3, 0x20, %o0
<== NOT EXECUTED
}
4000db78: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db7c: 81 e8 00 00 restore
<== NOT EXECUTED
4000c568 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
4000c568: 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)
4000c56c: 92 10 21 ff mov 0x1ff, %o1
4000c570: 11 10 00 63 sethi %hi(0x40018c00), %o0
4000c574: 40 00 06 ec call 4000e124 <rtems_mkdir>
4000c578: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 40018da8 <_Thread_queue_Operations_default+0x14>
4000c57c: 80 a2 20 00 cmp %o0, 0
4000c580: 12 80 00 48 bne 4000c6a0 <pipe_create+0x138>
4000c584: 03 10 00 6f sethi %hi(0x4001bc00), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c588: d4 10 60 10 lduh [ %g1 + 0x10 ], %o2 ! 4001bc10 <rtems_pipe_no>
4000c58c: 84 02 a0 01 add %o2, 1, %g2
4000c590: c4 30 60 10 sth %g2, [ %g1 + 0x10 ]
memcpy(fifopath, "/tmp/.fifo", 10);
4000c594: 03 00 00 19 sethi %hi(0x6400), %g1
4000c598: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <_Configuration_Interrupt_stack_size+0x566f>
4000c59c: 39 0b dd 1b sethi %hi(0x2f746c00), %i4
4000c5a0: c2 37 bf f8 sth %g1, [ %fp + -8 ]
4000c5a4: b8 17 21 70 or %i4, 0x170, %i4
4000c5a8: 3b 0b cb 99 sethi %hi(0x2f2e6400), %i5
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c5ac: 13 10 00 63 sethi %hi(0x40018c00), %o1
memcpy(fifopath, "/tmp/.fifo", 10);
4000c5b0: ba 17 62 69 or %i5, 0x269, %i5
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c5b4: 92 12 61 b0 or %o1, 0x1b0, %o1
memcpy(fifopath, "/tmp/.fifo", 10);
4000c5b8: f8 3f bf f0 std %i4, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c5bc: 40 00 10 f7 call 40010998 <sprintf>
4000c5c0: 90 07 bf fa add %fp, -6, %o0
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4000c5c4: 92 10 21 80 mov 0x180, %o1
4000c5c8: 40 00 06 5f call 4000df44 <mkfifo>
4000c5cc: 90 07 bf f0 add %fp, -16, %o0
4000c5d0: ba 92 20 00 orcc %o0, 0, %i5
4000c5d4: 12 80 00 35 bne 4000c6a8 <pipe_create+0x140>
<== NEVER TAKEN
4000c5d8: 13 00 00 10 sethi %hi(0x4000), %o1
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);
4000c5dc: 7f ff e3 77 call 400053b8 <open>
4000c5e0: 90 07 bf f0 add %fp, -16, %o0
if (filsdes[0] < 0) {
4000c5e4: 80 a2 20 00 cmp %o0, 0
4000c5e8: 06 80 00 18 bl 4000c648 <pipe_create+0xe0>
4000c5ec: d0 26 00 00 st %o0, [ %i0 ]
return &rtems_libio_iops[ fd ];
4000c5f0: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000c5f4: 90 00 40 08 add %g1, %o0, %o0
<== NOT EXECUTED
4000c5f8: 03 10 00 6f sethi %hi(0x4001bc00), %g1
<== NOT EXECUTED
4000c5fc: 91 2a 20 04 sll %o0, 4, %o0
<== NOT EXECUTED
4000c600: 82 10 61 d0 or %g1, 0x1d0, %g1
<== NOT EXECUTED
4000c604: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c608: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
4000c60c: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
4000c610: 84 08 bf fe and %g2, -2, %g2
<== NOT EXECUTED
4000c614: c4 22 20 08 st %g2, [ %o0 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c618: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c61c: 01 00 00 00 nop
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
rtems_libio_iop_flags_clear( iop, LIBIO_FLAGS_NO_DELAY );
filsdes[1] = open(fifopath, O_WRONLY);
4000c620: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
4000c624: 7f ff e3 65 call 400053b8 <open>
4000c628: 90 07 bf f0 add %fp, -16, %o0
if (filsdes[1] < 0) {
4000c62c: 80 a2 20 00 cmp %o0, 0
4000c630: 06 80 00 13 bl 4000c67c <pipe_create+0x114>
4000c634: d0 26 20 04 st %o0, [ %i0 + 4 ]
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4000c638: 7f ff e8 11 call 4000667c <unlink>
4000c63c: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000c640: 81 c7 e0 08 ret
4000c644: 91 e8 00 1d restore %g0, %i5, %o0
err = errno;
4000c648: 40 00 0f b8 call 40010528 <__errno>
4000c64c: 01 00 00 00 nop
4000c650: fa 02 00 00 ld [ %o0 ], %i5
unlink(fifopath);
4000c654: 7f ff e8 0a call 4000667c <unlink>
4000c658: 90 07 bf f0 add %fp, -16, %o0
if(err != 0)
4000c65c: 80 a7 60 00 cmp %i5, 0
4000c660: 02 bf ff f8 be 4000c640 <pipe_create+0xd8>
<== NEVER TAKEN
4000c664: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(err);
4000c668: 40 00 0f b0 call 40010528 <__errno>
4000c66c: 01 00 00 00 nop
4000c670: fa 22 00 00 st %i5, [ %o0 ]
4000c674: 10 bf ff f3 b 4000c640 <pipe_create+0xd8>
4000c678: ba 10 3f ff mov -1, %i5
err = errno;
4000c67c: 40 00 0f ab call 40010528 <__errno>
4000c680: 01 00 00 00 nop
4000c684: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
4000c688: 7f ff e0 4b call 400047b4 <close>
4000c68c: d0 06 00 00 ld [ %i0 ], %o0
unlink(fifopath);
4000c690: 7f ff e7 fb call 4000667c <unlink>
4000c694: 90 07 bf f0 add %fp, -16, %o0
if(err != 0)
4000c698: 10 bf ff f2 b 4000c660 <pipe_create+0xf8>
4000c69c: 80 a7 60 00 cmp %i5, 0
return -1;
4000c6a0: 10 bf ff e8 b 4000c640 <pipe_create+0xd8>
4000c6a4: ba 10 3f ff mov -1, %i5
if (errno != EEXIST){
4000c6a8: 40 00 0f a0 call 40010528 <__errno>
<== NOT EXECUTED
4000c6ac: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
4000c6b0: 30 bf ff e4 b,a 4000c640 <pipe_create+0xd8>
<== NOT EXECUTED
4000c6b4: 00 00 00 00 unimp 0
<== NOT EXECUTED
...
4000df30 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4000df30: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if (cmd == FIONREAD) {
4000df34: 03 10 01 19 sethi %hi(0x40046400), %g1
<== NOT EXECUTED
4000df38: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <__end+0x2915f>
<== NOT EXECUTED
4000df3c: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
4000df40: 12 80 00 0d bne 4000df74 <pipe_ioctl+0x44>
<== NOT EXECUTED
4000df44: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
if (buffer == NULL)
4000df48: 02 80 00 0d be 4000df7c <pipe_ioctl+0x4c>
<== NOT EXECUTED
4000df4c: ba 06 20 28 add %i0, 0x28, %i5
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000df50: 7f ff ec 40 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000df54: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return -EFAULT;
PIPE_LOCK(pipe);
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000df58: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
4000df5c: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000df60: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000df64: 7f ff ec 57 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000df68: b0 10 20 00 clr %i0
<== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
4000df6c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000df70: 81 e8 00 00 restore
<== NOT EXECUTED
}
return -EINVAL;
4000df74: 81 c7 e0 08 ret
<== NOT EXECUTED
4000df78: 91 e8 3f ea restore %g0, -22, %o0
<== NOT EXECUTED
}
4000df7c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000df80: 91 e8 3f f2 restore %g0, -14, %o0
<== NOT EXECUTED
4000db80 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000db80: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
PIPE_LOCK(pipe);
4000db84: b8 06 20 28 add %i0, 0x28, %i4
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000db88: 7f ff ed 32 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000db8c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
while (PIPE_EMPTY(pipe)) {
4000db90: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
4000db94: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000db98: 12 80 00 27 bne 4000dc34 <pipe_read+0xb4>
<== NOT EXECUTED
4000db9c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
/* Not an error */
if (pipe->Writers == 0)
4000dba0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000dba4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dba8: 22 80 00 16 be,a 4000dc00 <pipe_read+0x80>
<== NOT EXECUTED
4000dbac: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000dbb0: c2 06 e0 08 ld [ %i3 + 8 ], %g1
<== NOT EXECUTED
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000dbb4: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
4000dbb8: 32 80 00 12 bne,a 4000dc00 <pipe_read+0x80>
<== NOT EXECUTED
4000dbbc: b0 10 3f f5 mov -11, %i0
<== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
4000dbc0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
4000dbc4: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000dbc8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dbcc: 7f ff ed 3d call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000dbd0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
4000dbd4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
<== NOT EXECUTED
4000dbd8: 40 00 03 89 call 4000e9fc <rtems_barrier_wait>
<== NOT EXECUTED
4000dbdc: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000dbe0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000dbe4: 02 80 00 0b be 4000dc10 <pipe_read+0x90>
<== NOT EXECUTED
4000dbe8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000dbec: 7f ff ed 19 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000dbf0: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
ret = -EINTR;
PIPE_LOCK(pipe);
pipe->waitingReaders --;
4000dbf4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
4000dbf8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dbfc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dc00: 7f ff ed 30 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000dc04: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (read > 0)
return read;
return ret;
}
4000dc08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc0c: 81 e8 00 00 restore
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000dc10: 7f ff ed 10 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000dc14: 01 00 00 00 nop
<== NOT EXECUTED
pipe->waitingReaders --;
4000dc18: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
4000dc1c: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dc20: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
while (PIPE_EMPTY(pipe)) {
4000dc24: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4000dc28: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dc2c: 22 bf ff de be,a 4000dba4 <pipe_read+0x24>
<== NOT EXECUTED
4000dc30: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
chunk = MIN(count - read, pipe->Length);
4000dc34: 80 a6 80 01 cmp %i2, %g1
<== NOT EXECUTED
4000dc38: 38 80 00 33 bgu,a 4000dd04 <pipe_read+0x184>
<== NOT EXECUTED
4000dc3c: b4 10 00 01 mov %g1, %i2
<== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
4000dc40: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4000dc44: f6 07 60 04 ld [ %i5 + 4 ], %i3
<== NOT EXECUTED
4000dc48: d2 07 40 00 ld [ %i5 ], %o1
<== NOT EXECUTED
4000dc4c: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
if (chunk > chunk1) {
4000dc50: 80 a6 80 1b cmp %i2, %i3
<== NOT EXECUTED
4000dc54: 14 80 00 23 bg 4000dce0 <pipe_read+0x160>
<== NOT EXECUTED
4000dc58: 92 02 40 01 add %o1, %g1, %o1
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000dc5c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dc60: 40 00 0b ae call 40010b18 <memcpy>
<== NOT EXECUTED
4000dc64: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
pipe->Start += chunk;
4000dc68: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
pipe->Length -= chunk;
4000dc6c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
pipe->Start %= pipe->Size;
4000dc70: c8 07 60 04 ld [ %i5 + 4 ], %g4
<== NOT EXECUTED
pipe->Start += chunk;
4000dc74: 82 06 80 01 add %i2, %g1, %g1
<== NOT EXECUTED
pipe->Length -= chunk;
4000dc78: 84 20 80 1a sub %g2, %i2, %g2
<== NOT EXECUTED
pipe->Start %= pipe->Size;
4000dc7c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4000dc80: 01 00 00 00 nop
<== NOT EXECUTED
4000dc84: 01 00 00 00 nop
<== NOT EXECUTED
4000dc88: 01 00 00 00 nop
<== NOT EXECUTED
4000dc8c: 86 70 40 04 udiv %g1, %g4, %g3
<== NOT EXECUTED
pipe->Length -= chunk;
4000dc90: c4 27 60 0c st %g2, [ %i5 + 0xc ]
<== NOT EXECUTED
pipe->Start %= pipe->Size;
4000dc94: 86 58 c0 04 smul %g3, %g4, %g3
<== NOT EXECUTED
4000dc98: 82 20 40 03 sub %g1, %g3, %g1
<== NOT EXECUTED
if (PIPE_EMPTY(pipe))
4000dc9c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000dca0: 12 80 00 03 bne 4000dcac <pipe_read+0x12c>
<== NOT EXECUTED
4000dca4: c2 27 60 08 st %g1, [ %i5 + 8 ]
<== NOT EXECUTED
pipe->Start = 0;
4000dca8: c0 27 60 08 clr [ %i5 + 8 ]
<== NOT EXECUTED
if (pipe->waitingWriters > 0)
4000dcac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000dcb0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dcb4: 32 80 00 1d bne,a 4000dd28 <pipe_read+0x1a8>
<== NOT EXECUTED
4000dcb8: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dcbc: 7f ff ed 01 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000dcc0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000dcc4: b0 96 a0 00 orcc %i2, 0, %i0
<== NOT EXECUTED
4000dcc8: 16 bf ff d0 bge 4000dc08 <pipe_read+0x88>
<== NOT EXECUTED
4000dccc: 01 00 00 00 nop
<== NOT EXECUTED
4000dcd0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dcd4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
ret = -EAGAIN;
4000dcd8: 10 bf ff ca b 4000dc00 <pipe_read+0x80>
<== NOT EXECUTED
4000dcdc: b0 10 3f f5 mov -11, %i0
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000dce0: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000dce4: 40 00 0b 8d call 40010b18 <memcpy>
<== NOT EXECUTED
4000dce8: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000dcec: d2 07 40 00 ld [ %i5 ], %o1
<== NOT EXECUTED
4000dcf0: 94 26 80 1b sub %i2, %i3, %o2
<== NOT EXECUTED
4000dcf4: 40 00 0b 89 call 40010b18 <memcpy>
<== NOT EXECUTED
4000dcf8: 90 06 40 1b add %i1, %i3, %o0
<== NOT EXECUTED
4000dcfc: 10 bf ff dc b 4000dc6c <pipe_read+0xec>
<== NOT EXECUTED
4000dd00: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
4000dd04: f6 07 60 04 ld [ %i5 + 4 ], %i3
<== NOT EXECUTED
4000dd08: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4000dd0c: d2 07 40 00 ld [ %i5 ], %o1
<== NOT EXECUTED
4000dd10: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
if (chunk > chunk1) {
4000dd14: 80 a6 80 1b cmp %i2, %i3
<== NOT EXECUTED
4000dd18: 04 bf ff d1 ble 4000dc5c <pipe_read+0xdc>
<== NOT EXECUTED
4000dd1c: 92 02 40 01 add %o1, %g1, %o1
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000dd20: 10 bf ff f1 b 4000dce4 <pipe_read+0x164>
<== NOT EXECUTED
4000dd24: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
4000dd28: 40 00 03 20 call 4000e9a8 <rtems_barrier_release>
<== NOT EXECUTED
4000dd2c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4000dd30: 30 bf ff e3 b,a 4000dcbc <pipe_read+0x13c>
<== NOT EXECUTED
4000d6e8 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d6e8: 9d e3 bf 98 save %sp, -104, %sp
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
4000d6ec: 39 10 00 6d sethi %hi(0x4001b400), %i4
pipe_control_t *pipe = *pipep;
4000d6f0: fa 06 00 00 ld [ %i0 ], %i5
4000d6f4: 7f ff ee 57 call 40009050 <_Mutex_Acquire>
4000d6f8: 90 17 20 20 or %i4, 0x20, %o0
uint32_t mode;
pipe_lock();
PIPE_LOCK(pipe);
4000d6fc: b6 07 60 28 add %i5, 0x28, %i3
4000d700: 7f ff ee 54 call 40009050 <_Mutex_Acquire>
4000d704: 90 10 00 1b mov %i3, %o0
4000d708: c2 06 60 08 ld [ %i1 + 8 ], %g1
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
4000d70c: 80 88 60 02 btst 2, %g1
4000d710: 02 80 00 05 be 4000d724 <pipe_release+0x3c>
4000d714: b4 08 60 06 and %g1, 6, %i2
pipe->Readers --;
4000d718: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000d71c: 84 00 bf ff add %g2, -1, %g2
4000d720: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000d724: 80 88 60 04 btst 4, %g1
4000d728: 02 80 00 05 be 4000d73c <pipe_release+0x54>
4000d72c: 01 00 00 00 nop
pipe->Writers --;
4000d730: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000d734: 82 00 7f ff add %g1, -1, %g1
4000d738: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
}
static __inline void rtems_mutex_unlock( rtems_mutex *mutex )
{
_Mutex_Release( mutex );
4000d73c: 7f ff ee 61 call 400090c0 <_Mutex_Release>
4000d740: 90 10 00 1b mov %i3, %o0
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000d744: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d748: 80 a0 60 00 cmp %g1, 0
4000d74c: 02 80 00 0e be 4000d784 <pipe_release+0x9c>
<== ALWAYS TAKEN
4000d750: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4000d754: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000d758: 12 80 00 07 bne 4000d774 <pipe_release+0x8c>
<== NOT EXECUTED
4000d75c: 80 a6 a0 02 cmp %i2, 2
<== NOT EXECUTED
4000d760: 02 80 00 05 be 4000d774 <pipe_release+0x8c>
<== NOT EXECUTED
4000d764: 01 00 00 00 nop
<== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
4000d768: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
<== NOT EXECUTED
4000d76c: 40 00 04 8f call 4000e9a8 <rtems_barrier_release>
<== NOT EXECUTED
4000d770: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4000d774: 7f ff ee 53 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000d778: 90 17 20 20 or %i4, 0x20, %o0
<== NOT EXECUTED
rtems_libio_iop_flags_clear( iop, LIBIO_FLAGS_OPEN );
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
4000d77c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d780: 81 e8 00 00 restore
<== NOT EXECUTED
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000d784: 80 a0 60 00 cmp %g1, 0
4000d788: 02 80 00 0b be 4000d7b4 <pipe_release+0xcc>
4000d78c: 80 a6 a0 04 cmp %i2, 4
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000d790: 02 bf ff f9 be 4000d774 <pipe_release+0x8c>
<== NEVER TAKEN
4000d794: 01 00 00 00 nop
PIPE_WAKEUPWRITERS(pipe);
4000d798: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000d79c: 40 00 04 83 call 4000e9a8 <rtems_barrier_release>
4000d7a0: 92 07 bf fc add %fp, -4, %o1
4000d7a4: 7f ff ee 47 call 400090c0 <_Mutex_Release>
4000d7a8: 90 17 20 20 or %i4, 0x20, %o0
}
4000d7ac: 81 c7 e0 08 ret
4000d7b0: 81 e8 00 00 restore
rtems_barrier_delete(pipe->readBarrier);
4000d7b4: 40 00 04 52 call 4000e8fc <rtems_barrier_delete>
4000d7b8: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
rtems_barrier_delete(pipe->writeBarrier);
4000d7bc: 40 00 04 50 call 4000e8fc <rtems_barrier_delete>
4000d7c0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
free(pipe->Buffer);
4000d7c4: 7f ff de 11 call 40005008 <free>
4000d7c8: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000d7cc: 7f ff de 0f call 40005008 <free>
4000d7d0: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
4000d7d4: c0 26 00 00 clr [ %i0 ]
4000d7d8: 7f ff ee 3a call 400090c0 <_Mutex_Release>
4000d7dc: 90 17 20 20 or %i4, 0x20, %o0
}
4000d7e0: 81 c7 e0 08 ret
4000d7e4: 81 e8 00 00 restore
4000dd34 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000dd34: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000dd38: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000dd3c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000dd40: 02 80 00 36 be 4000de18 <pipe_write+0xe4>
<== NOT EXECUTED
4000dd44: b0 10 20 00 clr %i0
<== NOT EXECUTED
return 0;
PIPE_LOCK(pipe);
4000dd48: b8 07 60 28 add %i5, 0x28, %i4
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000dd4c: 7f ff ec c1 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000dd50: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (pipe->Readers == 0) {
4000dd54: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000dd58: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dd5c: 02 80 00 29 be 4000de00 <pipe_write+0xcc>
<== NOT EXECUTED
4000dd60: 01 00 00 00 nop
<== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4000dd64: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
4000dd68: 80 a0 40 1a cmp %g1, %i2
<== NOT EXECUTED
4000dd6c: 1a 80 00 03 bcc 4000dd78 <pipe_write+0x44>
<== NOT EXECUTED
4000dd70: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4000dd74: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
4000dd78: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000dd7c: a2 10 20 00 clr %l1
<== NOT EXECUTED
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000dd80: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
4000dd84: 86 20 40 02 sub %g1, %g2, %g3
<== NOT EXECUTED
4000dd88: 80 a0 c0 10 cmp %g3, %l0
<== NOT EXECUTED
4000dd8c: 1a 80 00 30 bcc 4000de4c <pipe_write+0x118>
<== NOT EXECUTED
4000dd90: a4 26 80 11 sub %i2, %l1, %l2
<== NOT EXECUTED
4000dd94: c2 06 e0 08 ld [ %i3 + 8 ], %g1
<== NOT EXECUTED
if (LIBIO_NODELAY(iop)) {
4000dd98: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
4000dd9c: 32 80 00 12 bne,a 4000dde4 <pipe_write+0xb0>
<== NOT EXECUTED
4000dda0: b6 10 3f f5 mov -11, %i3
<== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
4000dda4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000dda8: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000ddac: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000ddb0: 7f ff ec c4 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000ddb4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
4000ddb8: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
<== NOT EXECUTED
4000ddbc: 40 00 03 10 call 4000e9fc <rtems_barrier_wait>
<== NOT EXECUTED
4000ddc0: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000ddc4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000ddc8: 02 80 00 16 be 4000de20 <pipe_write+0xec>
<== NOT EXECUTED
4000ddcc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000ddd0: 7f ff ec a0 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000ddd4: b6 10 3f fc mov -4, %i3
<== NOT EXECUTED
ret = -EINTR;
PIPE_LOCK(pipe);
pipe->waitingWriters --;
4000ddd8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000dddc: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dde0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dde4: 7f ff ec b7 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000dde8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000ddec: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000ddf0: 14 80 00 0a bg 4000de18 <pipe_write+0xe4>
<== NOT EXECUTED
4000ddf4: 01 00 00 00 nop
<== NOT EXECUTED
4000ddf8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ddfc: 91 e8 00 1b restore %g0, %i3, %o0
<== NOT EXECUTED
4000de00: 7f ff ec b0 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000de04: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
kill(getpid(), SIGPIPE);
4000de08: 40 00 01 7d call 4000e3fc <getpid>
<== NOT EXECUTED
4000de0c: b0 10 3f e0 mov -32, %i0
<== NOT EXECUTED
4000de10: 40 00 02 8b call 4000e83c <kill>
<== NOT EXECUTED
4000de14: 92 10 20 0d mov 0xd, %o1
<== NOT EXECUTED
4000de18: 81 c7 e0 08 ret
<== NOT EXECUTED
4000de1c: 81 e8 00 00 restore
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000de20: 7f ff ec 8c call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000de24: 01 00 00 00 nop
<== NOT EXECUTED
pipe->waitingWriters --;
4000de28: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000de2c: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000de30: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
if (pipe->Readers == 0) {
4000de34: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000de38: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000de3c: 02 80 00 26 be 4000ded4 <pipe_write+0x1a0>
<== NOT EXECUTED
4000de40: 01 00 00 00 nop
<== NOT EXECUTED
4000de44: 10 bf ff cf b 4000dd80 <pipe_write+0x4c>
<== NOT EXECUTED
4000de48: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000de4c: 80 a4 80 03 cmp %l2, %g3
<== NOT EXECUTED
4000de50: 38 80 00 02 bgu,a 4000de58 <pipe_write+0x124>
<== NOT EXECUTED
4000de54: a4 10 00 03 mov %g3, %l2
<== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000de58: c8 07 60 08 ld [ %i5 + 8 ], %g4
<== NOT EXECUTED
4000de5c: 84 00 80 04 add %g2, %g4, %g2
<== NOT EXECUTED
4000de60: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
4000de64: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4000de68: 01 00 00 00 nop
<== NOT EXECUTED
4000de6c: 01 00 00 00 nop
<== NOT EXECUTED
4000de70: 01 00 00 00 nop
<== NOT EXECUTED
4000de74: 90 70 80 01 udiv %g2, %g1, %o0
<== NOT EXECUTED
4000de78: 90 5a 00 01 smul %o0, %g1, %o0
<== NOT EXECUTED
4000de7c: 92 06 40 11 add %i1, %l1, %o1
<== NOT EXECUTED
4000de80: 84 20 80 08 sub %g2, %o0, %g2
<== NOT EXECUTED
4000de84: a0 20 40 02 sub %g1, %g2, %l0
<== NOT EXECUTED
if (chunk > chunk1) {
4000de88: 80 a4 80 10 cmp %l2, %l0
<== NOT EXECUTED
4000de8c: 14 80 00 1a bg 4000def4 <pipe_write+0x1c0>
<== NOT EXECUTED
4000de90: 90 00 c0 02 add %g3, %g2, %o0
<== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000de94: 40 00 0b 21 call 40010b18 <memcpy>
<== NOT EXECUTED
4000de98: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
pipe->Length += chunk;
4000de9c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4000dea0: 82 00 40 12 add %g1, %l2, %g1
<== NOT EXECUTED
4000dea4: c2 27 60 0c st %g1, [ %i5 + 0xc ]
<== NOT EXECUTED
if (pipe->waitingReaders > 0)
4000dea8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
4000deac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000deb0: 32 80 00 1a bne,a 4000df18 <pipe_write+0x1e4>
<== NOT EXECUTED
4000deb4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
<== NOT EXECUTED
written += chunk;
4000deb8: b0 06 00 12 add %i0, %l2, %i0
<== NOT EXECUTED
while (written < count) {
4000debc: 80 a6 00 1a cmp %i0, %i2
<== NOT EXECUTED
4000dec0: 1a 80 00 1a bcc 4000df28 <pipe_write+0x1f4>
<== NOT EXECUTED
4000dec4: a2 10 00 18 mov %i0, %l1
<== NOT EXECUTED
4000dec8: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
chunk = 1;
4000decc: 10 bf ff ad b 4000dd80 <pipe_write+0x4c>
<== NOT EXECUTED
4000ded0: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
_Mutex_Release( mutex );
4000ded4: 7f ff ec 7b call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000ded8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
kill(getpid(), SIGPIPE);
4000dedc: 40 00 01 48 call 4000e3fc <getpid>
<== NOT EXECUTED
4000dee0: b6 10 3f e0 mov -32, %i3
<== NOT EXECUTED
4000dee4: 40 00 02 56 call 4000e83c <kill>
<== NOT EXECUTED
4000dee8: 92 10 20 0d mov 0xd, %o1
<== NOT EXECUTED
if (written > 0)
4000deec: 10 bf ff c1 b 4000ddf0 <pipe_write+0xbc>
<== NOT EXECUTED
4000def0: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000def4: 40 00 0b 09 call 40010b18 <memcpy>
<== NOT EXECUTED
4000def8: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000defc: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
4000df00: 92 04 00 11 add %l0, %l1, %o1
<== NOT EXECUTED
4000df04: 94 24 80 10 sub %l2, %l0, %o2
<== NOT EXECUTED
4000df08: 40 00 0b 04 call 40010b18 <memcpy>
<== NOT EXECUTED
4000df0c: 92 06 40 09 add %i1, %o1, %o1
<== NOT EXECUTED
4000df10: 10 bf ff e4 b 4000dea0 <pipe_write+0x16c>
<== NOT EXECUTED
4000df14: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
4000df18: 40 00 02 a4 call 4000e9a8 <rtems_barrier_release>
<== NOT EXECUTED
4000df1c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
written += chunk;
4000df20: 10 bf ff e7 b 4000debc <pipe_write+0x188>
<== NOT EXECUTED
4000df24: b0 06 00 12 add %i0, %l2, %i0
<== NOT EXECUTED
out_locked:
4000df28: 10 bf ff af b 4000dde4 <pipe_write+0xb0>
<== NOT EXECUTED
4000df2c: b6 10 20 00 clr %i3
<== NOT EXECUTED