=============================================================================== 40017b94 : 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_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 <== 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 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 <== 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 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 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 <== NEVER TAKEN 4001043c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 IMFS_node_destroy( jnode ); 40010440: 7f ff d8 5b call 400065ac 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 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 <== 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 40010478: 80 a0 a0 00 cmp %g2, 0 } while (jnode != NULL); 4001047c: 10 bf ff e3 b 40010408 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 <== NOT EXECUTED 40010490: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED 40010494: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40003480 : { 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 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 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 if (bit_mask == requested_bytes_per_block) { 400034e8: 80 a0 e0 10 cmp %g3, 0x10 400034ec: 02 80 00 0e be 40003524 400034f0: 80 a0 e0 0f cmp %g3, 0xf if(bit_mask > requested_bytes_per_block) 400034f4: 04 80 00 0b ble 40003520 <== 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 40003508: 03 10 00 6b sethi %hi(0x4001ac00), %g1 if(bit_mask > requested_bytes_per_block) 4000350c: 26 80 00 06 bl,a 40003524 <== 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 <== 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 } 4000352c: 81 c7 e0 08 ret 40003530: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000da40 : 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 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 <== NEVER TAKEN 4000da68: 94 10 20 78 mov 0x78, %o2 4000da6c: 08 80 00 1d bleu 4000dae0 <== 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 <== 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 <== 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 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 4000dab4: 80 a0 80 01 cmp %g2, %g1 4000dab8: 02 80 00 16 be 4000db10 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 4000db5c: 90 07 bf c8 add %fp, -56, %o0 } 4000db60: 81 c7 e0 08 ret 4000db64: 81 e8 00 00 restore =============================================================================== 40003f04 : { 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 <== 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 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 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 40003f70: 92 10 00 1a mov %i2, %o1 if ( my_length ) { 40003f74: 10 80 00 29 b 40004018 40003f78: 80 a7 20 00 cmp %i4, 0 memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 40003f7c: 40 00 2c 29 call 4000f020 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 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 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 <== 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 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 <== 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 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 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 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 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 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 <== 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 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 <== 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 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 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 <== 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 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 400040b8: 23 10 00 6b sethi %hi(0x4001ac00), %l1 400040bc: 30 bf ff f4 b,a 4000408c 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 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 400040e8: b8 27 00 18 sub %i4, %i0, %i4 bool zero_fill = start > memfile->File.size; 400040ec: 18 bf ff e2 bgu 40004074 400040f0: 94 10 20 00 clr %o2 400040f4: 10 bf ff ec b 400040a4 400040f8: 92 10 20 00 clr %o1 =============================================================================== 40017680 : 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 : 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 : 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 : 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 : 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 : #endif #include 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 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 <== 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 : { 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 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 <== 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 <== 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 : for( i=0; ((iname[i] != '\0')); i++ ) 40004648: 80 a2 a0 00 cmp %o2, 0 4000464c: 02 80 00 16 be 400046a4 <== 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 <== ALWAYS TAKEN 40004668: c2 08 40 00 ldub [ %g1 ], %g1 4000466c: 30 80 00 0c b,a 4000469c <== 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 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; ((iname[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 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; ((iname[i] != '\0')); i++ ) 400046a4: 81 c3 e0 08 retl <== NOT EXECUTED 400046a8: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED =============================================================================== 400043ac : 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 <== 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 <== 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 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 <== 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 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 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 40004458: d0 07 60 0c ld [ %i5 + 0xc ], %o0 4000445c: 10 bf ff e8 b 400043fc 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 : 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 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 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 : #endif #include 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 <== 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 <== 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 : 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 : 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 <== NOT EXECUTED 4000d99c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000d958 : 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 <== NOT EXECUTED 4000d96c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000d970 : 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 <== NOT EXECUTED 4000d984: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000d7e8 : 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 = *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 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 <== 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 <== 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 <== NEVER TAKEN 4000d848: 80 a0 60 02 cmp %g1, 2 4000d84c: 22 80 00 74 be,a 4000da1c <== 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 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 <== 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 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 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 <== 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 4000d8c4: 90 12 00 01 or %o0, %g1, %o0 4000d8c8: 80 a2 20 00 cmp %o0, 0 4000d8cc: 12 80 00 9f bne 4000db48 <== 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 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 4000d8ec: 90 12 00 01 or %o0, %g1, %o0 4000d8f0: 80 a2 20 00 cmp %o0, 0 4000d8f4: 12 80 00 93 bne 4000db40 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000d9b4: b0 10 20 00 clr %i0 <== NOT EXECUTED prevCounter = pipe->readerCounter; 4000d9b8: 10 80 00 08 b 4000d9d8 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== ALWAYS TAKEN 4000da54: b0 10 20 00 clr %i0 prevCounter = pipe->writerCounter; 4000da58: 10 80 00 08 b 4000da78 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000da94: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED out_error: 4000da98: 10 bf ff d9 b 4000d9fc <== 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 <== 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 <== 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 <== NOT EXECUTED 4000dae8: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED return 0; 4000daec: 10 bf ff 5b b 4000d858 <== 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 <== 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 4000db0c: 92 07 bf fc add %fp, -4, %o1 if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 4000db10: 10 bf ff 9f b 4000d98c 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 4000db20: 92 07 bf fc add %fp, -4, %o1 if (pipe->Writers == 0) { 4000db24: 10 bf ff c6 b 4000da3c 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 <== NOT EXECUTED 4000db34: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED if (pipe->Writers ++ == 0) 4000db38: 10 bf ff e3 b 4000dac4 <== 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 <== NOT EXECUTED 4000db44: d0 07 60 3c ld [ %i5 + 0x3c ], %o0 <== NOT EXECUTED free(pipe->Buffer); 4000db48: 7f ff dd 30 call 40005008 <== NOT EXECUTED 4000db4c: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED free(pipe); 4000db50: 7f ff dd 2e call 40005008 <== 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 : 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 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 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 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 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 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 <== 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 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 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 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 4000c634: d0 26 20 04 st %o0, [ %i0 + 4 ] err = errno; close(filsdes[0]); } unlink(fifopath); 4000c638: 7f ff e8 11 call 4000667c 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 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 <== 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 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 4000c68c: d0 06 00 00 ld [ %i0 ], %o0 unlink(fifopath); 4000c690: 7f ff e7 fb call 4000667c 4000c694: 90 07 bf f0 add %fp, -16, %o0 if(err != 0) 4000c698: 10 bf ff f2 b 4000c660 4000c69c: 80 a7 60 00 cmp %i5, 0 return -1; 4000c6a0: 10 bf ff e8 b 4000c640 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 <== NOT EXECUTED 4000c6b4: 00 00 00 00 unimp 0 <== NOT EXECUTED ... =============================================================================== 4000df30 : 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 <== NOT EXECUTED 4000df44: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED if (buffer == NULL) 4000df48: 02 80 00 0d be 4000df7c <== 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_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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000dcf8: 90 06 40 1b add %i1, %i3, %o0 <== NOT EXECUTED 4000dcfc: 10 bf ff dc b 4000dc6c <== 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 <== 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 <== NOT EXECUTED 4000dd24: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 4000dd28: 40 00 03 20 call 4000e9a8 <== NOT EXECUTED 4000dd2c: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED 4000dd30: 30 bf ff e3 b,a 4000dcbc <== NOT EXECUTED =============================================================================== 4000d6e8 : 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 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 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 <== 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 <== NOT EXECUTED 4000d75c: 80 a6 a0 02 cmp %i2, 2 <== NOT EXECUTED 4000d760: 02 80 00 05 be 4000d774 <== 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 <== 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 4000d78c: 80 a6 a0 04 cmp %i2, 4 else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 4000d790: 02 bf ff f9 be 4000d774 <== 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 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 4000d7b8: d0 07 60 3c ld [ %i5 + 0x3c ], %o0 rtems_barrier_delete(pipe->writeBarrier); 4000d7bc: 40 00 04 50 call 4000e8fc 4000d7c0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0 free(pipe->Buffer); 4000d7c4: 7f ff de 11 call 40005008 4000d7c8: d0 07 40 00 ld [ %i5 ], %o0 free(pipe); 4000d7cc: 7f ff de 0f call 40005008 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_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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000de0c: b0 10 3f e0 mov -32, %i0 <== NOT EXECUTED 4000de10: 40 00 02 8b call 4000e83c <== 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 <== NOT EXECUTED 4000de40: 01 00 00 00 nop <== NOT EXECUTED 4000de44: 10 bf ff cf b 4000dd80 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000dee0: b6 10 3f e0 mov -32, %i3 <== NOT EXECUTED 4000dee4: 40 00 02 56 call 4000e83c <== NOT EXECUTED 4000dee8: 92 10 20 0d mov 0xd, %o1 <== NOT EXECUTED if (written > 0) 4000deec: 10 bf ff c1 b 4000ddf0 <== 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 <== 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 <== NOT EXECUTED 4000df0c: 92 06 40 09 add %i1, %o1, %o1 <== NOT EXECUTED 4000df10: 10 bf ff e4 b 4000dea0 <== NOT EXECUTED 4000df14: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 4000df18: 40 00 02 a4 call 4000e9a8 <== NOT EXECUTED 4000df1c: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED written += chunk; 4000df20: 10 bf ff e7 b 4000debc <== NOT EXECUTED 4000df24: b0 06 00 12 add %i0, %l2, %i0 <== NOT EXECUTED out_locked: 4000df28: 10 bf ff af b 4000dde4 <== NOT EXECUTED 4000df2c: b6 10 20 00 clr %i3 <== NOT EXECUTED