4001192c <IMFS_LIMITS_AND_OPTIONS>:
4001192c: 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 ff ................
4001193c: 00 00 00 ff 00 00 00 02 00 00 00 01 00 00 00 02 ................
4001194c: 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 ................
4001195c: 00 00 00 00 4e 4f 4e 42 4c 4f 43 4b 00 00 00 00 ....NONBLOCK....
4001196c: 00 00 00 00 41 50 50 45 4e 44 00 00 52 45 41 44 ....APPEND..READ
4001197c: 00 00 00 00 57 52 49 54 45 00 00 00 52 45 41 44 ....WRITE...READ
4001198c: 2f 57 52 49 54 45 00 00 /WRITE..
40003260 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
40003260: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = (IMFS_jnode_t *) loc->node_access;
40003264: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_uid = owner;
40003268: f2 37 60 1c sth %i1, [ %i5 + 0x1c ]
<== NOT EXECUTED
static inline time_t _IMFS_get_time( void )
{
struct bintime now;
/* Use most efficient way to get the time in seconds (CLOCK_REALTIME) */
_Timecounter_Getbintime( &now );
4000326c: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
jnode->st_gid = group;
40003270: f4 37 60 1e sth %i2, [ %i5 + 0x1e ]
<== NOT EXECUTED
40003274: 40 00 17 7d call 40009068 <_Timecounter_Getbintime>
<== NOT EXECUTED
40003278: b0 10 20 00 clr %i0
<== NOT EXECUTED
return now.sec;
4000327c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_mtime = _IMFS_get_time();
}
static inline void IMFS_update_ctime( IMFS_jnode_t *jnode )
{
jnode->stat_ctime = _IMFS_get_time();
40003280: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
IMFS_update_ctime( jnode );
return 0;
}
40003284: 81 c7 e0 08 ret
<== NOT EXECUTED
40003288: 81 e8 00 00 restore
<== NOT EXECUTED
4000de68 <IMFS_create_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
4000de68: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *allocated_node;
IMFS_jnode_t *node;
allocated_node = calloc( 1, node_size + namelen );
4000de6c: 90 10 20 01 mov 1, %o0
4000de70: 7f ff da eb call 40004a1c <calloc>
4000de74: 92 06 80 1c add %i2, %i4, %o1
if ( allocated_node == NULL ) {
4000de78: a0 92 20 00 orcc %o0, 0, %l0
4000de7c: 02 80 00 1c be 4000deec <IMFS_create_node+0x84>
<== NEVER TAKEN
4000de80: da 07 a0 5c ld [ %fp + 0x5c ], %o5
errno = ENOMEM;
return NULL;
}
node = IMFS_initialize_node(
4000de84: 98 10 00 1d mov %i5, %o4
4000de88: 96 10 00 1c mov %i4, %o3
4000de8c: 94 04 00 1a add %l0, %i2, %o2
4000de90: 7f ff d9 ae call 40004548 <IMFS_initialize_node>
4000de94: 92 10 00 19 mov %i1, %o1
(char *) allocated_node + node_size,
namelen,
mode,
arg
);
if ( node != NULL ) {
4000de98: ba 92 20 00 orcc %o0, 0, %i5
4000de9c: 02 80 00 0f be 4000ded8 <IMFS_create_node+0x70>
4000dea0: 94 10 00 1c mov %i4, %o2
IMFS_jnode_t *parent = parentloc->node_access;
memcpy( RTEMS_DECONST( char *, node->name ), name, namelen );
4000dea4: d0 07 60 0c ld [ %i5 + 0xc ], %o0
IMFS_jnode_t *parent = parentloc->node_access;
4000dea8: f4 06 20 08 ld [ %i0 + 8 ], %i2
memcpy( RTEMS_DECONST( char *, node->name ), name, namelen );
4000deac: 40 00 06 18 call 4000f70c <memcpy>
4000deb0: 92 10 00 1b mov %i3, %o1
old_last = tail->previous;
4000deb4: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
return &the_chain->Tail.Node;
4000deb8: 84 06 a0 44 add %i2, 0x44, %g2
entry_node->Parent = dir_node;
4000debc: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
4000dec0: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
4000dec4: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
old_last->next = the_node;
4000dec8: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
4000decc: c2 27 60 04 st %g1, [ %i5 + 4 ]
} else {
free( allocated_node );
}
return node;
}
4000ded0: 81 c7 e0 08 ret
4000ded4: 91 e8 00 1d restore %g0, %i5, %o0
free( allocated_node );
4000ded8: 90 10 00 10 mov %l0, %o0
4000dedc: 7f ff db 1b call 40004b48 <free>
4000dee0: b0 10 00 1d mov %i5, %i0
}
4000dee4: 81 c7 e0 08 ret
4000dee8: 81 e8 00 00 restore
errno = ENOMEM;
4000deec: 40 00 05 7b call 4000f4d8 <__errno>
<== NOT EXECUTED
4000def0: ba 10 20 00 clr %i5
<== NOT EXECUTED
4000def4: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
return NULL;
4000def8: 10 bf ff f6 b 4000ded0 <IMFS_create_node+0x68>
<== NOT EXECUTED
4000defc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400036d0 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
400036d0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = loc->node_access;
400036d4: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_mode = mode;
400036d8: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
400036dc: 40 00 16 63 call 40009068 <_Timecounter_Getbintime>
<== NOT EXECUTED
400036e0: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
400036e4: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
400036e8: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
IMFS_update_ctime( jnode );
return 0;
}
400036ec: 81 c7 e0 08 ret
<== NOT EXECUTED
400036f0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40004548 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
40004548: 9d e3 bf 90 save %sp, -112, %sp
struct timeval tv;
if ( namelen > IMFS_NAME_MAX ) {
4000454c: 80 a6 e0 ff cmp %i3, 0xff
40004550: 18 80 00 19 bgu 400045b4 <IMFS_initialize_node+0x6c>
<== NEVER TAKEN
40004554: 92 10 20 00 clr %o1
errno = ENAMETOOLONG;
return NULL;
}
gettimeofday( &tv, 0 );
40004558: 40 00 01 aa call 40004c00 <gettimeofday>
4000455c: 90 07 bf f0 add %fp, -16, %o0
/*
* Fill in the basic information
*/
node->name = name;
node->namelen = namelen;
node->reference_count = 1;
40004560: 03 00 00 40 sethi %hi(0x10000), %g1
node->name = name;
40004564: f4 26 20 0c st %i2, [ %i0 + 0xc ]
node->reference_count = 1;
40004568: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
4000456c: f6 36 20 10 sth %i3, [ %i0 + 0x10 ]
node->reference_count = 1;
40004570: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
node->st_nlink = 1;
node->control = node_control;
40004574: f2 26 20 38 st %i1, [ %i0 + 0x38 ]
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode;
node->st_uid = geteuid();
40004578: 40 00 01 9c call 40004be8 <geteuid>
4000457c: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
node->st_gid = getegid();
40004580: 40 00 01 94 call 40004bd0 <getegid>
40004584: d0 36 20 1c sth %o0, [ %i0 + 0x1c ]
/*
* Now set all the times.
*/
node->stat_atime = (time_t) tv.tv_sec;
40004588: c4 1f bf f0 ldd [ %fp + -16 ], %g2
node->st_gid = getegid();
4000458c: d0 36 20 1e sth %o0, [ %i0 + 0x1e ]
node->stat_mtime = (time_t) tv.tv_sec;
node->stat_ctime = (time_t) tv.tv_sec;
return (*node_control->node_initialize)( node, arg );
40004590: 92 10 00 1d mov %i5, %o1
node->stat_atime = (time_t) tv.tv_sec;
40004594: c4 3e 20 20 std %g2, [ %i0 + 0x20 ]
node->stat_mtime = (time_t) tv.tv_sec;
40004598: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
node->stat_ctime = (time_t) tv.tv_sec;
4000459c: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
return (*node_control->node_initialize)( node, arg );
400045a0: c2 06 60 04 ld [ %i1 + 4 ], %g1
400045a4: 9f c0 40 00 call %g1
400045a8: 90 10 00 18 mov %i0, %o0
}
400045ac: 81 c7 e0 08 ret
400045b0: 91 e8 00 08 restore %g0, %o0, %o0
errno = ENAMETOOLONG;
400045b4: 40 00 2b c9 call 4000f4d8 <__errno>
<== NOT EXECUTED
400045b8: b0 10 20 00 clr %i0
<== NOT EXECUTED
400045bc: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
400045c0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return NULL;
400045c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400045c8: 81 e8 00 00 restore
<== NOT EXECUTED
40003744 <IMFS_initialize_support>:
{
40003744: 9d e3 bf a0 save %sp, -96, %sp
IMFS_fs_info_t *fs_info = mount_data->fs_info;
40003748: fa 06 40 00 ld [ %i1 ], %i5
fs_info->mknod_controls = mount_data->mknod_controls;
4000374c: c2 06 60 08 ld [ %i1 + 8 ], %g1
40003750: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
root_node = IMFS_initialize_node(
40003754: 9a 10 20 00 clr %o5
40003758: d2 00 40 00 ld [ %g1 ], %o1
4000375c: 96 10 20 00 clr %o3
40003760: 19 00 00 10 sethi %hi(0x4000), %o4
40003764: 90 10 00 1d mov %i5, %o0
40003768: 98 13 21 ed or %o4, 0x1ed, %o4
4000376c: 15 10 00 44 sethi %hi(0x40011000), %o2
40003770: 40 00 03 76 call 40004548 <IMFS_initialize_node>
40003774: 94 12 a0 00 mov %o2, %o2 ! 40011000 <rtems_libio_number_iops+0x200>
mt_entry->ops = mount_data->ops;
40003778: c2 06 60 04 ld [ %i1 + 4 ], %g1
loc->handlers = node->control->handlers;
4000377c: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
40003780: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003784: 03 10 00 46 sethi %hi(0x40011800), %g1
40003788: 82 10 61 2c or %g1, 0x12c, %g1 ! 4001192c <IMFS_LIMITS_AND_OPTIONS>
mt_entry->fs_info = fs_info;
4000378c: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003790: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
40003794: c4 00 80 00 ld [ %g2 ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
40003798: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000379c: d0 20 60 08 st %o0, [ %g1 + 8 ]
400037a0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
IMFS_determine_bytes_per_block(
400037a4: 03 10 00 4b sethi %hi(0x40012c00), %g1
400037a8: c6 00 63 68 ld [ %g1 + 0x368 ], %g3 ! 40012f68 <imfs_rq_memfile_bytes_per_block>
if (bit_mask == requested_bytes_per_block) {
400037ac: 80 a0 e0 10 cmp %g3, 0x10
400037b0: 02 80 00 0e be 400037e8 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
400037b4: 80 a0 e0 0f cmp %g3, 0xf
if(bit_mask > requested_bytes_per_block)
400037b8: 04 80 00 0b ble 400037e4 <IMFS_initialize_support+0xa0> <== NEVER TAKEN
400037bc: 82 10 20 20 mov 0x20, %g1
400037c0: 84 10 20 05 mov 5, %g2
if (bit_mask == requested_bytes_per_block) {
400037c4: 80 a0 c0 01 cmp %g3, %g1
400037c8: 22 80 00 09 be,a 400037ec <IMFS_initialize_support+0xa8>
400037cc: 03 10 00 51 sethi %hi(0x40014400), %g1
if(bit_mask > requested_bytes_per_block)
400037d0: 26 80 00 06 bl,a 400037e8 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
400037d4: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
400037d8: 84 80 bf ff addcc %g2, -1, %g2
400037dc: 12 bf ff fa bne 400037c4 <IMFS_initialize_support+0x80> <== ALWAYS TAKEN
400037e0: 83 28 60 01 sll %g1, 1, %g1
: default_bytes_per_block);
400037e4: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
*dest_bytes_per_block = ((is_valid)
400037e8: 03 10 00 51 sethi %hi(0x40014400), %g1
<== NOT EXECUTED
400037ec: c6 20 63 c4 st %g3, [ %g1 + 0x3c4 ] ! 400147c4 <imfs_memfile_bytes_per_block>
}
400037f0: 81 c7 e0 08 ret
400037f4: 91 e8 20 00 restore %g0, 0, %o0
400038e4 <IMFS_link>:
{
400038e4: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
target = targetloc->node_access;
400038e8: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
if ( target->st_nlink >= LINK_MAX )
400038ec: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
<== NOT EXECUTED
400038f0: 80 a0 60 07 cmp %g1, 7
<== NOT EXECUTED
400038f4: 18 80 00 19 bgu 40003958 <IMFS_link+0x74>
<== NOT EXECUTED
400038f8: 9a 10 21 ff mov 0x1ff, %o5
<== NOT EXECUTED
new_node = IMFS_create_node(
400038fc: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
<== NOT EXECUTED
40003900: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
40003904: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40003908: 94 10 20 48 mov 0x48, %o2
<== NOT EXECUTED
4000390c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40003910: 13 10 00 44 sethi %hi(0x40011000), %o1
<== NOT EXECUTED
40003914: 40 00 29 55 call 4000de68 <IMFS_create_node>
<== NOT EXECUTED
40003918: 92 12 61 08 or %o1, 0x108, %o1 ! 40011108 <IMFS_node_control_hard_link>
<== NOT EXECUTED
if ( !new_node )
4000391c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003920: 02 80 00 14 be 40003970 <IMFS_link+0x8c>
<== NOT EXECUTED
40003924: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
target->reference_count++;
40003928: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
<== NOT EXECUTED
target->st_nlink++;
4000392c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
<== NOT EXECUTED
target->reference_count++;
40003930: 84 00 a0 01 inc %g2
<== NOT EXECUTED
target->st_nlink++;
40003934: 82 00 60 01 inc %g1
<== NOT EXECUTED
target->reference_count++;
40003938: c4 37 60 18 sth %g2, [ %i5 + 0x18 ]
<== NOT EXECUTED
target->st_nlink++;
4000393c: c2 37 60 1a sth %g1, [ %i5 + 0x1a ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003940: 40 00 15 ca call 40009068 <_Timecounter_Getbintime>
<== NOT EXECUTED
40003944: b0 10 20 00 clr %i0
<== NOT EXECUTED
return now.sec;
40003948: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
4000394c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
40003950: 81 c7 e0 08 ret
<== NOT EXECUTED
40003954: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMLINK );
40003958: 40 00 2e e0 call 4000f4d8 <__errno>
<== NOT EXECUTED
4000395c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003960: 82 10 20 1f mov 0x1f, %g1
<== NOT EXECUTED
40003964: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003968: 81 c7 e0 08 ret
<== NOT EXECUTED
4000396c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40003970: 40 00 2e da call 4000f4d8 <__errno>
<== NOT EXECUTED
40003974: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003978: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
4000397c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003980: 81 c7 e0 08 ret
<== NOT EXECUTED
40003984: 81 e8 00 00 restore
<== NOT EXECUTED
4000df00 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
4000df00: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000df04: 7f ff de 1f call 40005780 <rtems_current_user_env_get>
4000df08: 01 00 00 00 nop
4000df0c: da 02 20 08 ld [ %o0 + 8 ], %o5
4000df10: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
4000df14: 03 00 00 3c sethi %hi(0xf000), %g1
4000df18: 05 00 00 18 sethi %hi(0x6000), %g2
4000df1c: 82 0e 40 01 and %i1, %g1, %g1
4000df20: 80 a0 40 02 cmp %g1, %g2
4000df24: 02 80 00 0c be 4000df54 <IMFS_make_generic_node+0x54>
<== NEVER TAKEN
4000df28: 94 10 20 78 mov 0x78, %o2
4000df2c: 08 80 00 1d bleu 4000dfa0 <IMFS_make_generic_node+0xa0> <== ALWAYS TAKEN
4000df30: 05 00 00 04 sethi %hi(0x1000), %g2
4000df34: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4000df38: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000df3c: 02 80 00 06 be 4000df54 <IMFS_make_generic_node+0x54>
<== NOT EXECUTED
4000df40: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
4000df44: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000df48: 12 80 00 1c bne 4000dfb8 <IMFS_make_generic_node+0xb8>
<== NOT EXECUTED
4000df4c: 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 =
4000df50: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
4000df54: 92 10 00 18 mov %i0, %o1
4000df58: 7f ff df b8 call 40005e38 <rtems_filesystem_eval_path_start>
4000df5c: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
4000df60: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000df64: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
4000df68: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000df6c: 03 10 00 11 sethi %hi(0x40004400), %g1
4000df70: 82 10 61 cc or %g1, 0x1cc, %g1 ! 400045cc <IMFS_node_clone>
4000df74: 80 a0 80 01 cmp %g2, %g1
4000df78: 02 80 00 16 be 4000dfd0 <IMFS_make_generic_node+0xd0>
<== ALWAYS TAKEN
4000df7c: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
4000df80: 92 10 20 86 mov 0x86, %o1
<== NOT EXECUTED
4000df84: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
4000df88: 7f ff de f1 call 40005b4c <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000df8c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000df90: 7f ff df b6 call 40005e68 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000df94: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
}
return rv;
}
4000df98: 81 c7 e0 08 ret
<== NOT EXECUTED
4000df9c: 81 e8 00 00 restore
<== NOT EXECUTED
switch (mode & S_IFMT) {
4000dfa0: 80 a0 40 02 cmp %g1, %g2
4000dfa4: 02 bf ff eb be 4000df50 <IMFS_make_generic_node+0x50>
<== NEVER TAKEN
4000dfa8: 05 00 00 08 sethi %hi(0x2000), %g2
4000dfac: 80 a0 40 02 cmp %g1, %g2
4000dfb0: 02 bf ff e9 be 4000df54 <IMFS_make_generic_node+0x54>
<== ALWAYS TAKEN
4000dfb4: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
4000dfb8: 40 00 05 48 call 4000f4d8 <__errno>
<== NOT EXECUTED
4000dfbc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000dfc0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000dfc4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000dfc8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dfcc: 81 e8 00 00 restore
<== NOT EXECUTED
IMFS_jnode_t *new_node = IMFS_create_node(
4000dfd0: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000dfd4: 9a 10 00 19 mov %i1, %o5
4000dfd8: d8 07 bf d4 ld [ %fp + -44 ], %o4
4000dfdc: d6 07 bf d0 ld [ %fp + -48 ], %o3
4000dfe0: 94 10 20 48 mov 0x48, %o2
4000dfe4: 92 10 00 1a mov %i2, %o1
4000dfe8: 7f ff ff a0 call 4000de68 <IMFS_create_node>
4000dfec: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
4000dff0: 80 a2 20 00 cmp %o0, 0
4000dff4: 02 bf ff e7 be 4000df90 <IMFS_make_generic_node+0x90>
<== NEVER TAKEN
4000dff8: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
4000dffc: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
4000e000: 7f ff ec 1a call 40009068 <_Timecounter_Getbintime>
4000e004: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
4000e008: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
4000e00c: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
4000e010: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
4000e014: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
4000e018: 7f ff df 94 call 40005e68 <rtems_filesystem_eval_path_cleanup>
4000e01c: 90 07 bf c8 add %fp, -56, %o0
}
4000e020: 81 c7 e0 08 ret
4000e024: 81 e8 00 00 restore
400041c8 <IMFS_memfile_write>:
{
400041c8: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
if ( last_byte > memfile->File.size ) {
400041cc: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
last_byte = start + my_length;
400041d0: 96 07 00 1a add %i4, %i2, %o3
<== NOT EXECUTED
if ( last_byte > memfile->File.size ) {
400041d4: 80 a0 40 0b cmp %g1, %o3
<== NOT EXECUTED
400041d8: 0a 80 00 54 bcs 40004328 <IMFS_memfile_write+0x160>
<== NOT EXECUTED
400041dc: a0 10 00 18 mov %i0, %l0
<== NOT EXECUTED
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
400041e0: 23 10 00 51 sethi %hi(0x40014400), %l1
<== NOT EXECUTED
400041e4: e4 04 63 c4 ld [ %l1 + 0x3c4 ], %l2 ! 400147c4 <imfs_memfile_bytes_per_block>
<== NOT EXECUTED
400041e8: bb 3c a0 1f sra %l2, 0x1f, %i5
<== NOT EXECUTED
400041ec: 96 10 00 12 mov %l2, %o3
<== NOT EXECUTED
400041f0: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
400041f4: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
400041f8: 40 00 2f be call 400100f0 <__moddi3>
<== NOT EXECUTED
400041fc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40004200: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40004204: a6 10 00 09 mov %o1, %l3
<== NOT EXECUTED
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40004208: 96 10 00 12 mov %l2, %o3
<== NOT EXECUTED
4000420c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40004210: 40 00 2f 2d call 4000fec4 <__divdi3>
<== NOT EXECUTED
40004214: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40004218: ba 10 00 12 mov %l2, %i5
<== NOT EXECUTED
4000421c: b4 10 00 09 mov %o1, %i2
<== NOT EXECUTED
if ( start_offset ) {
40004220: 80 a4 e0 00 cmp %l3, 0
<== NOT EXECUTED
40004224: 12 80 00 1a bne 4000428c <IMFS_memfile_write+0xc4>
<== NOT EXECUTED
40004228: b0 10 20 00 clr %i0
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000422c: 80 a7 00 1d cmp %i4, %i5
<== NOT EXECUTED
40004230: 1a 80 00 0e bcc 40004268 <IMFS_memfile_write+0xa0>
<== NOT EXECUTED
40004234: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
if ( my_length ) {
40004238: 10 80 00 29 b 400042dc <IMFS_memfile_write+0x114>
<== NOT EXECUTED
4000423c: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40004240: 40 00 2d 33 call 4000f70c <memcpy>
<== NOT EXECUTED
40004244: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004248: c2 04 63 c4 ld [ %l1 + 0x3c4 ], %g1
<== NOT EXECUTED
my_length -= to_copy;
4000424c: b8 27 00 1d sub %i4, %i5, %i4
<== NOT EXECUTED
src += to_copy;
40004250: b6 06 c0 1d add %i3, %i5, %i3
<== NOT EXECUTED
block++;
40004254: b4 06 a0 01 inc %i2
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004258: 80 a0 40 1c cmp %g1, %i4
<== NOT EXECUTED
4000425c: 18 80 00 1f bgu 400042d8 <IMFS_memfile_write+0x110>
<== NOT EXECUTED
40004260: b0 06 00 1d add %i0, %i5, %i0
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40004264: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40004268: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000426c: 7f ff fd d4 call 400039bc <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40004270: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40004274: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
if ( !block_ptr )
40004278: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000427c: 12 bf ff f1 bne 40004240 <IMFS_memfile_write+0x78>
<== NOT EXECUTED
40004280: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
}
40004284: 81 c7 e0 08 ret
<== NOT EXECUTED
40004288: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
4000428c: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004290: 7f ff fd cb call 400039bc <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40004294: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( !block_ptr )
40004298: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000429c: 02 bf ff fa be 40004284 <IMFS_memfile_write+0xbc>
<== NOT EXECUTED
400042a0: a4 24 80 13 sub %l2, %l3, %l2
<== NOT EXECUTED
400042a4: 80 a7 00 12 cmp %i4, %l2
<== NOT EXECUTED
400042a8: 18 80 00 37 bgu 40004384 <IMFS_memfile_write+0x1bc>
<== NOT EXECUTED
400042ac: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400042b0: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
400042b4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
400042b8: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
400042bc: 90 02 00 13 add %o0, %l3, %o0
<== NOT EXECUTED
400042c0: 40 00 2d 13 call 4000f70c <memcpy>
<== NOT EXECUTED
400042c4: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
block++;
400042c8: b4 06 a0 01 inc %i2
<== NOT EXECUTED
400042cc: fa 04 63 c4 ld [ %l1 + 0x3c4 ], %i5
<== NOT EXECUTED
my_length -= to_copy;
400042d0: 10 bf ff d7 b 4000422c <IMFS_memfile_write+0x64>
<== NOT EXECUTED
400042d4: b8 27 00 18 sub %i4, %i0, %i4
<== NOT EXECUTED
if ( my_length ) {
400042d8: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
400042dc: 02 80 00 0c be 4000430c <IMFS_memfile_write+0x144>
<== NOT EXECUTED
400042e0: 94 10 20 00 clr %o2
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
400042e4: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
400042e8: 7f ff fd b5 call 400039bc <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
400042ec: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( !block_ptr )
400042f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400042f4: 02 bf ff e4 be 40004284 <IMFS_memfile_write+0xbc>
<== NOT EXECUTED
400042f8: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, my_length );
400042fc: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40004300: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40004304: 40 00 2d 02 call 4000f70c <memcpy>
<== NOT EXECUTED
40004308: b0 06 00 1c add %i0, %i4, %i0
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
4000430c: 40 00 13 57 call 40009068 <_Timecounter_Getbintime>
<== NOT EXECUTED
40004310: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
40004314: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_mtime = now;
40004318: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
<== NOT EXECUTED
jnode->stat_ctime = now;
4000431c: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
<== NOT EXECUTED
}
40004320: 81 c7 e0 08 ret
<== NOT EXECUTED
40004324: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40004328: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000432c: 04 80 00 0b ble 40004358 <IMFS_memfile_write+0x190>
<== NOT EXECUTED
40004330: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40004334: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004338: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
4000433c: 7f ff fe 49 call 40003c60 <IMFS_memfile_extend>
<== NOT EXECUTED
40004340: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40004344: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40004348: 02 bf ff a7 be 400041e4 <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
4000434c: 23 10 00 51 sethi %hi(0x40014400), %l1
<== NOT EXECUTED
40004350: 81 c7 e0 08 ret
<== NOT EXECUTED
40004354: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40004358: 02 80 00 16 be 400043b0 <IMFS_memfile_write+0x1e8>
<== NOT EXECUTED
4000435c: 80 a6 80 01 cmp %i2, %g1
<== NOT EXECUTED
40004360: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40004364: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004368: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
4000436c: 7f ff fe 3d call 40003c60 <IMFS_memfile_extend>
<== NOT EXECUTED
40004370: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40004374: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40004378: 02 bf ff 9b be 400041e4 <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
4000437c: 23 10 00 51 sethi %hi(0x40014400), %l1
<== NOT EXECUTED
40004380: 30 bf ff f4 b,a 40004350 <IMFS_memfile_write+0x188>
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40004384: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40004388: b0 10 00 12 mov %l2, %i0
<== NOT EXECUTED
4000438c: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40004390: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40004394: 90 02 00 13 add %o0, %l3, %o0
<== NOT EXECUTED
40004398: 40 00 2c dd call 4000f70c <memcpy>
<== NOT EXECUTED
4000439c: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
block++;
400043a0: b4 06 a0 01 inc %i2
<== NOT EXECUTED
400043a4: fa 04 63 c4 ld [ %l1 + 0x3c4 ], %i5
<== NOT EXECUTED
my_length -= to_copy;
400043a8: 10 bf ff a1 b 4000422c <IMFS_memfile_write+0x64>
<== NOT EXECUTED
400043ac: b8 27 00 18 sub %i4, %i0, %i4
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
400043b0: 18 bf ff e2 bgu 40004338 <IMFS_memfile_write+0x170>
<== NOT EXECUTED
400043b4: 94 10 20 00 clr %o2
<== NOT EXECUTED
400043b8: 10 bf ff ec b 40004368 <IMFS_memfile_write+0x1a0>
<== NOT EXECUTED
400043bc: 92 10 20 00 clr %o1
<== NOT EXECUTED
40011060 <IMFS_mknod_control_device>:
40011060: 40 01 10 74 40 00 36 f4 40 00 46 3c 40 00 46 44 @..t@.6.@.F<@.FD
40011070: 00 00 00 48 ...H
40011004 <IMFS_mknod_control_dir_default>:
40011004: 40 01 10 18 40 00 34 40 40 00 34 58 40 00 46 44 @...@.4@@.4X@.FD
40011014: 00 00 00 50 ...P
400110b4 <IMFS_mknod_control_enosys>:
400110b4: 40 01 18 ec 40 00 37 28 40 00 46 3c 40 00 46 44 @...@.7(@.F<@.FD
400110c4: 00 00 00 40 ...@
40012368 <IMFS_mknod_control_fifo>:
40012368: 40 01 23 7c 40 00 36 9c 40 00 44 e0 40 00 44 e8 @.#|@.6.@.D.@.D.
40012378: 00 00 00 48 ...H
40011118 <IMFS_mknod_control_memfile>:
40011118: 40 01 11 2c 40 00 37 f8 40 00 46 3c 40 00 40 64 @..,@.7.@.F<@.@d
40011128: 00 00 00 58 ...X
400044d4 <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400044d4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400044d8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
400044dc: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
400044e0: 07 00 00 3c sethi %hi(0xf000), %g3
<== NOT EXECUTED
400044e4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
400044e8: 82 08 40 03 and %g1, %g3, %g1
<== NOT EXECUTED
if ( IMFS_is_directory( node ) ) {
400044ec: 07 00 00 10 sethi %hi(0x4000), %g3
<== NOT EXECUTED
400044f0: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400044f4: 12 80 00 0f bne 40004530 <IMFS_mount+0x5c>
<== NOT EXECUTED
400044f8: 01 00 00 00 nop
<== NOT EXECUTED
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
400044fc: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
<== NOT EXECUTED
40004500: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40004504: 12 80 00 05 bne 40004518 <IMFS_mount+0x44>
<== NOT EXECUTED
40004508: 01 00 00 00 nop
<== NOT EXECUTED
dir->mt_fs = mt_entry;
4000450c: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
<== NOT EXECUTED
40004510: 81 c7 e0 08 ret
<== NOT EXECUTED
40004514: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
} else {
errno = EBUSY;
40004518: 40 00 2b f0 call 4000f4d8 <__errno>
<== NOT EXECUTED
4000451c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004520: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40004524: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004528: 81 c7 e0 08 ret
<== NOT EXECUTED
4000452c: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004530: 40 00 2b ea call 4000f4d8 <__errno>
<== NOT EXECUTED
40004534: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004538: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
4000453c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40004540: 81 c7 e0 08 ret
<== NOT EXECUTED
40004544: 81 e8 00 00 restore
<== NOT EXECUTED
400045e4 <IMFS_node_destroy>:
void IMFS_node_destroy( IMFS_jnode_t *node )
{
400045e4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_assert( node->reference_count == 0 );
(*node->control->node_destroy)( node );
400045e8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
<== NOT EXECUTED
400045ec: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
400045f0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400045f4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
400045f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400045fc: 81 e8 00 00 restore
<== NOT EXECUTED
40004644 <IMFS_node_destroy_default>:
void IMFS_node_destroy_default( IMFS_jnode_t *node )
{
40004644: 9d e3 bf a0 save %sp, -96, %sp
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
40004648: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1
4000464c: 80 88 60 01 btst 1, %g1
40004650: 12 80 00 04 bne 40004660 <IMFS_node_destroy_default+0x1c> <== NEVER TAKEN
40004654: 01 00 00 00 nop
free( RTEMS_DECONST( char *, node->name ) );
}
free( node );
40004658: 40 00 01 3c call 40004b48 <free>
4000465c: 81 e8 00 00 restore
free( RTEMS_DECONST( char *, node->name ) );
40004660: 40 00 01 3a call 40004b48 <free>
<== NOT EXECUTED
40004664: d0 06 20 0c ld [ %i0 + 0xc ], %o0
<== NOT EXECUTED
free( node );
40004668: 40 00 01 38 call 40004b48 <free>
<== NOT EXECUTED
4000466c: 81 e8 00 00 restore
<== NOT EXECUTED
40003458 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40003458: 9d e3 bf a0 save %sp, -96, %sp
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
4000345c: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
return &the_chain->Tail.Node;
40003460: 82 06 20 44 add %i0, 0x44, %g1
40003464: 80 a0 80 01 cmp %g2, %g1
40003468: 12 80 00 0c bne 40003498 <IMFS_node_remove_directory+0x40> <== NEVER TAKEN
4000346c: 01 00 00 00 nop
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
40003470: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
40003474: 80 a0 60 00 cmp %g1, 0
40003478: 02 80 00 0c be 400034a8 <IMFS_node_remove_directory+0x50> <== ALWAYS TAKEN
4000347c: 01 00 00 00 nop
errno = EBUSY;
40003480: 40 00 30 16 call 4000f4d8 <__errno>
<== NOT EXECUTED
40003484: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
40003488: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000348c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
40003490: 81 c7 e0 08 ret
<== NOT EXECUTED
40003494: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
40003498: 40 00 30 10 call 4000f4d8 <__errno>
<== NOT EXECUTED
4000349c: b0 10 20 00 clr %i0
<== NOT EXECUTED
400034a0: 82 10 20 5a mov 0x5a, %g1
<== NOT EXECUTED
400034a4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400034a8: 81 c7 e0 08 ret
400034ac: 81 e8 00 00 restore
4000490c <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
4000490c: 80 a2 a0 00 cmp %o2, 0
<== NOT EXECUTED
40004910: 02 80 00 16 be 40004968 <IMFS_readlink+0x5c>
<== NOT EXECUTED
40004914: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
40004918: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
<== NOT EXECUTED
4000491c: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
40004920: 90 10 20 00 clr %o0
<== NOT EXECUTED
40004924: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004928: 12 80 00 07 bne 40004944 <IMFS_readlink+0x38>
<== NOT EXECUTED
4000492c: c2 08 40 00 ldub [ %g1 ], %g1
<== NOT EXECUTED
40004930: 30 80 00 0c b,a 40004960 <IMFS_readlink+0x54>
<== NOT EXECUTED
40004934: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
<== NOT EXECUTED
40004938: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000493c: 02 80 00 07 be 40004958 <IMFS_readlink+0x4c>
<== NOT EXECUTED
40004940: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
<== NOT EXECUTED
buf[i] = sym_link->name[i];
40004944: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004948: 90 02 20 01 inc %o0
<== NOT EXECUTED
4000494c: 80 a2 80 08 cmp %o2, %o0
<== NOT EXECUTED
40004950: 32 bf ff f9 bne,a 40004934 <IMFS_readlink+0x28>
<== NOT EXECUTED
40004954: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
<== NOT EXECUTED
}
40004958: 81 c3 e0 08 retl
<== NOT EXECUTED
4000495c: 01 00 00 00 nop
<== NOT EXECUTED
40004960: 81 c3 e0 08 retl
<== NOT EXECUTED
40004964: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004968: 81 c3 e0 08 retl
<== NOT EXECUTED
4000496c: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
40004670 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
40004670: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *node = oldloc->node_access;
40004674: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent == NULL ) {
40004678: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4000467c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40004680: 02 80 00 36 be 40004758 <IMFS_rename+0xe8>
<== NOT EXECUTED
40004684: f4 06 a0 08 ld [ %i2 + 8 ], %i2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
40004688: 80 a7 20 fe cmp %i4, 0xfe
<== NOT EXECUTED
4000468c: 18 80 00 27 bgu 40004728 <IMFS_rename+0xb8>
<== NOT EXECUTED
40004690: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
allocated_name = malloc( namelen );
40004694: 40 00 02 3c call 40004f84 <malloc>
<== NOT EXECUTED
40004698: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if ( allocated_name == NULL ) {
4000469c: b2 92 20 00 orcc %o0, 0, %i1
<== NOT EXECUTED
400046a0: 02 80 00 28 be 40004740 <IMFS_rename+0xd0>
<== NOT EXECUTED
400046a4: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( allocated_name, name, namelen );
400046a8: 40 00 2c 19 call 4000f70c <memcpy>
<== NOT EXECUTED
400046ac: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
400046b0: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
400046b4: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
400046b8: 12 80 00 18 bne 40004718 <IMFS_rename+0xa8>
<== NOT EXECUTED
400046bc: 01 00 00 00 nop
<== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400046c0: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
400046c4: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
}
node->name = allocated_name;
400046c8: f2 27 60 0c st %i1, [ %i5 + 0xc ]
<== NOT EXECUTED
node->namelen = namelen;
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
400046cc: 82 10 60 01 or %g1, 1, %g1
<== NOT EXECUTED
node->namelen = namelen;
400046d0: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
400046d4: 88 06 a0 44 add %i2, 0x44, %g4
<== NOT EXECUTED
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
400046d8: c2 37 60 12 sth %g1, [ %i5 + 0x12 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
400046dc: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
next->previous = previous;
400046e0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
400046e4: b0 10 20 00 clr %i0
<== NOT EXECUTED
previous->next = next;
400046e8: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
Chain_Node *old_last;
_Assert( _Chain_Is_node_off_chain( the_node ) );
tail = _Chain_Tail( the_chain );
old_last = tail->previous;
400046ec: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
<== NOT EXECUTED
entry_node->Parent = dir_node;
400046f0: f4 27 60 08 st %i2, [ %i5 + 8 ]
<== NOT EXECUTED
the_node->next = tail;
400046f4: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
400046f8: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
<== NOT EXECUTED
old_last->next = the_node;
400046fc: fa 20 40 00 st %i5, [ %g1 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40004700: 40 00 12 5a call 40009068 <_Timecounter_Getbintime>
<== NOT EXECUTED
40004704: c2 27 60 04 st %g1, [ %i5 + 4 ]
<== NOT EXECUTED
return now.sec;
40004708: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
4000470c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
40004710: 81 c7 e0 08 ret
<== NOT EXECUTED
40004714: 81 e8 00 00 restore
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
40004718: 40 00 01 0c call 40004b48 <free>
<== NOT EXECUTED
4000471c: d0 07 60 0c ld [ %i5 + 0xc ], %o0
<== NOT EXECUTED
40004720: 10 bf ff e8 b 400046c0 <IMFS_rename+0x50>
<== NOT EXECUTED
40004724: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40004728: 40 00 2b 6c call 4000f4d8 <__errno>
<== NOT EXECUTED
4000472c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004730: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40004734: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004738: 81 c7 e0 08 ret
<== NOT EXECUTED
4000473c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40004740: 40 00 2b 66 call 4000f4d8 <__errno>
<== NOT EXECUTED
40004744: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004748: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
4000474c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004750: 81 c7 e0 08 ret
<== NOT EXECUTED
40004754: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40004758: 40 00 2b 60 call 4000f4d8 <__errno>
<== NOT EXECUTED
4000475c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004760: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004764: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004768: 81 c7 e0 08 ret
<== NOT EXECUTED
4000476c: 81 e8 00 00 restore
<== NOT EXECUTED
40004770 <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
40004770: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
40004774: d0 06 60 08 ld [ %i1 + 8 ], %o0
node = (*node->control->node_remove)( node );
40004778: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000477c: c2 00 60 08 ld [ %g1 + 8 ], %g1
40004780: 9f c0 40 00 call %g1
40004784: 01 00 00 00 nop
if ( node != NULL ) {
40004788: 80 a2 20 00 cmp %o0, 0
4000478c: 22 80 00 11 be,a 400047d0 <IMFS_rmnod+0x60>
<== NEVER TAKEN
40004790: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
--node->reference_count;
40004794: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
40004798: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
4000479c: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
400047a0: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
400047a4: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
400047a8: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
400047ac: c2 02 20 08 ld [ %o0 + 8 ], %g1
400047b0: 80 a0 60 00 cmp %g1, 0
400047b4: 02 80 00 07 be 400047d0 <IMFS_rmnod+0x60>
<== NEVER TAKEN
400047b8: b0 10 20 00 clr %i0
node->Parent = NULL;
400047bc: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
400047c0: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
400047c4: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
400047c8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
400047cc: c4 20 40 00 st %g2, [ %g1 ]
400047d0: 81 c7 e0 08 ret
400047d4: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
400047d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400047dc: 81 e8 00 00 restore
<== NOT EXECUTED
400048a8 <IMFS_symlink>:
{
400048a8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
sizeof( IMFS_sym_link_t ) + strlen( target ) + 1,
400048ac: 40 00 2c ba call 4000fb94 <strlen>
<== NOT EXECUTED
400048b0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
new_node = IMFS_create_node(
400048b4: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
<== NOT EXECUTED
400048b8: 94 02 20 49 add %o0, 0x49, %o2
<== NOT EXECUTED
400048bc: 98 10 00 1a mov %i2, %o4
<== NOT EXECUTED
400048c0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400048c4: 1b 00 00 28 sethi %hi(0xa000), %o5
<== NOT EXECUTED
400048c8: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400048cc: 9a 13 61 ff or %o5, 0x1ff, %o5
<== NOT EXECUTED
400048d0: 13 10 00 44 sethi %hi(0x40011000), %o1
<== NOT EXECUTED
return 0;
400048d4: b0 10 20 00 clr %i0
<== NOT EXECUTED
new_node = IMFS_create_node(
400048d8: 40 00 25 64 call 4000de68 <IMFS_create_node>
<== NOT EXECUTED
400048dc: 92 12 61 ac or %o1, 0x1ac, %o1
<== NOT EXECUTED
if ( new_node == NULL ) {
400048e0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400048e4: 02 80 00 04 be 400048f4 <IMFS_symlink+0x4c>
<== NOT EXECUTED
400048e8: 01 00 00 00 nop
<== NOT EXECUTED
}
400048ec: 81 c7 e0 08 ret
<== NOT EXECUTED
400048f0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
400048f4: 40 00 2a f9 call 4000f4d8 <__errno>
<== NOT EXECUTED
400048f8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400048fc: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004900: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40004904: 81 c7 e0 08 ret
<== NOT EXECUTED
40004908: 81 e8 00 00 restore
<== NOT EXECUTED
40004970 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40004970: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004974: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
40004978: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
4000497c: 07 00 00 3c sethi %hi(0xf000), %g3
<== NOT EXECUTED
40004980: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
40004984: 82 08 40 03 and %g1, %g3, %g1
<== NOT EXECUTED
if ( IMFS_is_directory( node ) ) {
40004988: 07 00 00 10 sethi %hi(0x4000), %g3
<== NOT EXECUTED
4000498c: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40004990: 12 80 00 0f bne 400049cc <IMFS_unmount+0x5c>
<== NOT EXECUTED
40004994: 01 00 00 00 nop
<== NOT EXECUTED
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
40004998: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
<== NOT EXECUTED
4000499c: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
400049a0: 12 80 00 05 bne 400049b4 <IMFS_unmount+0x44>
<== NOT EXECUTED
400049a4: 01 00 00 00 nop
<== NOT EXECUTED
dir->mt_fs = NULL;
400049a8: c0 20 a0 4c clr [ %g2 + 0x4c ]
<== NOT EXECUTED
400049ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400049b0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
} else {
errno = EINVAL;
400049b4: 40 00 2a c9 call 4000f4d8 <__errno>
<== NOT EXECUTED
400049b8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400049bc: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400049c0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400049c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400049c8: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
400049cc: 40 00 2a c3 call 4000f4d8 <__errno>
<== NOT EXECUTED
400049d0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400049d4: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
400049d8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
400049dc: 81 c7 e0 08 ret
<== NOT EXECUTED
400049e0: 81 e8 00 00 restore
<== NOT EXECUTED
400049e4 <IMFS_utime>:
int IMFS_utime(
const rtems_filesystem_location_info_t *loc,
time_t actime,
time_t modtime
)
{
400049e4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) loc->node_access;
400049e8: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
{
400049ec: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
400049f0: b0 10 00 19 mov %i1, %i0
<== NOT EXECUTED
400049f4: 86 10 00 1c mov %i4, %g3
<== NOT EXECUTED
400049f8: b2 10 00 1a mov %i2, %i1
<== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
400049fc: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004a00: 90 10 20 00 clr %o0
<== NOT EXECUTED
the_jnode->stat_atime = actime;
40004a04: f0 3f 60 20 std %i0, [ %i5 + 0x20 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004a08: 40 00 2c 93 call 4000fc54 <time>
<== NOT EXECUTED
40004a0c: b0 10 20 00 clr %i0
<== NOT EXECUTED
40004a10: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
<== NOT EXECUTED
return 0;
}
40004a14: 81 c7 e0 08 ret
<== NOT EXECUTED
40004a18: 81 e8 00 00 restore
<== NOT EXECUTED
4000de00 <device_close>:
}
int device_close(
rtems_libio_t *iop
)
{
4000de00: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_close(
4000de04: d4 00 60 44 ld [ %g1 + 0x44 ], %o2
<== NOT EXECUTED
4000de08: d2 00 60 40 ld [ %g1 + 0x40 ], %o1
<== NOT EXECUTED
4000de0c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000de10: 40 00 01 a4 call 4000e4a0 <rtems_deviceio_close>
<== NOT EXECUTED
4000de14: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000de60 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4000de60: 81 c3 e0 08 retl
<== NOT EXECUTED
4000de64: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000de48 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
ioctl_command_t command,
void *buffer
)
{
4000de48: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_control(
4000de4c: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000de50: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000de54: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000de58: 40 00 01 d6 call 4000e5b0 <rtems_deviceio_control>
<== NOT EXECUTED
4000de5c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000ddec <device_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
4000ddec: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_open(
4000ddf0: d8 18 60 40 ldd [ %g1 + 0x40 ], %o4
<== NOT EXECUTED
4000ddf4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000ddf8: 40 00 01 9d call 4000e46c <rtems_deviceio_open>
<== NOT EXECUTED
4000ddfc: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000de18 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000de18: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_read(
4000de1c: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000de20: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000de24: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000de28: 40 00 01 aa call 4000e4d0 <rtems_deviceio_read>
<== NOT EXECUTED
4000de2c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000de30 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000de30: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_write(
4000de34: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000de38: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000de3c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000de40: 40 00 01 c0 call 4000e540 <rtems_deviceio_write>
<== NOT EXECUTED
4000de44: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d6c8 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d6c8: 9d e3 bf 98 save %sp, -104, %sp
_Mutex_Acquire( mutex );
4000d6cc: 37 10 00 52 sethi %hi(0x40014800), %i3
4000d6d0: 7f ff ed 00 call 40008ad0 <_Mutex_Acquire>
4000d6d4: 90 16 e2 a0 or %i3, 0x2a0, %o0 ! 40014aa0 <pipe_mutex>
pipe = *pipep;
4000d6d8: fa 06 00 00 ld [ %i0 ], %i5
if (pipe == NULL) {
4000d6dc: 80 a7 60 00 cmp %i5, 0
4000d6e0: 02 80 00 1a be 4000d748 <fifo_open+0x80>
4000d6e4: b8 10 00 18 mov %i0, %i4
4000d6e8: 7f ff ec fa call 40008ad0 <_Mutex_Acquire>
4000d6ec: 90 07 60 28 add %i5, 0x28, %o0
if (*pipep == NULL) {
4000d6f0: c2 07 00 00 ld [ %i4 ], %g1
4000d6f4: 80 a0 60 00 cmp %g1, 0
4000d6f8: 22 80 00 4c be,a 4000d828 <fifo_open+0x160>
4000d6fc: fa 27 00 00 st %i5, [ %i4 ]
_Mutex_Release( mutex );
4000d700: 7f ff ed 10 call 40008b40 <_Mutex_Release>
4000d704: 90 16 e2 a0 or %i3, 0x2a0, %o0
4000d708: c2 06 60 08 ld [ %i1 + 8 ], %g1
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
4000d70c: fa 07 00 00 ld [ %i4 ], %i5
switch (LIBIO_ACCMODE(iop)) {
4000d710: 82 08 60 06 and %g1, 6, %g1
4000d714: 80 a0 60 04 cmp %g1, 4
4000d718: 02 80 00 4c be 4000d848 <fifo_open+0x180>
4000d71c: b6 07 60 28 add %i5, 0x28, %i3
4000d720: 80 a0 60 06 cmp %g1, 6
4000d724: 02 80 00 97 be 4000d980 <fifo_open+0x2b8>
4000d728: 80 a0 60 02 cmp %g1, 2
4000d72c: 22 80 00 74 be,a 4000d8fc <fifo_open+0x234>
<== ALWAYS TAKEN
4000d730: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
return 0;
4000d734: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d738: 7f ff ed 02 call 40008b40 <_Mutex_Release>
4000d73c: 90 10 00 1b mov %i3, %o0
4000d740: 81 c7 e0 08 ret
4000d744: 81 e8 00 00 restore
pipe = malloc(sizeof(pipe_control_t));
4000d748: 7f ff de 28 call 40004fe8 <malloc>
4000d74c: 90 10 20 44 mov 0x44, %o0
if (pipe == NULL)
4000d750: ba 92 20 00 orcc %o0, 0, %i5
4000d754: 02 80 00 be be 4000da4c <fifo_open+0x384>
<== NEVER TAKEN
4000d758: 94 10 20 3c mov 0x3c, %o2
memset(pipe, 0, sizeof(pipe_control_t));
4000d75c: 92 10 20 00 clr %o1
4000d760: 40 00 0a cf call 4001029c <memset>
4000d764: 90 07 60 08 add %i5, 8, %o0
pipe->Size = PIPE_BUF;
4000d768: 82 10 22 00 mov 0x200, %g1
4000d76c: c2 27 60 04 st %g1, [ %i5 + 4 ]
pipe->Buffer = malloc(pipe->Size);
4000d770: 7f ff de 1e call 40004fe8 <malloc>
4000d774: 90 10 22 00 mov 0x200, %o0
if (! pipe->Buffer)
4000d778: 80 a2 20 00 cmp %o0, 0
4000d77c: 02 80 00 ad be 4000da30 <fifo_open+0x368>
<== NEVER TAKEN
4000d780: d0 27 40 00 st %o0, [ %i5 ]
rtems_build_name ('P', 'I', 'r', c),
4000d784: 35 10 00 52 sethi %hi(0x40014800), %i2
if (rtems_barrier_create(
4000d788: 03 14 12 5c sethi %hi(0x50497000), %g1
rtems_build_name ('P', 'I', 'r', c),
4000d78c: d0 4e a2 9c ldsb [ %i2 + 0x29c ], %o0
if (rtems_barrier_create(
4000d790: 82 10 62 00 or %g1, 0x200, %g1
4000d794: 96 07 60 3c add %i5, 0x3c, %o3
4000d798: 94 10 20 00 clr %o2
4000d79c: 92 10 20 00 clr %o1
4000d7a0: 7f ff e4 80 call 400069a0 <rtems_barrier_create>
4000d7a4: 90 12 00 01 or %o0, %g1, %o0
4000d7a8: 80 a2 20 00 cmp %o0, 0
4000d7ac: 12 80 00 9f bne 4000da28 <fifo_open+0x360>
4000d7b0: d0 4e a2 9c ldsb [ %i2 + 0x29c ], %o0
if (rtems_barrier_create(
4000d7b4: 03 14 12 5d sethi %hi(0x50497400), %g1
4000d7b8: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000d7bc: 96 07 60 40 add %i5, 0x40, %o3
4000d7c0: 94 10 20 00 clr %o2
4000d7c4: 92 10 20 00 clr %o1
4000d7c8: 7f ff e4 76 call 400069a0 <rtems_barrier_create>
4000d7cc: 90 12 00 01 or %o0, %g1, %o0
4000d7d0: 80 a2 20 00 cmp %o0, 0
4000d7d4: 12 80 00 93 bne 4000da20 <fifo_open+0x358>
4000d7d8: 03 10 00 4b sethi %hi(0x40012c00), %g1
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
4000d7dc: c0 27 60 28 clr [ %i5 + 0x28 ]
4000d7e0: 82 10 60 18 or %g1, 0x18, %g1
4000d7e4: c0 27 60 2c clr [ %i5 + 0x2c ]
4000d7e8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
4000d7ec: c0 27 60 30 clr [ %i5 + 0x30 ]
4000d7f0: c0 27 60 34 clr [ %i5 + 0x34 ]
if (c ++ == 'z')
4000d7f4: c4 4e a2 9c ldsb [ %i2 + 0x29c ], %g2
4000d7f8: 80 a0 a0 7a cmp %g2, 0x7a
4000d7fc: 02 80 00 3d be 4000d8f0 <fifo_open+0x228>
4000d800: c2 0e a2 9c ldub [ %i2 + 0x29c ], %g1
4000d804: 82 00 60 01 inc %g1
_Mutex_Acquire( mutex );
4000d808: 90 07 60 28 add %i5, 0x28, %o0
4000d80c: 7f ff ec b1 call 40008ad0 <_Mutex_Acquire>
4000d810: c2 2e a2 9c stb %g1, [ %i2 + 0x29c ]
if (*pipep == NULL) {
4000d814: c2 07 00 00 ld [ %i4 ], %g1
4000d818: 80 a0 60 00 cmp %g1, 0
4000d81c: 12 bf ff b9 bne 4000d700 <fifo_open+0x38>
<== NEVER TAKEN
4000d820: 01 00 00 00 nop
*pipep = pipe;
4000d824: fa 27 00 00 st %i5, [ %i4 ]
_Mutex_Release( mutex );
4000d828: 7f ff ec c6 call 40008b40 <_Mutex_Release>
4000d82c: 90 16 e2 a0 or %i3, 0x2a0, %o0
4000d830: c2 06 60 08 ld [ %i1 + 8 ], %g1
pipe = *pipep;
4000d834: fa 07 00 00 ld [ %i4 ], %i5
switch (LIBIO_ACCMODE(iop)) {
4000d838: 82 08 60 06 and %g1, 6, %g1
4000d83c: 80 a0 60 04 cmp %g1, 4
4000d840: 12 bf ff b8 bne 4000d720 <fifo_open+0x58>
4000d844: b6 07 60 28 add %i5, 0x28, %i3
if (pipe->Writers ++ == 0)
4000d848: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
pipe->writerCounter ++;
4000d84c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d850: 82 00 60 01 inc %g1
if (pipe->Writers ++ == 0)
4000d854: 86 00 a0 01 add %g2, 1, %g3
pipe->writerCounter ++;
4000d858: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000d85c: 80 a0 a0 00 cmp %g2, 0
4000d860: 02 80 00 61 be 4000d9e4 <fifo_open+0x31c>
<== ALWAYS TAKEN
4000d864: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000d868: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000d86c: 80 a0 60 00 cmp %g1, 0
4000d870: 12 bf ff b2 bne 4000d738 <fifo_open+0x70>
4000d874: b0 10 20 00 clr %i0
4000d878: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000d87c: 80 88 60 01 btst 1, %g1
4000d880: 32 80 00 55 bne,a 4000d9d4 <fifo_open+0x30c>
4000d884: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
4000d888: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d88c: 80 a0 60 00 cmp %g1, 0
4000d890: 12 bf ff aa bne 4000d738 <fifo_open+0x70>
<== NEVER TAKEN
4000d894: b0 10 20 00 clr %i0
prevCounter = pipe->readerCounter;
4000d898: 10 80 00 08 b 4000d8b8 <fifo_open+0x1f0>
4000d89c: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
_Mutex_Acquire( mutex );
4000d8a0: 7f ff ec 8c call 40008ad0 <_Mutex_Acquire>
4000d8a4: 01 00 00 00 nop
} while (prevCounter == pipe->readerCounter);
4000d8a8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d8ac: 80 a0 40 1a cmp %g1, %i2
4000d8b0: 12 bf ff a2 bne 4000d738 <fifo_open+0x70>
<== ALWAYS TAKEN
4000d8b4: b0 10 20 00 clr %i0
_Mutex_Release( mutex );
4000d8b8: 7f ff ec a2 call 40008b40 <_Mutex_Release>
4000d8bc: 90 10 00 1b mov %i3, %o0
if (! PIPE_WRITEWAIT(pipe))
4000d8c0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000d8c4: 40 00 03 75 call 4000e698 <rtems_barrier_wait>
4000d8c8: 92 10 20 00 clr %o1
4000d8cc: 80 a2 20 00 cmp %o0, 0
4000d8d0: 02 bf ff f4 be 4000d8a0 <fifo_open+0x1d8>
<== ALWAYS TAKEN
4000d8d4: 90 10 00 1b mov %i3, %o0
err = -EINTR;
4000d8d8: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
4000d8dc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000d8e0: 7f ff ff 3a call 4000d5c8 <pipe_release>
4000d8e4: 90 10 00 1c mov %i4, %o0
return err;
4000d8e8: 81 c7 e0 08 ret
4000d8ec: 81 e8 00 00 restore
c = 'a';
4000d8f0: 82 10 20 61 mov 0x61, %g1
4000d8f4: 10 bf ff 7d b 4000d6e8 <fifo_open+0x20>
4000d8f8: c2 2e a2 9c stb %g1, [ %i2 + 0x29c ]
pipe->readerCounter ++;
4000d8fc: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d900: 82 00 60 01 inc %g1
if (pipe->Readers ++ == 0)
4000d904: 86 00 a0 01 add %g2, 1, %g3
pipe->readerCounter ++;
4000d908: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000d90c: 80 a0 a0 00 cmp %g2, 0
4000d910: 02 80 00 3a be 4000d9f8 <fifo_open+0x330>
<== ALWAYS TAKEN
4000d914: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
if (pipe->Writers == 0) {
4000d918: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000d91c: 80 a0 60 00 cmp %g1, 0
4000d920: 12 bf ff 86 bne 4000d738 <fifo_open+0x70>
4000d924: b0 10 20 00 clr %i0
4000d928: c2 06 60 08 ld [ %i1 + 8 ], %g1
if (LIBIO_NODELAY(iop))
4000d92c: 80 88 60 01 btst 1, %g1
4000d930: 12 bf ff 82 bne 4000d738 <fifo_open+0x70>
4000d934: b0 10 20 00 clr %i0
prevCounter = pipe->writerCounter;
4000d938: 10 80 00 08 b 4000d958 <fifo_open+0x290>
4000d93c: f4 07 60 24 ld [ %i5 + 0x24 ], %i2
_Mutex_Acquire( mutex );
4000d940: 7f ff ec 64 call 40008ad0 <_Mutex_Acquire>
4000d944: 01 00 00 00 nop
} while (prevCounter == pipe->writerCounter);
4000d948: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d94c: 80 a0 40 1a cmp %g1, %i2
4000d950: 12 bf ff 7a bne 4000d738 <fifo_open+0x70>
<== ALWAYS TAKEN
4000d954: b0 10 20 00 clr %i0
_Mutex_Release( mutex );
4000d958: 7f ff ec 7a call 40008b40 <_Mutex_Release>
4000d95c: 90 10 00 1b mov %i3, %o0
if (! PIPE_READWAIT(pipe))
4000d960: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000d964: 40 00 03 4d call 4000e698 <rtems_barrier_wait>
4000d968: 92 10 20 00 clr %o1
4000d96c: 80 a2 20 00 cmp %o0, 0
4000d970: 02 bf ff f4 be 4000d940 <fifo_open+0x278>
<== ALWAYS TAKEN
4000d974: 90 10 00 1b mov %i3, %o0
out_error:
4000d978: 10 bf ff d9 b 4000d8dc <fifo_open+0x214>
<== NOT EXECUTED
4000d97c: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
if (pipe->Readers ++ == 0)
4000d980: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
pipe->readerCounter ++;
4000d984: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d988: 82 00 60 01 inc %g1
if (pipe->Readers ++ == 0)
4000d98c: 86 00 a0 01 add %g2, 1, %g3
pipe->readerCounter ++;
4000d990: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000d994: 80 a0 a0 00 cmp %g2, 0
4000d998: 02 80 00 1d be 4000da0c <fifo_open+0x344>
<== ALWAYS TAKEN
4000d99c: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
if (pipe->Writers ++ == 0)
4000d9a0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
pipe->writerCounter ++;
4000d9a4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d9a8: 82 00 60 01 inc %g1
if (pipe->Writers ++ == 0)
4000d9ac: 86 00 a0 01 add %g2, 1, %g3
pipe->writerCounter ++;
4000d9b0: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000d9b4: 80 a0 a0 00 cmp %g2, 0
4000d9b8: 12 bf ff 5f bne 4000d734 <fifo_open+0x6c>
<== NEVER TAKEN
4000d9bc: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
4000d9c0: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000d9c4: 40 00 03 20 call 4000e644 <rtems_barrier_release>
4000d9c8: 92 07 bf fc add %fp, -4, %o1
return 0;
4000d9cc: 10 bf ff 5b b 4000d738 <fifo_open+0x70>
4000d9d0: b0 10 20 00 clr %i0
4000d9d4: 7f ff ec 5b call 40008b40 <_Mutex_Release>
4000d9d8: b0 10 3f fa mov -6, %i0
goto out_error;
4000d9dc: 10 bf ff c1 b 4000d8e0 <fifo_open+0x218>
4000d9e0: 92 10 00 19 mov %i1, %o1
PIPE_WAKEUPREADERS(pipe);
4000d9e4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000d9e8: 40 00 03 17 call 4000e644 <rtems_barrier_release>
4000d9ec: 92 07 bf fc add %fp, -4, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000d9f0: 10 bf ff 9f b 4000d86c <fifo_open+0x1a4>
4000d9f4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
PIPE_WAKEUPWRITERS(pipe);
4000d9f8: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000d9fc: 40 00 03 12 call 4000e644 <rtems_barrier_release>
4000da00: 92 07 bf fc add %fp, -4, %o1
if (pipe->Writers == 0) {
4000da04: 10 bf ff c6 b 4000d91c <fifo_open+0x254>
4000da08: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
PIPE_WAKEUPWRITERS(pipe);
4000da0c: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000da10: 40 00 03 0d call 4000e644 <rtems_barrier_release>
4000da14: 92 07 bf fc add %fp, -4, %o1
if (pipe->Writers ++ == 0)
4000da18: 10 bf ff e3 b 4000d9a4 <fifo_open+0x2dc>
4000da1c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
rtems_barrier_delete(pipe->readBarrier);
4000da20: 7f ff e4 0c call 40006a50 <rtems_barrier_delete>
4000da24: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
free(pipe->Buffer);
4000da28: 7f ff dc 27 call 40004ac4 <free>
4000da2c: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000da30: 7f ff dc 25 call 40004ac4 <free>
4000da34: 90 10 00 1d mov %i5, %o0
return err;
4000da38: b0 10 3f f4 mov -12, %i0
4000da3c: 7f ff ec 41 call 40008b40 <_Mutex_Release>
4000da40: 90 16 e2 a0 or %i3, 0x2a0, %o0
4000da44: 81 c7 e0 08 ret
4000da48: 81 e8 00 00 restore
return err;
4000da4c: b0 10 3f f4 mov -12, %i0
<== NOT EXECUTED
4000da50: 7f ff ec 3c call 40008b40 <_Mutex_Release>
<== NOT EXECUTED
4000da54: 90 16 e2 a0 or %i3, 0x2a0, %o0
<== NOT EXECUTED
}
4000da58: 81 c7 e0 08 ret
<== NOT EXECUTED
4000da5c: 81 e8 00 00 restore
<== NOT EXECUTED
4000da60 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000da60: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
PIPE_LOCK(pipe);
4000da64: b8 06 20 28 add %i0, 0x28, %i4
_Mutex_Acquire( mutex );
4000da68: 7f ff ec 1a call 40008ad0 <_Mutex_Acquire>
4000da6c: 90 10 00 1c mov %i4, %o0
while (PIPE_EMPTY(pipe)) {
4000da70: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000da74: 80 a0 60 00 cmp %g1, 0
4000da78: 12 80 00 27 bne 4000db14 <pipe_read+0xb4>
4000da7c: ba 10 00 18 mov %i0, %i5
/* Not an error */
if (pipe->Writers == 0)
4000da80: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000da84: 80 a0 60 00 cmp %g1, 0
4000da88: 22 80 00 16 be,a 4000dae0 <pipe_read+0x80>
4000da8c: b0 10 20 00 clr %i0
4000da90: c2 06 e0 08 ld [ %i3 + 8 ], %g1
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000da94: 80 88 60 01 btst 1, %g1
4000da98: 32 80 00 12 bne,a 4000dae0 <pipe_read+0x80>
4000da9c: b0 10 3f f5 mov -11, %i0
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
4000daa0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000daa4: 82 00 60 01 inc %g1
4000daa8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_Mutex_Release( mutex );
4000daac: 7f ff ec 25 call 40008b40 <_Mutex_Release>
4000dab0: 90 10 00 1c mov %i4, %o0
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
4000dab4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000dab8: 40 00 02 f8 call 4000e698 <rtems_barrier_wait>
4000dabc: 92 10 20 00 clr %o1
4000dac0: 80 a2 20 00 cmp %o0, 0
4000dac4: 02 80 00 0b be 4000daf0 <pipe_read+0x90>
<== ALWAYS TAKEN
4000dac8: 90 10 00 1c mov %i4, %o0
_Mutex_Acquire( mutex );
4000dacc: 7f ff ec 01 call 40008ad0 <_Mutex_Acquire>
<== NOT EXECUTED
4000dad0: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
ret = -EINTR;
PIPE_LOCK(pipe);
pipe->waitingReaders --;
4000dad4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
4000dad8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dadc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dae0: 7f ff ec 18 call 40008b40 <_Mutex_Release>
4000dae4: 90 10 00 1c mov %i4, %o0
PIPE_UNLOCK(pipe);
if (read > 0)
return read;
return ret;
}
4000dae8: 81 c7 e0 08 ret
4000daec: 81 e8 00 00 restore
_Mutex_Acquire( mutex );
4000daf0: 7f ff eb f8 call 40008ad0 <_Mutex_Acquire>
4000daf4: 01 00 00 00 nop
pipe->waitingReaders --;
4000daf8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000dafc: 82 00 7f ff add %g1, -1, %g1
4000db00: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
while (PIPE_EMPTY(pipe)) {
4000db04: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000db08: 80 a0 60 00 cmp %g1, 0
4000db0c: 22 bf ff de be,a 4000da84 <pipe_read+0x24>
<== NEVER TAKEN
4000db10: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
chunk = MIN(count - read, pipe->Length);
4000db14: 80 a6 80 01 cmp %i2, %g1
4000db18: 38 80 00 33 bgu,a 4000dbe4 <pipe_read+0x184>
<== NEVER TAKEN
4000db1c: b4 10 00 01 mov %g1, %i2
<== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
4000db20: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000db24: f6 07 60 04 ld [ %i5 + 4 ], %i3
4000db28: d2 07 40 00 ld [ %i5 ], %o1
4000db2c: b6 26 c0 01 sub %i3, %g1, %i3
if (chunk > chunk1) {
4000db30: 80 a6 80 1b cmp %i2, %i3
4000db34: 14 80 00 23 bg 4000dbc0 <pipe_read+0x160>
4000db38: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000db3c: 94 10 00 1a mov %i2, %o2
4000db40: 40 00 09 9b call 400101ac <memcpy>
4000db44: 90 10 00 19 mov %i1, %o0
pipe->Start += chunk;
4000db48: c2 07 60 08 ld [ %i5 + 8 ], %g1
pipe->Length -= chunk;
4000db4c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
pipe->Start %= pipe->Size;
4000db50: c8 07 60 04 ld [ %i5 + 4 ], %g4
pipe->Start += chunk;
4000db54: 82 06 80 01 add %i2, %g1, %g1
pipe->Length -= chunk;
4000db58: 84 20 80 1a sub %g2, %i2, %g2
pipe->Start %= pipe->Size;
4000db5c: 81 80 20 00 wr %g0, %y
4000db60: 01 00 00 00 nop
4000db64: 01 00 00 00 nop
4000db68: 01 00 00 00 nop
4000db6c: 86 70 40 04 udiv %g1, %g4, %g3
pipe->Length -= chunk;
4000db70: c4 27 60 0c st %g2, [ %i5 + 0xc ]
pipe->Start %= pipe->Size;
4000db74: 86 58 c0 04 smul %g3, %g4, %g3
4000db78: 82 20 40 03 sub %g1, %g3, %g1
if (PIPE_EMPTY(pipe))
4000db7c: 80 a0 a0 00 cmp %g2, 0
4000db80: 12 80 00 03 bne 4000db8c <pipe_read+0x12c>
4000db84: c2 27 60 08 st %g1, [ %i5 + 8 ]
pipe->Start = 0;
4000db88: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
4000db8c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000db90: 80 a0 60 00 cmp %g1, 0
4000db94: 32 80 00 1d bne,a 4000dc08 <pipe_read+0x1a8>
4000db98: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
_Mutex_Release( mutex );
4000db9c: 7f ff eb e9 call 40008b40 <_Mutex_Release>
4000dba0: 90 10 00 1c mov %i4, %o0
4000dba4: b0 96 a0 00 orcc %i2, 0, %i0
4000dba8: 16 bf ff d0 bge 4000dae8 <pipe_read+0x88>
<== ALWAYS TAKEN
4000dbac: 01 00 00 00 nop
4000dbb0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dbb4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
ret = -EAGAIN;
4000dbb8: 10 bf ff ca b 4000dae0 <pipe_read+0x80>
<== NOT EXECUTED
4000dbbc: b0 10 3f f5 mov -11, %i0
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000dbc0: 94 10 00 1b mov %i3, %o2
4000dbc4: 40 00 09 7a call 400101ac <memcpy>
4000dbc8: 90 10 00 19 mov %i1, %o0
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000dbcc: d2 07 40 00 ld [ %i5 ], %o1
4000dbd0: 94 26 80 1b sub %i2, %i3, %o2
4000dbd4: 40 00 09 76 call 400101ac <memcpy>
4000dbd8: 90 06 40 1b add %i1, %i3, %o0
4000dbdc: 10 bf ff dc b 4000db4c <pipe_read+0xec>
4000dbe0: c2 07 60 08 ld [ %i5 + 8 ], %g1
chunk1 = pipe->Size - pipe->Start;
4000dbe4: f6 07 60 04 ld [ %i5 + 4 ], %i3
<== NOT EXECUTED
4000dbe8: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4000dbec: d2 07 40 00 ld [ %i5 ], %o1
<== NOT EXECUTED
4000dbf0: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
if (chunk > chunk1) {
4000dbf4: 80 a6 80 1b cmp %i2, %i3
<== NOT EXECUTED
4000dbf8: 04 bf ff d1 ble 4000db3c <pipe_read+0xdc>
<== NOT EXECUTED
4000dbfc: 92 02 40 01 add %o1, %g1, %o1
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000dc00: 10 bf ff f1 b 4000dbc4 <pipe_read+0x164>
<== NOT EXECUTED
4000dc04: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
4000dc08: 40 00 02 8f call 4000e644 <rtems_barrier_release>
4000dc0c: 92 07 bf fc add %fp, -4, %o1
4000dc10: 30 bf ff e3 b,a 4000db9c <pipe_read+0x13c>
4000d5c8 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d5c8: 9d e3 bf 98 save %sp, -104, %sp
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
4000d5cc: 39 10 00 52 sethi %hi(0x40014800), %i4
pipe_control_t *pipe = *pipep;
4000d5d0: fa 06 00 00 ld [ %i0 ], %i5
4000d5d4: 7f ff ed 3f call 40008ad0 <_Mutex_Acquire>
4000d5d8: 90 17 22 a0 or %i4, 0x2a0, %o0
uint32_t mode;
pipe_lock();
PIPE_LOCK(pipe);
4000d5dc: b6 07 60 28 add %i5, 0x28, %i3
4000d5e0: 7f ff ed 3c call 40008ad0 <_Mutex_Acquire>
4000d5e4: 90 10 00 1b mov %i3, %o0
4000d5e8: c2 06 60 08 ld [ %i1 + 8 ], %g1
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
4000d5ec: 80 88 60 02 btst 2, %g1
4000d5f0: 02 80 00 05 be 4000d604 <pipe_release+0x3c>
4000d5f4: b4 08 60 06 and %g1, 6, %i2
pipe->Readers --;
4000d5f8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000d5fc: 84 00 bf ff add %g2, -1, %g2
4000d600: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000d604: 80 88 60 04 btst 4, %g1
4000d608: 02 80 00 05 be 4000d61c <pipe_release+0x54>
4000d60c: 01 00 00 00 nop
pipe->Writers --;
4000d610: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000d614: 82 00 7f ff add %g1, -1, %g1
4000d618: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
}
static __inline void rtems_mutex_unlock( rtems_mutex *mutex )
{
_Mutex_Release( mutex );
4000d61c: 7f ff ed 49 call 40008b40 <_Mutex_Release>
4000d620: 90 10 00 1b mov %i3, %o0
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000d624: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d628: 80 a0 60 00 cmp %g1, 0
4000d62c: 02 80 00 0e be 4000d664 <pipe_release+0x9c>
4000d630: 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)
4000d634: 80 a0 60 00 cmp %g1, 0
4000d638: 12 80 00 07 bne 4000d654 <pipe_release+0x8c>
<== NEVER TAKEN
4000d63c: 80 a6 a0 02 cmp %i2, 2
4000d640: 02 80 00 05 be 4000d654 <pipe_release+0x8c>
<== NEVER TAKEN
4000d644: 01 00 00 00 nop
PIPE_WAKEUPREADERS(pipe);
4000d648: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000d64c: 40 00 03 fe call 4000e644 <rtems_barrier_release>
4000d650: 92 07 bf fc add %fp, -4, %o1
4000d654: 7f ff ed 3b call 40008b40 <_Mutex_Release>
4000d658: 90 17 22 a0 or %i4, 0x2a0, %o0
rtems_libio_iop_flags_clear( iop, LIBIO_FLAGS_OPEN );
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
4000d65c: 81 c7 e0 08 ret
4000d660: 81 e8 00 00 restore
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000d664: 80 a0 60 00 cmp %g1, 0
4000d668: 02 80 00 0b be 4000d694 <pipe_release+0xcc>
4000d66c: 80 a6 a0 04 cmp %i2, 4
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000d670: 02 bf ff f9 be 4000d654 <pipe_release+0x8c>
<== NEVER TAKEN
4000d674: 01 00 00 00 nop
PIPE_WAKEUPWRITERS(pipe);
4000d678: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000d67c: 40 00 03 f2 call 4000e644 <rtems_barrier_release>
4000d680: 92 07 bf fc add %fp, -4, %o1
4000d684: 7f ff ed 2f call 40008b40 <_Mutex_Release>
4000d688: 90 17 22 a0 or %i4, 0x2a0, %o0
}
4000d68c: 81 c7 e0 08 ret
4000d690: 81 e8 00 00 restore
rtems_barrier_delete(pipe->readBarrier);
4000d694: 7f ff e4 ef call 40006a50 <rtems_barrier_delete>
4000d698: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
rtems_barrier_delete(pipe->writeBarrier);
4000d69c: 7f ff e4 ed call 40006a50 <rtems_barrier_delete>
4000d6a0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
free(pipe->Buffer);
4000d6a4: 7f ff dd 08 call 40004ac4 <free>
4000d6a8: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000d6ac: 7f ff dd 06 call 40004ac4 <free>
4000d6b0: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
4000d6b4: c0 26 00 00 clr [ %i0 ]
4000d6b8: 7f ff ed 22 call 40008b40 <_Mutex_Release>
4000d6bc: 90 17 22 a0 or %i4, 0x2a0, %o0
}
4000d6c0: 81 c7 e0 08 ret
4000d6c4: 81 e8 00 00 restore
4000dc14 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000dc14: 9d e3 bf 98 save %sp, -104, %sp
4000dc18: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000dc1c: 80 a6 a0 00 cmp %i2, 0
4000dc20: 02 80 00 36 be 4000dcf8 <pipe_write+0xe4>
<== NEVER TAKEN
4000dc24: b0 10 20 00 clr %i0
return 0;
PIPE_LOCK(pipe);
4000dc28: b8 07 60 28 add %i5, 0x28, %i4
_Mutex_Acquire( mutex );
4000dc2c: 7f ff eb a9 call 40008ad0 <_Mutex_Acquire>
4000dc30: 90 10 00 1c mov %i4, %o0
if (pipe->Readers == 0) {
4000dc34: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000dc38: 80 a0 60 00 cmp %g1, 0
4000dc3c: 02 80 00 29 be 4000dce0 <pipe_write+0xcc>
4000dc40: 01 00 00 00 nop
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4000dc44: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000dc48: 80 a0 40 1a cmp %g1, %i2
4000dc4c: 1a 80 00 03 bcc 4000dc58 <pipe_write+0x44>
<== ALWAYS TAKEN
4000dc50: a0 10 00 1a mov %i2, %l0
4000dc54: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
4000dc58: b0 10 20 00 clr %i0
4000dc5c: a2 10 20 00 clr %l1
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000dc60: c4 07 60 0c ld [ %i5 + 0xc ], %g2
4000dc64: 86 20 40 02 sub %g1, %g2, %g3
4000dc68: 80 a0 c0 10 cmp %g3, %l0
4000dc6c: 1a 80 00 30 bcc 4000dd2c <pipe_write+0x118>
4000dc70: a4 26 80 11 sub %i2, %l1, %l2
4000dc74: c2 06 e0 08 ld [ %i3 + 8 ], %g1
if (LIBIO_NODELAY(iop)) {
4000dc78: 80 88 60 01 btst 1, %g1
4000dc7c: 32 80 00 12 bne,a 4000dcc4 <pipe_write+0xb0>
4000dc80: b6 10 3f f5 mov -11, %i3
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
4000dc84: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000dc88: 82 00 60 01 inc %g1
4000dc8c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Mutex_Release( mutex );
4000dc90: 7f ff eb ac call 40008b40 <_Mutex_Release>
4000dc94: 90 10 00 1c mov %i4, %o0
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
4000dc98: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000dc9c: 40 00 02 7f call 4000e698 <rtems_barrier_wait>
4000dca0: 92 10 20 00 clr %o1
4000dca4: 80 a2 20 00 cmp %o0, 0
4000dca8: 02 80 00 16 be 4000dd00 <pipe_write+0xec>
<== ALWAYS TAKEN
4000dcac: 90 10 00 1c mov %i4, %o0
_Mutex_Acquire( mutex );
4000dcb0: 7f ff eb 88 call 40008ad0 <_Mutex_Acquire>
<== NOT EXECUTED
4000dcb4: b6 10 3f fc mov -4, %i3
<== NOT EXECUTED
ret = -EINTR;
PIPE_LOCK(pipe);
pipe->waitingWriters --;
4000dcb8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000dcbc: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dcc0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dcc4: 7f ff eb 9f call 40008b40 <_Mutex_Release>
4000dcc8: 90 10 00 1c mov %i4, %o0
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000dccc: 80 a6 20 00 cmp %i0, 0
4000dcd0: 14 80 00 0a bg 4000dcf8 <pipe_write+0xe4>
4000dcd4: 01 00 00 00 nop
4000dcd8: 81 c7 e0 08 ret
4000dcdc: 91 e8 00 1b restore %g0, %i3, %o0
4000dce0: 7f ff eb 98 call 40008b40 <_Mutex_Release>
4000dce4: 90 10 00 1c mov %i4, %o0
kill(getpid(), SIGPIPE);
4000dce8: 40 00 01 75 call 4000e2bc <getpid>
4000dcec: b0 10 3f e0 mov -32, %i0
4000dcf0: 40 00 02 51 call 4000e634 <kill>
4000dcf4: 92 10 20 0d mov 0xd, %o1
4000dcf8: 81 c7 e0 08 ret
4000dcfc: 81 e8 00 00 restore
_Mutex_Acquire( mutex );
4000dd00: 7f ff eb 74 call 40008ad0 <_Mutex_Acquire>
4000dd04: 01 00 00 00 nop
pipe->waitingWriters --;
4000dd08: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000dd0c: 82 00 7f ff add %g1, -1, %g1
4000dd10: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (pipe->Readers == 0) {
4000dd14: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000dd18: 80 a0 60 00 cmp %g1, 0
4000dd1c: 02 80 00 26 be 4000ddb4 <pipe_write+0x1a0>
<== NEVER TAKEN
4000dd20: 01 00 00 00 nop
4000dd24: 10 bf ff cf b 4000dc60 <pipe_write+0x4c>
4000dd28: c2 07 60 04 ld [ %i5 + 4 ], %g1
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000dd2c: 80 a4 80 03 cmp %l2, %g3
4000dd30: 38 80 00 02 bgu,a 4000dd38 <pipe_write+0x124>
<== NEVER TAKEN
4000dd34: a4 10 00 03 mov %g3, %l2
<== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000dd38: c8 07 60 08 ld [ %i5 + 8 ], %g4
4000dd3c: 84 00 80 04 add %g2, %g4, %g2
4000dd40: c6 07 40 00 ld [ %i5 ], %g3
4000dd44: 81 80 20 00 wr %g0, %y
4000dd48: 01 00 00 00 nop
4000dd4c: 01 00 00 00 nop
4000dd50: 01 00 00 00 nop
4000dd54: 90 70 80 01 udiv %g2, %g1, %o0
4000dd58: 90 5a 00 01 smul %o0, %g1, %o0
4000dd5c: 92 06 40 11 add %i1, %l1, %o1
4000dd60: 84 20 80 08 sub %g2, %o0, %g2
4000dd64: a0 20 40 02 sub %g1, %g2, %l0
if (chunk > chunk1) {
4000dd68: 80 a4 80 10 cmp %l2, %l0
4000dd6c: 14 80 00 1a bg 4000ddd4 <pipe_write+0x1c0>
4000dd70: 90 00 c0 02 add %g3, %g2, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000dd74: 40 00 09 0e call 400101ac <memcpy>
4000dd78: 94 10 00 12 mov %l2, %o2
pipe->Length += chunk;
4000dd7c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000dd80: 82 00 40 12 add %g1, %l2, %g1
4000dd84: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
4000dd88: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000dd8c: 80 a0 60 00 cmp %g1, 0
4000dd90: 32 80 00 1a bne,a 4000ddf8 <pipe_write+0x1e4>
4000dd94: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
written += chunk;
4000dd98: b0 06 00 12 add %i0, %l2, %i0
while (written < count) {
4000dd9c: 80 a6 00 1a cmp %i0, %i2
4000dda0: 1a 80 00 1a bcc 4000de08 <pipe_write+0x1f4>
<== ALWAYS TAKEN
4000dda4: a2 10 00 18 mov %i0, %l1
4000dda8: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
chunk = 1;
4000ddac: 10 bf ff ad b 4000dc60 <pipe_write+0x4c>
<== NOT EXECUTED
4000ddb0: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
_Mutex_Release( mutex );
4000ddb4: 7f ff eb 63 call 40008b40 <_Mutex_Release>
<== NOT EXECUTED
4000ddb8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
kill(getpid(), SIGPIPE);
4000ddbc: 40 00 01 40 call 4000e2bc <getpid>
<== NOT EXECUTED
4000ddc0: b6 10 3f e0 mov -32, %i3
<== NOT EXECUTED
4000ddc4: 40 00 02 1c call 4000e634 <kill>
<== NOT EXECUTED
4000ddc8: 92 10 20 0d mov 0xd, %o1
<== NOT EXECUTED
if (written > 0)
4000ddcc: 10 bf ff c1 b 4000dcd0 <pipe_write+0xbc>
<== NOT EXECUTED
4000ddd0: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000ddd4: 40 00 08 f6 call 400101ac <memcpy>
4000ddd8: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000dddc: d0 07 40 00 ld [ %i5 ], %o0
4000dde0: 92 04 00 11 add %l0, %l1, %o1
4000dde4: 94 24 80 10 sub %l2, %l0, %o2
4000dde8: 40 00 08 f1 call 400101ac <memcpy>
4000ddec: 92 06 40 09 add %i1, %o1, %o1
4000ddf0: 10 bf ff e4 b 4000dd80 <pipe_write+0x16c>
4000ddf4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
PIPE_WAKEUPREADERS(pipe);
4000ddf8: 40 00 02 13 call 4000e644 <rtems_barrier_release>
4000ddfc: 92 07 bf fc add %fp, -4, %o1
written += chunk;
4000de00: 10 bf ff e7 b 4000dd9c <pipe_write+0x188>
4000de04: b0 06 00 12 add %i0, %l2, %i0
out_locked:
4000de08: 10 bf ff af b 4000dcc4 <pipe_write+0xb0>
4000de0c: b6 10 20 00 clr %i3