=============================================================================== 40006c90 : int rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control) { 40006c90: 9d e3 bf a0 save %sp, -96, %sp if (!control->buffer) 40006c94: d2 06 00 00 ld [ %i0 ], %o1 40006c98: 80 a2 60 00 cmp %o1, 0 40006c9c: 02 80 00 46 be 40006db4 40006ca0: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_buffer_handle_request (control->fs, 40006ca4: d4 06 20 08 ld [ %i0 + 8 ], %o2 40006ca8: d0 06 20 04 ld [ %i0 + 4 ], %o0 40006cac: 40 00 01 5d call 40007220 40006cb0: 96 10 20 01 mov 1, %o3 if (rc) 40006cb4: b0 92 20 00 orcc %o0, 0, %i0 40006cb8: 12 80 00 3b bne 40006da4 <== NEVER TAKEN 40006cbc: 01 00 00 00 nop *map = rtems_rfs_buffer_data (control->buffer); 40006cc0: c2 07 40 00 ld [ %i5 ], %g1 40006cc4: c2 00 60 08 ld [ %g1 + 8 ], %g1 40006cc8: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 rc = rtems_rfs_bitmap_load_map (control, &map); if (rc > 0) return rc; control->free = 0; 40006ccc: c0 27 60 10 clr [ %i5 + 0x10 ] search_map = control->search_bits; size = control->size; bit = 0; rtems_rfs_bitmap_check(control, search_map); *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 40006cd0: 82 10 3f ff mov -1, %g1 search_map = control->search_bits; 40006cd4: de 07 60 14 ld [ %i5 + 0x14 ], %o7 size = control->size; 40006cd8: c8 07 60 0c ld [ %i5 + 0xc ], %g4 while (size) 40006cdc: 80 a1 20 00 cmp %g4, 0 40006ce0: 02 80 00 0f be 40006d1c <== NEVER TAKEN 40006ce4: c2 23 c0 00 st %g1, [ %o7 ] 40006ce8: b8 07 20 04 add %i4, 4, %i4 bit = 0; 40006cec: b2 10 20 00 clr %i1 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 40006cf0: b4 10 20 01 mov 1, %i2 available = size; } else { bits = *map; available = rtems_rfs_bitmap_element_bits (); 40006cf4: 9a 10 20 20 mov 0x20, %o5 mask >>= (rtems_rfs_bitmap_element_bits () - size); 40006cf8: b0 10 3f ff mov -1, %i0 if (size < rtems_rfs_bitmap_element_bits ()) 40006cfc: 80 a1 20 1f cmp %g4, 0x1f 40006d00: 18 80 00 09 bgu 40006d24 40006d04: c4 07 3f fc ld [ %i4 + -4 ], %g2 mask >>= (rtems_rfs_bitmap_element_bits () - size); 40006d08: 82 23 40 04 sub %o5, %g4, %g1 40006d0c: 83 36 00 01 srl %i0, %g1, %g1 } if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 40006d10: 84 88 80 01 andcc %g2, %g1, %g2 40006d14: 12 80 00 22 bne 40006d9c 40006d18: b6 10 00 04 mov %g4, %i3 else bit++; map++; } return 0; 40006d1c: 81 c7 e0 08 ret 40006d20: 91 e8 20 00 restore %g0, 0, %o0 if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 40006d24: 80 a0 a0 00 cmp %g2, 0 40006d28: 12 80 00 0f bne 40006d64 40006d2c: 88 01 3f e0 add %g4, -32, %g4 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 40006d30: 80 a6 60 1f cmp %i1, 0x1f 40006d34: 02 80 00 06 be 40006d4c 40006d38: 80 a1 20 00 cmp %g4, 0 while (size) 40006d3c: 02 bf ff f8 be 40006d1c 40006d40: b2 06 60 01 inc %i1 40006d44: 10 bf ff ee b 40006cfc 40006d48: b8 07 20 04 add %i4, 4, %i4 if (size > 0) 40006d4c: 02 bf ff f4 be 40006d1c 40006d50: b2 10 20 00 clr %i1 *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 40006d54: f0 23 e0 04 st %i0, [ %o7 + 4 ] search_map++; 40006d58: 9e 03 e0 04 add %o7, 4, %o7 40006d5c: 10 bf ff e8 b 40006cfc 40006d60: b8 07 20 04 add %i4, 4, %i4 available = rtems_rfs_bitmap_element_bits (); 40006d64: b6 10 20 20 mov 0x20, %i3 for (b = 0; b < available; b++) 40006d68: 82 10 20 00 clr %g1 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 40006d6c: 87 2e 80 01 sll %i2, %g1, %g3 if (!rtems_rfs_bitmap_test (bits, b)) 40006d70: 80 88 c0 02 btst %g3, %g2 40006d74: 02 80 00 05 be 40006d88 40006d78: 82 00 60 01 inc %g1 control->free++; 40006d7c: c6 07 60 10 ld [ %i5 + 0x10 ], %g3 40006d80: 86 00 e0 01 inc %g3 40006d84: c6 27 60 10 st %g3, [ %i5 + 0x10 ] for (b = 0; b < available; b++) 40006d88: 80 a6 c0 01 cmp %i3, %g1 40006d8c: 12 bf ff f9 bne 40006d70 40006d90: 87 2e 80 01 sll %i2, %g1, %g3 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 40006d94: 10 bf ff e8 b 40006d34 40006d98: 80 a6 60 1f cmp %i1, 0x1f if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 40006d9c: 10 bf ff f3 b 40006d68 40006da0: 88 10 20 00 clr %g4 if (rc > 0) 40006da4: 04 bf ff ca ble 40006ccc <== NOT EXECUTED 40006da8: b8 10 20 00 clr %i4 <== NOT EXECUTED } 40006dac: 81 c7 e0 08 ret <== NOT EXECUTED 40006db0: 81 e8 00 00 restore <== NOT EXECUTED 40006db4: 81 c7 e0 08 ret 40006db8: 91 e8 20 06 restore %g0, 6, %o0 =============================================================================== 40006b94 : int rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit seed, bool* allocated, rtems_rfs_bitmap_bit* bit) { 40006b94: 9d e3 bf a0 save %sp, -96, %sp int rc = 0; /* * By default we assume the allocation failed. */ *allocated = false; 40006b98: c0 2e 80 00 clrb [ %i2 ] * seed up then from the seed down a window number of bits, then repeat the * process from the window distance from the seed, again above then * below. Keep moving out until all bits have been searched. */ upper_seed = seed; lower_seed = seed; 40006b9c: ba 10 00 19 mov %i1, %i5 * we have searched all of the map. The seed may not be aligned to a window * boundary so we may need to search a partial window and this may also not * be balanced for the upper or lower seeds. We move to the limits, search * then return false if no clear bits are found. */ while (((upper_seed >= 0) && (upper_seed < control->size)) 40006ba0: 80 a6 60 00 cmp %i1, 0 40006ba4: 06 80 00 1e bl 40006c1c 40006ba8: 80 a7 60 00 cmp %i5, 0 40006bac: c2 06 20 0c ld [ %i0 + 0xc ], %g1 40006bb0: 80 a0 40 19 cmp %g1, %i1 40006bb4: 08 80 00 1a bleu 40006c1c 40006bb8: 80 a7 60 00 cmp %i5, 0 /* * Search up first so bits allocated in succession are grouped together. */ if (upper_seed < control->size) { *bit = upper_seed; 40006bbc: f2 26 c0 00 st %i1, [ %i3 ] rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated, 40006bc0: 96 10 20 01 mov 1, %o3 40006bc4: 94 10 00 1a mov %i2, %o2 40006bc8: 92 10 00 1b mov %i3, %o1 40006bcc: 7f ff fe 60 call 4000654c 40006bd0: 90 10 00 18 mov %i0, %o0 window, 1); if ((rc > 0) || *allocated) 40006bd4: 80 a2 20 00 cmp %o0, 0 40006bd8: 14 80 00 2c bg 40006c88 <== NEVER TAKEN 40006bdc: 01 00 00 00 nop 40006be0: c2 0e 80 00 ldub [ %i2 ], %g1 40006be4: 80 a0 60 00 cmp %g1, 0 40006be8: 12 80 00 28 bne 40006c88 40006bec: 80 a7 60 00 cmp %i5, 0 break; } if (lower_seed >= 0) 40006bf0: 36 80 00 14 bge,a 40006c40 40006bf4: fa 26 c0 00 st %i5, [ %i3 ] /* * Do not bound the limits at the edges of the map. Do not update if an * edge has been passed. */ if (upper_seed < control->size) 40006bf8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 40006bfc: 80 a6 40 01 cmp %i1, %g1 40006c00: 1a bf ff e9 bcc 40006ba4 <== NEVER TAKEN 40006c04: 80 a6 60 00 cmp %i1, 0 upper_seed += window; 40006c08: b2 06 68 00 add %i1, 0x800, %i1 while (((upper_seed >= 0) && (upper_seed < control->size)) 40006c0c: 80 a6 60 00 cmp %i1, 0 40006c10: 16 bf ff e9 bge 40006bb4 <== ALWAYS TAKEN 40006c14: 80 a0 40 19 cmp %g1, %i1 || ((lower_seed >= 0) && (lower_seed < control->size))) 40006c18: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 40006c1c: 06 80 00 1b bl 40006c88 40006c20: 01 00 00 00 nop 40006c24: c2 06 20 0c ld [ %i0 + 0xc ], %g1 40006c28: 80 a0 40 1d cmp %g1, %i5 40006c2c: 08 80 00 17 bleu 40006c88 40006c30: 80 a6 40 01 cmp %i1, %g1 if (upper_seed < control->size) 40006c34: 2a bf ff e3 bcs,a 40006bc0 <== NEVER TAKEN 40006c38: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED *bit = lower_seed; 40006c3c: fa 26 c0 00 st %i5, [ %i3 ] rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated, 40006c40: 96 10 3f ff mov -1, %o3 40006c44: 94 10 00 1a mov %i2, %o2 40006c48: 92 10 00 1b mov %i3, %o1 40006c4c: 7f ff fe 40 call 4000654c 40006c50: 90 10 00 18 mov %i0, %o0 if ((rc > 0) || *allocated) 40006c54: 80 a2 20 00 cmp %o0, 0 40006c58: 14 80 00 0c bg 40006c88 <== NEVER TAKEN 40006c5c: 01 00 00 00 nop 40006c60: c2 0e 80 00 ldub [ %i2 ], %g1 40006c64: 80 a0 60 00 cmp %g1, 0 40006c68: 12 80 00 08 bne 40006c88 40006c6c: 01 00 00 00 nop if (upper_seed < control->size) 40006c70: c2 06 20 0c ld [ %i0 + 0xc ], %g1 40006c74: 80 a6 40 01 cmp %i1, %g1 40006c78: 2a 80 00 02 bcs,a 40006c80 40006c7c: b2 06 68 00 add %i1, 0x800, %i1 if (lower_seed >= 0) lower_seed -= window; 40006c80: 10 bf ff c8 b 40006ba0 40006c84: ba 07 78 00 add %i5, -2048, %i5 } return 0; } 40006c88: 81 c7 e0 08 ret 40006c8c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 400068c4 : { 400068c4: 9d e3 bf a0 save %sp, -96, %sp if (!control->buffer) 400068c8: d2 06 00 00 ld [ %i0 ], %o1 400068cc: 80 a2 60 00 cmp %o1, 0 400068d0: 02 80 00 28 be 40006970 400068d4: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_buffer_handle_request (control->fs, 400068d8: d4 06 20 08 ld [ %i0 + 8 ], %o2 400068dc: d0 06 20 04 ld [ %i0 + 4 ], %o0 400068e0: 40 00 02 50 call 40007220 400068e4: 96 10 20 01 mov 1, %o3 if (rc) 400068e8: b0 92 20 00 orcc %o0, 0, %i0 400068ec: 12 80 00 24 bne 4000697c <== NEVER TAKEN 400068f0: 01 00 00 00 nop *map = rtems_rfs_buffer_data (control->buffer); 400068f4: c2 07 40 00 ld [ %i5 ], %g1 400068f8: c2 00 60 08 ld [ %g1 + 8 ], %g1 400068fc: c8 00 60 1c ld [ %g1 + 0x1c ], %g4 if (bit >= control->size) 40006900: c2 07 60 0c ld [ %i5 + 0xc ], %g1 40006904: 80 a0 40 19 cmp %g1, %i1 40006908: 08 80 00 18 bleu 40006968 4000690c: b0 10 20 16 mov 0x16, %i0 index = rtems_rfs_bitmap_map_index (bit); 40006910: 85 3e 60 05 sra %i1, 5, %g2 element = map[index]; 40006914: b7 28 a0 02 sll %g2, 2, %i3 40006918: f8 01 00 1b ld [ %g4 + %i3 ], %i4 search_map = control->search_bits; 4000691c: f4 07 60 14 ld [ %i5 + 0x14 ], %i2 map[index] = rtems_rfs_bitmap_clear (element, 1 << offset); 40006920: 86 10 20 01 mov 1, %g3 40006924: 83 28 c0 19 sll %g3, %i1, %g1 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 40006928: 82 10 40 1c or %g1, %i4, %g1 map[index] = rtems_rfs_bitmap_clear (element, 1 << offset); 4000692c: c2 21 00 1b st %g1, [ %g4 + %i3 ] if (rtems_rfs_bitmap_match(element, map[index])) 40006930: 80 a7 00 01 cmp %i4, %g1 40006934: 02 80 00 0d be 40006968 <== NEVER TAKEN 40006938: b0 10 20 00 clr %i0 index = rtems_rfs_bitmap_map_index (bit); 4000693c: b3 3e 60 0a sra %i1, 0xa, %i1 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 40006940: b3 2e 60 02 sll %i1, 2, %i1 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 40006944: c2 06 80 19 ld [ %i2 + %i1 ], %g1 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 40006948: 85 28 c0 02 sll %g3, %g2, %g2 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4000694c: 84 10 40 02 or %g1, %g2, %g2 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 40006950: c4 26 80 19 st %g2, [ %i2 + %i1 ] rtems_rfs_buffer_mark_dirty (control->buffer); 40006954: c4 07 40 00 ld [ %i5 ], %g2 control->free++; 40006958: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 rtems_rfs_buffer_mark_dirty (control->buffer); 4000695c: c6 28 80 00 stb %g3, [ %g2 ] control->free++; 40006960: 82 00 60 01 inc %g1 40006964: c2 27 60 10 st %g1, [ %i5 + 0x10 ] return 0; 40006968: 81 c7 e0 08 ret 4000696c: 81 e8 00 00 restore return ENXIO; 40006970: b0 10 20 06 mov 6, %i0 } 40006974: 81 c7 e0 08 ret 40006978: 81 e8 00 00 restore if (rc > 0) 4000697c: 14 bf ff fb bg 40006968 <== NOT EXECUTED 40006980: 88 10 20 00 clr %g4 <== NOT EXECUTED if (bit >= control->size) 40006984: 10 bf ff e0 b 40006904 <== NOT EXECUTED 40006988: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED =============================================================================== 40006ac4 : { 40006ac4: 9d e3 bf a0 save %sp, -96, %sp if (!control->buffer) 40006ac8: d2 06 00 00 ld [ %i0 ], %o1 40006acc: 80 a2 60 00 cmp %o1, 0 40006ad0: 02 80 00 2f be 40006b8c 40006ad4: b8 10 00 18 mov %i0, %i4 rc = rtems_rfs_buffer_handle_request (control->fs, 40006ad8: d4 06 20 08 ld [ %i0 + 8 ], %o2 40006adc: d0 06 20 04 ld [ %i0 + 4 ], %o0 40006ae0: 40 00 01 d0 call 40007220 40006ae4: 96 10 20 01 mov 1, %o3 if (rc) 40006ae8: b0 92 20 00 orcc %o0, 0, %i0 40006aec: 12 80 00 22 bne 40006b74 <== NEVER TAKEN 40006af0: 01 00 00 00 nop *map = rtems_rfs_buffer_data (control->buffer); 40006af4: f4 07 00 00 ld [ %i4 ], %i2 40006af8: c2 06 a0 08 ld [ %i2 + 8 ], %g1 40006afc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 elements = rtems_rfs_bitmap_elements (control->size); 40006b00: fa 07 20 0c ld [ %i4 + 0xc ], %i5 control->free = control->size; 40006b04: fa 27 20 10 st %i5, [ %i4 + 0x10 ] map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 40006b08: 92 10 20 ff mov 0xff, %o1 elements = rtems_rfs_bitmap_elements (control->size); 40006b0c: ba 07 7f ff add %i5, -1, %i5 40006b10: b7 37 60 05 srl %i5, 5, %i3 40006b14: b6 06 e0 01 inc %i3 map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 40006b18: 40 00 5f 61 call 4001e89c 40006b1c: 95 2e e0 02 sll %i3, 2, %o2 if (last_search_bit == 0) 40006b20: b6 8e e0 1f andcc %i3, 0x1f, %i3 40006b24: 12 80 00 11 bne 40006b68 40006b28: b2 10 3f ff mov -1, %i1 elements = rtems_rfs_bitmap_elements (elements); 40006b2c: bb 37 60 0a srl %i5, 0xa, %i5 for (e = 0; e < (elements - 1); e++) 40006b30: 80 a7 60 00 cmp %i5, 0 40006b34: 02 80 00 07 be 40006b50 40006b38: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 40006b3c: 90 10 00 01 mov %g1, %o0 40006b40: 95 2f 60 02 sll %i5, 2, %o2 40006b44: 40 00 5f 56 call 4001e89c 40006b48: 92 10 20 ff mov 0xff, %o1 40006b4c: 82 10 00 08 mov %o0, %g1 control->search_bits[elements - 1] = 40006b50: bb 2f 60 02 sll %i5, 2, %i5 40006b54: f2 20 40 1d st %i1, [ %g1 + %i5 ] rtems_rfs_buffer_mark_dirty (control->buffer); 40006b58: 82 10 20 01 mov 1, %g1 40006b5c: c2 2e 80 00 stb %g1, [ %i2 ] return 0; 40006b60: 81 c7 e0 08 ret 40006b64: 91 e8 20 00 restore %g0, 0, %o0 mask >>= (rtems_rfs_bitmap_element_bits () - size); 40006b68: b6 20 00 1b neg %i3 40006b6c: 10 bf ff f0 b 40006b2c 40006b70: b3 36 40 1b srl %i1, %i3, %i1 if (rc > 0) 40006b74: 24 80 00 04 ble,a 40006b84 <== NOT EXECUTED 40006b78: f4 07 00 00 ld [ %i4 ], %i2 <== NOT EXECUTED } 40006b7c: 81 c7 e0 08 ret <== NOT EXECUTED 40006b80: 81 e8 00 00 restore <== NOT EXECUTED *map = NULL; 40006b84: 10 bf ff df b 40006b00 <== NOT EXECUTED 40006b88: 90 10 20 00 clr %o0 <== NOT EXECUTED } 40006b8c: 81 c7 e0 08 ret 40006b90: 91 e8 20 06 restore %g0, 6, %o0 =============================================================================== 400067ec : { 400067ec: 9d e3 bf a0 save %sp, -96, %sp if (!control->buffer) 400067f0: d2 06 00 00 ld [ %i0 ], %o1 400067f4: 80 a2 60 00 cmp %o1, 0 400067f8: 02 80 00 2a be 400068a0 400067fc: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_buffer_handle_request (control->fs, 40006800: d4 06 20 08 ld [ %i0 + 8 ], %o2 40006804: d0 06 20 04 ld [ %i0 + 4 ], %o0 40006808: 40 00 02 86 call 40007220 4000680c: 96 10 20 01 mov 1, %o3 if (rc) 40006810: b0 92 20 00 orcc %o0, 0, %i0 40006814: 12 80 00 28 bne 400068b4 <== NEVER TAKEN 40006818: 01 00 00 00 nop *map = rtems_rfs_buffer_data (control->buffer); 4000681c: c2 07 40 00 ld [ %i5 ], %g1 40006820: c2 00 60 08 ld [ %g1 + 8 ], %g1 40006824: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 if (bit >= control->size) 40006828: c2 07 60 0c ld [ %i5 + 0xc ], %g1 4000682c: 80 a0 40 19 cmp %g1, %i1 40006830: 08 80 00 1d bleu 400068a4 40006834: b0 10 20 16 mov 0x16, %i0 index = rtems_rfs_bitmap_map_index (bit); 40006838: b7 3e 60 05 sra %i1, 5, %i3 element = map[index]; 4000683c: 89 2e e0 02 sll %i3, 2, %g4 40006840: f8 00 c0 04 ld [ %g3 + %g4 ], %i4 search_map = control->search_bits; 40006844: f4 07 60 14 ld [ %i5 + 0x14 ], %i2 map[index] = rtems_rfs_bitmap_set (element, 1 << offset); 40006848: 84 10 20 01 mov 1, %g2 4000684c: 83 28 80 19 sll %g2, %i1, %g1 return RTEMS_RFS_BITMAP_SET_BITS (target, bits); 40006850: 82 2f 00 01 andn %i4, %g1, %g1 if (rtems_rfs_bitmap_match(element, map[index])) 40006854: 80 a7 00 01 cmp %i4, %g1 40006858: 02 80 00 15 be 400068ac 4000685c: c2 20 c0 04 st %g1, [ %g3 + %g4 ] control->free--; 40006860: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 40006864: 82 00 7f ff add %g1, -1, %g1 rtems_rfs_buffer_mark_dirty (control->buffer); 40006868: f8 07 40 00 ld [ %i5 ], %i4 control->free--; 4000686c: c2 27 60 10 st %g1, [ %i5 + 0x10 ] rtems_rfs_buffer_mark_dirty (control->buffer); 40006870: c4 2f 00 00 stb %g2, [ %i4 ] if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET)) 40006874: c2 00 c0 04 ld [ %g3 + %g4 ], %g1 40006878: 80 a0 60 00 cmp %g1, 0 4000687c: 12 80 00 0c bne 400068ac 40006880: b3 3e 60 0a sra %i1, 0xa, %i1 search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); 40006884: b3 2e 60 02 sll %i1, 2, %i1 return RTEMS_RFS_BITMAP_SET_BITS (target, bits); 40006888: c2 06 80 19 ld [ %i2 + %i1 ], %g1 search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); 4000688c: 85 28 80 1b sll %g2, %i3, %g2 return RTEMS_RFS_BITMAP_SET_BITS (target, bits); 40006890: 84 28 40 02 andn %g1, %g2, %g2 search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); 40006894: c4 26 80 19 st %g2, [ %i2 + %i1 ] return 0; 40006898: 81 c7 e0 08 ret 4000689c: 91 e8 20 00 restore %g0, 0, %o0 return ENXIO; 400068a0: b0 10 20 06 mov 6, %i0 } 400068a4: 81 c7 e0 08 ret 400068a8: 81 e8 00 00 restore return 0; 400068ac: 81 c7 e0 08 ret 400068b0: 91 e8 20 00 restore %g0, 0, %o0 if (rc > 0) 400068b4: 14 bf ff fc bg 400068a4 <== NOT EXECUTED 400068b8: 86 10 20 00 clr %g3 <== NOT EXECUTED if (bit >= control->size) 400068bc: 10 bf ff dc b 4000682c <== NOT EXECUTED 400068c0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED =============================================================================== 40006a20 : { 40006a20: 9d e3 bf a0 save %sp, -96, %sp if (!control->buffer) 40006a24: d2 06 00 00 ld [ %i0 ], %o1 40006a28: 80 a2 60 00 cmp %o1, 0 40006a2c: 02 80 00 24 be 40006abc 40006a30: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_buffer_handle_request (control->fs, 40006a34: d4 06 20 08 ld [ %i0 + 8 ], %o2 40006a38: d0 06 20 04 ld [ %i0 + 4 ], %o0 40006a3c: 40 00 01 f9 call 40007220 40006a40: 96 10 20 01 mov 1, %o3 if (rc) 40006a44: b0 92 20 00 orcc %o0, 0, %i0 40006a48: 12 80 00 17 bne 40006aa4 <== NEVER TAKEN 40006a4c: 01 00 00 00 nop *map = rtems_rfs_buffer_data (control->buffer); 40006a50: f6 07 40 00 ld [ %i5 ], %i3 40006a54: c2 06 e0 08 ld [ %i3 + 8 ], %g1 40006a58: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 control->free = 0; 40006a5c: c0 27 60 10 clr [ %i5 + 0x10 ] map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; 40006a60: 92 10 20 00 clr %o1 elements = rtems_rfs_bitmap_elements (control->size); 40006a64: f8 07 60 0c ld [ %i5 + 0xc ], %i4 40006a68: b8 07 3f ff add %i4, -1, %i4 40006a6c: 95 37 20 05 srl %i4, 5, %o2 40006a70: 94 02 a0 01 inc %o2 map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; 40006a74: 40 00 5f 8a call 4001e89c 40006a78: 95 2a a0 02 sll %o2, 2, %o2 control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; 40006a7c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 elements = rtems_rfs_bitmap_elements (elements); 40006a80: 95 37 20 0a srl %i4, 0xa, %o2 control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; 40006a84: 92 10 20 00 clr %o1 elements = rtems_rfs_bitmap_elements (elements); 40006a88: 94 02 a0 01 inc %o2 control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; 40006a8c: 40 00 5f 84 call 4001e89c 40006a90: 95 2a a0 02 sll %o2, 2, %o2 rtems_rfs_buffer_mark_dirty (control->buffer); 40006a94: 82 10 20 01 mov 1, %g1 40006a98: c2 2e c0 00 stb %g1, [ %i3 ] return 0; 40006a9c: 81 c7 e0 08 ret 40006aa0: 91 e8 20 00 restore %g0, 0, %o0 if (rc > 0) 40006aa4: 24 80 00 04 ble,a 40006ab4 <== NOT EXECUTED 40006aa8: f6 07 40 00 ld [ %i5 ], %i3 <== NOT EXECUTED } 40006aac: 81 c7 e0 08 ret <== NOT EXECUTED 40006ab0: 81 e8 00 00 restore <== NOT EXECUTED *map = NULL; 40006ab4: 10 bf ff ea b 40006a5c <== NOT EXECUTED 40006ab8: 90 10 20 00 clr %o0 <== NOT EXECUTED } 40006abc: 81 c7 e0 08 ret 40006ac0: 91 e8 20 06 restore %g0, 6, %o0 =============================================================================== 4000698c : { 4000698c: 9d e3 bf a0 save %sp, -96, %sp if (!control->buffer) 40006990: d2 06 00 00 ld [ %i0 ], %o1 40006994: 80 a2 60 00 cmp %o1, 0 40006998: 02 80 00 20 be 40006a18 4000699c: 90 10 20 06 mov 6, %o0 rc = rtems_rfs_buffer_handle_request (control->fs, 400069a0: d4 06 20 08 ld [ %i0 + 8 ], %o2 400069a4: d0 06 20 04 ld [ %i0 + 4 ], %o0 400069a8: 40 00 02 1e call 40007220 400069ac: 96 10 20 01 mov 1, %o3 if (rc) 400069b0: 80 a2 20 00 cmp %o0, 0 400069b4: 12 80 00 15 bne 40006a08 <== NEVER TAKEN 400069b8: 01 00 00 00 nop *map = rtems_rfs_buffer_data (control->buffer); 400069bc: c2 06 00 00 ld [ %i0 ], %g1 400069c0: c2 00 60 08 ld [ %g1 + 8 ], %g1 400069c4: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 if (bit >= control->size) 400069c8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 400069cc: 80 a0 40 19 cmp %g1, %i1 400069d0: 08 80 00 0c bleu 40006a00 400069d4: 90 10 20 16 mov 0x16, %o0 index = rtems_rfs_bitmap_map_index (bit); 400069d8: 83 3e 60 05 sra %i1, 5, %g1 *state = rtems_rfs_bitmap_test (map[index], bit); 400069dc: 83 28 60 02 sll %g1, 2, %g1 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 400069e0: c4 00 80 01 ld [ %g2 + %g1 ], %g2 400069e4: 82 10 20 01 mov 1, %g1 400069e8: 83 28 40 19 sll %g1, %i1, %g1 400069ec: 82 08 40 02 and %g1, %g2, %g1 400069f0: 80 a0 00 01 cmp %g0, %g1 400069f4: 82 60 3f ff subx %g0, -1, %g1 400069f8: c2 2e 80 00 stb %g1, [ %i2 ] return 0; 400069fc: 90 10 20 00 clr %o0 } 40006a00: 81 c7 e0 08 ret 40006a04: 91 e8 00 08 restore %g0, %o0, %o0 if (rc > 0) 40006a08: 14 bf ff fe bg 40006a00 <== NOT EXECUTED 40006a0c: 84 10 20 00 clr %g2 <== NOT EXECUTED if (bit >= control->size) 40006a10: 10 bf ff ef b 400069cc <== NOT EXECUTED 40006a14: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED } 40006a18: 81 c7 e0 08 ret 40006a1c: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 400142a8 : { 400142a8: 9d e3 bf a0 save %sp, -96, %sp if (map->dirty && map->inode) 400142ac: c2 0e 40 00 ldub [ %i1 ], %g1 400142b0: 80 a0 60 00 cmp %g1, 0 400142b4: 02 80 00 0b be 400142e0 400142b8: ba 10 20 00 clr %i5 400142bc: d2 06 60 04 ld [ %i1 + 4 ], %o1 400142c0: 80 a2 60 00 cmp %o1, 0 400142c4: 22 80 00 08 be,a 400142e4 <== NEVER TAKEN 400142c8: c0 26 60 04 clr [ %i1 + 4 ] <== NOT EXECUTED brc = rtems_rfs_inode_load (fs, map->inode); 400142cc: 7f ff d3 64 call 4000905c 400142d0: 90 10 00 18 mov %i0, %o0 if (brc > 0) 400142d4: ba 92 20 00 orcc %o0, 0, %i5 400142d8: 04 80 00 12 ble 40014320 <== ALWAYS TAKEN 400142dc: 82 10 20 1c mov 0x1c, %g1 map->inode = NULL; 400142e0: c0 26 60 04 clr [ %i1 + 4 ] rtems_rfs_buffer_handle_release (fs, handle); 400142e4: 92 06 60 38 add %i1, 0x38, %o1 400142e8: 7f ff cc 97 call 40007544 400142ec: 90 10 00 18 mov %i0, %o0 handle->dirty = false; 400142f0: c0 2e 60 38 clrb [ %i1 + 0x38 ] rtems_rfs_buffer_handle_release (fs, handle); 400142f4: 92 06 60 44 add %i1, 0x44, %o1 handle->bnum = 0; 400142f8: c0 26 60 3c clr [ %i1 + 0x3c ] rtems_rfs_buffer_handle_release (fs, handle); 400142fc: 90 10 00 18 mov %i0, %o0 handle->buffer = NULL; 40014300: c0 26 60 40 clr [ %i1 + 0x40 ] rtems_rfs_buffer_handle_release (fs, handle); 40014304: 7f ff cc 90 call 40007544 40014308: b0 10 00 1d mov %i5, %i0 handle->dirty = false; 4001430c: c0 2e 60 44 clrb [ %i1 + 0x44 ] handle->bnum = 0; 40014310: c0 26 60 48 clr [ %i1 + 0x48 ] handle->buffer = NULL; 40014314: c0 26 60 4c clr [ %i1 + 0x4c ] } 40014318: 81 c7 e0 08 ret 4001431c: 81 e8 00 00 restore 40014320: b6 06 60 08 add %i1, 8, %i3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 40014324: b8 10 20 01 mov 1, %i4 rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]); 40014328: c4 06 60 04 ld [ %i1 + 4 ], %g2 4001432c: c6 06 c0 01 ld [ %i3 + %g1 ], %g3 rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno); 40014330: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40014334: bb 30 e0 18 srl %g3, 0x18, %i5 40014338: fa 29 00 01 stb %i5, [ %g4 + %g1 ] 4001433c: bb 30 e0 10 srl %g3, 0x10, %i5 40014340: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40014344: 88 01 00 01 add %g4, %g1, %g4 40014348: fa 29 20 01 stb %i5, [ %g4 + 1 ] 4001434c: bb 30 e0 08 srl %g3, 8, %i5 40014350: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40014354: 88 01 00 01 add %g4, %g1, %g4 40014358: fa 29 20 02 stb %i5, [ %g4 + 2 ] 4001435c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40014360: 88 01 00 01 add %g4, %g1, %g4 40014364: c6 29 20 03 stb %g3, [ %g4 + 3 ] for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 40014368: 82 00 60 04 add %g1, 4, %g1 4001436c: 80 a0 60 30 cmp %g1, 0x30 40014370: 12 bf ff ee bne 40014328 40014374: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ] rtems_rfs_inode_set_block_count (map->inode, map->size.count); 40014378: c2 06 60 04 ld [ %i1 + 4 ], %g1 4001437c: c4 06 60 08 ld [ %i1 + 8 ], %g2 rtems_rfs_write_u32 (&handle->node->block_count, block_count); 40014380: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40014384: 89 30 a0 18 srl %g2, 0x18, %g4 40014388: c8 28 e0 0c stb %g4, [ %g3 + 0xc ] 4001438c: 89 30 a0 10 srl %g2, 0x10, %g4 40014390: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40014394: c8 28 e0 0d stb %g4, [ %g3 + 0xd ] 40014398: 89 30 a0 08 srl %g2, 8, %g4 4001439c: c6 00 60 0c ld [ %g1 + 0xc ], %g3 400143a0: c8 28 e0 0e stb %g4, [ %g3 + 0xe ] brc = rtems_rfs_inode_unload (fs, map->inode, true); 400143a4: 94 10 20 01 mov 1, %o2 400143a8: c6 00 60 0c ld [ %g1 + 0xc ], %g3 400143ac: c4 28 e0 0f stb %g2, [ %g3 + 0xf ] 400143b0: 90 10 00 18 mov %i0, %o0 rtems_rfs_inode_set_block_offset (map->inode, map->size.offset); 400143b4: c6 06 60 04 ld [ %i1 + 4 ], %g3 rtems_rfs_write_u16 (&handle->node->block_offset, block_offset); 400143b8: c8 0e 60 0e ldub [ %i1 + 0xe ], %g4 rtems_rfs_buffer_mark_dirty (&handle->buffer); 400143bc: f8 28 60 10 stb %i4, [ %g1 + 0x10 ] rtems_rfs_write_u16 (&handle->node->block_offset, block_offset); 400143c0: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 400143c4: c4 06 60 0c ld [ %i1 + 0xc ], %g2 400143c8: c8 28 60 0a stb %g4, [ %g1 + 0xa ] 400143cc: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 400143d0: c4 28 60 0b stb %g2, [ %g1 + 0xb ] rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block); 400143d4: c4 06 60 04 ld [ %i1 + 4 ], %g2 400143d8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 rtems_rfs_buffer_mark_dirty (&handle->buffer); 400143dc: f8 28 e0 10 stb %i4, [ %g3 + 0x10 ] rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block); 400143e0: 89 30 60 18 srl %g1, 0x18, %g4 400143e4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 400143e8: c8 28 e0 30 stb %g4, [ %g3 + 0x30 ] 400143ec: 89 30 60 10 srl %g1, 0x10, %g4 400143f0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 400143f4: c8 28 e0 31 stb %g4, [ %g3 + 0x31 ] 400143f8: 89 30 60 08 srl %g1, 8, %g4 400143fc: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 40014400: c8 28 e0 32 stb %g4, [ %g3 + 0x32 ] 40014404: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 40014408: c2 28 e0 33 stb %g1, [ %g3 + 0x33 ] rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block); 4001440c: c2 06 60 04 ld [ %i1 + 4 ], %g1 40014410: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 40014414: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ] rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block); 40014418: 89 30 e0 18 srl %g3, 0x18, %g4 4001441c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40014420: c8 28 a0 34 stb %g4, [ %g2 + 0x34 ] 40014424: 89 30 e0 10 srl %g3, 0x10, %g4 40014428: c4 00 60 0c ld [ %g1 + 0xc ], %g2 4001442c: c8 28 a0 35 stb %g4, [ %g2 + 0x35 ] 40014430: 89 30 e0 08 srl %g3, 8, %g4 40014434: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40014438: c8 28 a0 36 stb %g4, [ %g2 + 0x36 ] 4001443c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40014440: c6 28 a0 37 stb %g3, [ %g2 + 0x37 ] rtems_rfs_buffer_mark_dirty (&handle->buffer); 40014444: f8 28 60 10 stb %i4, [ %g1 + 0x10 ] brc = rtems_rfs_inode_unload (fs, map->inode, true); 40014448: 7f ff d3 6d call 400091fc 4001444c: d2 06 60 04 ld [ %i1 + 4 ], %o1 map->dirty = false; 40014450: c0 2e 40 00 clrb [ %i1 ] if (brc > 0) 40014454: 82 38 00 08 xnor %g0, %o0, %g1 40014458: 83 38 60 1f sra %g1, 0x1f, %g1 map->dirty = false; 4001445c: 10 bf ff a1 b 400142e0 40014460: ba 0a 00 01 and %o0, %g1, %i5 =============================================================================== 40014464 : { 40014464: 9d e3 bf 98 save %sp, -104, %sp *block = 0; 40014468: c0 26 c0 00 clr [ %i3 ] if (rtems_rfs_block_pos_block_past_end (bpos, &map->size)) 4001446c: c2 06 80 00 ld [ %i2 ], %g1 40014470: 80 a0 60 00 cmp %g1, 0 40014474: 02 80 00 05 be 40014488 40014478: c4 06 60 08 ld [ %i1 + 8 ], %g2 4001447c: 80 a0 a0 00 cmp %g2, 0 40014480: 02 80 00 1a be 400144e8 <== NEVER TAKEN 40014484: 90 10 20 06 mov 6, %o0 40014488: 80 a0 40 02 cmp %g1, %g2 4001448c: 1a 80 00 17 bcc 400144e8 40014490: 90 10 20 06 mov 6, %o0 if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0)) 40014494: c6 06 60 10 ld [ %i1 + 0x10 ], %g3 40014498: 80 a0 40 03 cmp %g1, %g3 4001449c: 22 80 00 39 be,a 40014580 400144a0: c6 06 60 18 ld [ %i1 + 0x18 ], %g3 if (map->size.count <= RTEMS_RFS_INODE_BLOCKS) 400144a4: 80 a0 a0 05 cmp %g2, 5 400144a8: 38 80 00 12 bgu,a 400144f0 400144ac: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 *block = map->blocks[bpos->bno]; 400144b0: 82 00 60 08 add %g1, 8, %g1 400144b4: 83 28 60 02 sll %g1, 2, %g1 400144b8: 82 06 40 01 add %i1, %g1, %g1 400144bc: c2 00 60 04 ld [ %g1 + 4 ], %g1 400144c0: c2 26 c0 00 st %g1, [ %i3 ] map->bpos.block = *block; 400144c4: 90 10 20 00 clr %o0 rtems_rfs_block_copy_bpos (&map->bpos, bpos); 400144c8: c2 06 a0 04 ld [ %i2 + 4 ], %g1 400144cc: c4 06 80 00 ld [ %i2 ], %g2 400144d0: c6 06 a0 08 ld [ %i2 + 8 ], %g3 400144d4: c6 26 60 18 st %g3, [ %i1 + 0x18 ] 400144d8: c4 26 60 10 st %g2, [ %i1 + 0x10 ] 400144dc: c2 26 60 14 st %g1, [ %i1 + 0x14 ] map->bpos.block = *block; 400144e0: c2 06 c0 00 ld [ %i3 ], %g1 400144e4: c2 26 60 18 st %g1, [ %i1 + 0x18 ] } 400144e8: 81 c7 e0 08 ret 400144ec: 91 e8 00 08 restore %g0, %o0, %o0 direct = bpos->bno % fs->blocks_per_block; 400144f0: 81 80 20 00 wr %g0, %y 400144f4: 01 00 00 00 nop 400144f8: 01 00 00 00 nop 400144fc: 01 00 00 00 nop 40014500: 96 70 40 03 udiv %g1, %g3, %o3 singly = bpos->bno / fs->blocks_per_block; 40014504: d6 27 bf fc st %o3, [ %fp + -4 ] direct = bpos->bno % fs->blocks_per_block; 40014508: ba 5a c0 03 smul %o3, %g3, %i5 if (map->size.count <= fs->block_map_singly_blocks) 4001450c: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 40014510: 80 a1 00 02 cmp %g4, %g2 40014514: 1a 80 00 20 bcc 40014594 40014518: ba 20 40 1d sub %g1, %i5, %i5 singly %= fs->blocks_per_block; 4001451c: 81 80 20 00 wr %g0, %y 40014520: 01 00 00 00 nop 40014524: 01 00 00 00 nop 40014528: 01 00 00 00 nop 4001452c: 82 72 c0 03 udiv %o3, %g3, %g1 40014530: 86 58 40 03 smul %g1, %g3, %g3 40014534: 96 22 c0 03 sub %o3, %g3, %o3 40014538: d6 27 bf fc st %o3, [ %fp + -4 ] if (map->size.count < fs->block_map_doubly_blocks) 4001453c: c6 06 20 3c ld [ %i0 + 0x3c ], %g3 40014540: 80 a0 c0 02 cmp %g3, %g2 40014544: 08 bf ff e9 bleu 400144e8 <== NEVER TAKEN 40014548: 90 10 20 06 mov 6, %o0 rc = rtems_rfs_block_find_indirect (fs, 4001454c: 82 00 60 08 add %g1, 8, %g1 40014550: 83 28 60 02 sll %g1, 2, %g1 40014554: 82 06 40 01 add %i1, %g1, %g1 40014558: d4 00 60 04 ld [ %g1 + 4 ], %o2 4001455c: 98 07 bf fc add %fp, -4, %o4 40014560: 92 06 60 44 add %i1, 0x44, %o1 40014564: 7f ff fe 95 call 40013fb8 40014568: 90 10 00 18 mov %i0, %o0 if (rc == 0) 4001456c: 80 a2 20 00 cmp %o0, 0 40014570: 12 bf ff de bne 400144e8 <== NEVER TAKEN 40014574: d4 07 bf fc ld [ %fp + -4 ], %o2 rc = rtems_rfs_block_find_indirect (fs, 40014578: 10 80 00 0c b 400145a8 4001457c: 98 10 00 1b mov %i3, %o4 if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0)) 40014580: 80 a0 e0 00 cmp %g3, 0 40014584: 02 bf ff c9 be 400144a8 40014588: 80 a0 a0 05 cmp %g2, 5 *block = map->bpos.block; 4001458c: 10 bf ff ce b 400144c4 40014590: c6 26 c0 00 st %g3, [ %i3 ] rc = rtems_rfs_block_find_indirect (fs, 40014594: 96 02 e0 08 add %o3, 8, %o3 40014598: 97 2a e0 02 sll %o3, 2, %o3 4001459c: 96 06 40 0b add %i1, %o3, %o3 400145a0: d4 02 e0 04 ld [ %o3 + 4 ], %o2 rc = rtems_rfs_block_find_indirect (fs, 400145a4: 98 10 00 1b mov %i3, %o4 400145a8: 96 10 00 1d mov %i5, %o3 400145ac: 92 06 60 38 add %i1, 0x38, %o1 400145b0: 7f ff fe 82 call 40013fb8 400145b4: 90 10 00 18 mov %i0, %o0 if (rc == 0) 400145b8: 80 a2 20 00 cmp %o0, 0 400145bc: 22 bf ff c3 be,a 400144c8 <== ALWAYS TAKEN 400145c0: 90 10 20 00 clr %o0 400145c4: 30 bf ff c9 b,a 400144e8 <== NOT EXECUTED =============================================================================== 40014674 : { 40014674: 9d e3 bf 98 save %sp, -104, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW)) 40014678: 90 10 20 00 clr %o0 4001467c: 7f ff d9 52 call 4000abc4 40014680: 13 00 00 08 sethi %hi(0x2000), %o1 40014684: 80 a2 20 00 cmp %o0, 0 40014688: 32 80 00 e6 bne,a 40014a20 <== NEVER TAKEN 4001468c: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs)) 40014690: c2 06 60 08 ld [ %i1 + 8 ], %g1 40014694: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 40014698: 82 06 80 01 add %i2, %g1, %g1 4001469c: 80 a0 40 02 cmp %g1, %g2 400146a0: 1a 80 00 c0 bcc 400149a0 <== NEVER TAKEN 400146a4: ba 10 20 1b mov 0x1b, %i5 for (b = 0; b < blocks; b++) 400146a8: 80 a6 a0 00 cmp %i2, 0 400146ac: 02 80 00 e3 be 40014a38 <== NEVER TAKEN 400146b0: a4 10 20 00 clr %l2 rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block, 400146b4: d2 06 60 20 ld [ %i1 + 0x20 ], %o1 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 400146b8: b8 10 20 01 mov 1, %i4 rc = rtems_rfs_buffer_handle_request (fs, 400146bc: a2 06 60 44 add %i1, 0x44, %l1 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 400146c0: 10 80 00 11 b 40014704 400146c4: a0 06 60 38 add %i1, 0x38, %l0 map->blocks[map->size.count] = block; 400146c8: 84 00 60 08 add %g1, 8, %g2 400146cc: 85 28 a0 02 sll %g2, 2, %g2 400146d0: 84 06 40 02 add %i1, %g2, %g2 400146d4: d2 20 a0 04 st %o1, [ %g2 + 4 ] map->size.count++; 400146d8: 82 00 60 01 inc %g1 map->size.offset = 0; 400146dc: c0 26 60 0c clr [ %i1 + 0xc ] if (b == 0) 400146e0: 80 a4 a0 00 cmp %l2, 0 400146e4: 12 80 00 03 bne 400146f0 <== NEVER TAKEN 400146e8: c2 26 60 08 st %g1, [ %i1 + 8 ] *new_block = block; 400146ec: d2 26 c0 00 st %o1, [ %i3 ] for (b = 0; b < blocks; b++) 400146f0: a4 04 a0 01 inc %l2 map->last_data_block = block; 400146f4: d2 26 60 20 st %o1, [ %i1 + 0x20 ] for (b = 0; b < blocks; b++) 400146f8: 80 a4 80 1a cmp %l2, %i2 400146fc: 02 80 00 cf be 40014a38 <== ALWAYS TAKEN 40014700: f8 2e 40 00 stb %i4, [ %i1 ] rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block, 40014704: 96 07 bf f8 add %fp, -8, %o3 40014708: 94 10 20 00 clr %o2 4001470c: 7f ff d1 48 call 40008c2c 40014710: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40014714: ba 92 20 00 orcc %o0, 0, %i5 40014718: 14 80 00 a2 bg 400149a0 4001471c: 01 00 00 00 nop if (map->size.count < RTEMS_RFS_INODE_BLOCKS) 40014720: c2 06 60 08 ld [ %i1 + 8 ], %g1 40014724: 80 a0 60 04 cmp %g1, 4 40014728: 08 bf ff e8 bleu 400146c8 4001472c: d2 07 bf f8 ld [ %fp + -8 ], %o1 direct = map->size.count % fs->blocks_per_block; 40014730: ec 06 20 34 ld [ %i0 + 0x34 ], %l6 if (map->size.count < fs->block_map_singly_blocks) 40014734: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 direct = map->size.count % fs->blocks_per_block; 40014738: 81 80 20 00 wr %g0, %y 4001473c: 01 00 00 00 nop 40014740: 01 00 00 00 nop 40014744: 01 00 00 00 nop 40014748: aa 70 40 16 udiv %g1, %l6, %l5 if (map->size.count < fs->block_map_singly_blocks) 4001474c: 80 a0 40 02 cmp %g1, %g2 direct = map->size.count % fs->blocks_per_block; 40014750: a6 5d 40 16 smul %l5, %l6, %l3 if (map->size.count < fs->block_map_singly_blocks) 40014754: 1a 80 00 30 bcc 40014814 40014758: a6 20 40 13 sub %g1, %l3, %l3 if ((direct == 0) || 4001475c: 80 a4 e0 00 cmp %l3, 0 40014760: 02 80 00 06 be 40014778 40014764: 80 a0 40 16 cmp %g1, %l6 40014768: 1a 80 00 90 bcc 400149a8 4001476c: 80 a4 e0 05 cmp %l3, 5 40014770: 32 80 00 8f bne,a 400149ac 40014774: 82 05 60 08 add %l5, 8, %g1 upping = map->size.count == RTEMS_RFS_INODE_BLOCKS; 40014778: 82 18 60 05 xor %g1, 5, %g1 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001477c: 80 a0 00 01 cmp %g0, %g1 &map->blocks[singly], 40014780: 96 05 60 09 add %l5, 9, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40014784: 98 60 3f ff subx %g0, -1, %o4 &map->blocks[singly], 40014788: 97 2a e0 02 sll %o3, 2, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001478c: 94 10 00 10 mov %l0, %o2 40014790: 96 06 40 0b add %i1, %o3, %o3 40014794: 92 10 00 19 mov %i1, %o1 40014798: 7f ff fd b6 call 40013e70 4001479c: 90 10 00 18 mov %i0, %o0 400147a0: ba 10 00 08 mov %o0, %i5 if (rc > 0) 400147a4: 80 a7 60 00 cmp %i5, 0 400147a8: 14 80 00 7b bg 40014994 <== NEVER TAKEN 400147ac: d4 07 bf f8 ld [ %fp + -8 ], %o2 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 400147b0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 400147b4: c4 0f bf f8 ldub [ %fp + -8 ], %g2 400147b8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400147bc: a7 2c e0 02 sll %l3, 2, %l3 400147c0: c4 28 40 13 stb %g2, [ %g1 + %l3 ] 400147c4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 400147c8: c4 17 bf f8 lduh [ %fp + -8 ], %g2 400147cc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400147d0: 82 00 40 13 add %g1, %l3, %g1 400147d4: c4 28 60 01 stb %g2, [ %g1 + 1 ] 400147d8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 400147dc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400147e0: c4 07 bf f8 ld [ %fp + -8 ], %g2 400147e4: 82 00 40 13 add %g1, %l3, %g1 400147e8: 85 30 a0 08 srl %g2, 8, %g2 400147ec: c4 28 60 02 stb %g2, [ %g1 + 2 ] 400147f0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 400147f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400147f8: a6 00 40 13 add %g1, %l3, %l3 400147fc: c2 07 bf f8 ld [ %fp + -8 ], %g1 40014800: c2 2c e0 03 stb %g1, [ %l3 + 3 ] 40014804: f8 2e 60 38 stb %i4, [ %i1 + 0x38 ] map->size.count++; 40014808: c2 06 60 08 ld [ %i1 + 8 ], %g1 *new_block = block; 4001480c: 10 bf ff b3 b 400146d8 40014810: d2 07 bf f8 ld [ %fp + -8 ], %o1 doubly = singly / fs->blocks_per_block; 40014814: 81 80 20 00 wr %g0, %y 40014818: 01 00 00 00 nop 4001481c: 01 00 00 00 nop 40014820: 01 00 00 00 nop 40014824: ae 75 40 16 udiv %l5, %l6, %l7 if (direct == 0) 40014828: 80 a4 e0 00 cmp %l3, 0 singly %= fs->blocks_per_block; 4001482c: a8 5d c0 16 smul %l7, %l6, %l4 if (direct == 0) 40014830: 12 80 00 37 bne 4001490c 40014834: a8 25 40 14 sub %l5, %l4, %l4 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40014838: 98 10 20 00 clr %o4 4001483c: 96 07 bf fc add %fp, -4, %o3 40014840: 94 10 00 10 mov %l0, %o2 40014844: 92 10 00 19 mov %i1, %o1 40014848: 7f ff fd 8a call 40013e70 4001484c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40014850: ba 92 20 00 orcc %o0, 0, %i5 40014854: 14 80 00 4f bg 40014990 <== NEVER TAKEN 40014858: 80 a5 20 00 cmp %l4, 0 if ((singly == 0) || 4001485c: 02 80 00 06 be 40014874 <== NEVER TAKEN 40014860: 80 a5 40 16 cmp %l5, %l6 40014864: 1a 80 00 5b bcc 400149d0 <== NEVER TAKEN 40014868: 80 a5 20 05 cmp %l4, 5 4001486c: 12 80 00 5a bne 400149d4 40014870: 82 05 e0 08 add %l7, 8, %g1 upping = map->size.count == fs->block_map_singly_blocks; 40014874: c2 06 60 08 ld [ %i1 + 8 ], %g1 40014878: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 4001487c: 82 18 40 02 xor %g1, %g2, %g1 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40014880: 80 a0 00 01 cmp %g0, %g1 &map->blocks[doubly], 40014884: 96 05 e0 09 add %l7, 9, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40014888: 98 60 3f ff subx %g0, -1, %o4 &map->blocks[doubly], 4001488c: 97 2a e0 02 sll %o3, 2, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40014890: 94 10 00 11 mov %l1, %o2 40014894: 96 06 40 0b add %i1, %o3, %o3 40014898: 92 10 00 19 mov %i1, %o1 4001489c: 7f ff fd 75 call 40013e70 400148a0: 90 10 00 18 mov %i0, %o0 if (rc > 0) 400148a4: ba 92 20 00 orcc %o0, 0, %i5 400148a8: 14 80 00 56 bg 40014a00 <== NEVER TAKEN 400148ac: d4 07 bf fc ld [ %fp + -4 ], %o2 rtems_rfs_block_set_number (&map->doubly_buffer, 400148b0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400148b4: c4 0f bf fc ldub [ %fp + -4 ], %g2 400148b8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400148bc: a9 2d 20 02 sll %l4, 2, %l4 400148c0: c4 28 40 14 stb %g2, [ %g1 + %l4 ] 400148c4: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400148c8: c4 17 bf fc lduh [ %fp + -4 ], %g2 400148cc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400148d0: 82 00 40 14 add %g1, %l4, %g1 400148d4: c4 28 60 01 stb %g2, [ %g1 + 1 ] 400148d8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400148dc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400148e0: c4 07 bf fc ld [ %fp + -4 ], %g2 400148e4: 82 00 40 14 add %g1, %l4, %g1 400148e8: 85 30 a0 08 srl %g2, 8, %g2 400148ec: c4 28 60 02 stb %g2, [ %g1 + 2 ] 400148f0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400148f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400148f8: a8 00 40 14 add %g1, %l4, %l4 400148fc: c2 07 bf fc ld [ %fp + -4 ], %g1 40014900: c2 2d 20 03 stb %g1, [ %l4 + 3 ] 40014904: 10 bf ff ab b 400147b0 40014908: f8 2e 60 44 stb %i4, [ %i1 + 0x44 ] rc = rtems_rfs_buffer_handle_request (fs, 4001490c: ae 05 e0 08 add %l7, 8, %l7 40014910: af 2d e0 02 sll %l7, 2, %l7 40014914: ae 06 40 17 add %i1, %l7, %l7 40014918: d4 05 e0 04 ld [ %l7 + 4 ], %o2 4001491c: 96 10 20 01 mov 1, %o3 40014920: 92 10 00 11 mov %l1, %o1 40014924: 7f ff ca 3f call 40007220 40014928: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001492c: ba 92 20 00 orcc %o0, 0, %i5 40014930: 14 80 00 18 bg 40014990 <== NEVER TAKEN 40014934: a9 2d 20 02 sll %l4, 2, %l4 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 40014938: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 4001493c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 40014940: d4 08 80 14 ldub [ %g2 + %l4 ], %o2 40014944: 82 00 80 14 add %g2, %l4, %g1 40014948: c6 08 60 03 ldub [ %g1 + 3 ], %g3 4001494c: c4 08 60 01 ldub [ %g1 + 1 ], %g2 40014950: c2 08 60 02 ldub [ %g1 + 2 ], %g1 40014954: 85 28 a0 10 sll %g2, 0x10, %g2 40014958: 83 28 60 08 sll %g1, 8, %g1 4001495c: 95 2a a0 18 sll %o2, 0x18, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014960: 96 10 20 01 mov 1, %o3 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 40014964: 94 12 80 03 or %o2, %g3, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014968: 92 10 00 10 mov %l0, %o1 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001496c: 94 12 80 02 or %o2, %g2, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014970: 90 10 00 18 mov %i0, %o0 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 40014974: 94 12 80 01 or %o2, %g1, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014978: 7f ff ca 2a call 40007220 4001497c: d4 27 bf fc st %o2, [ %fp + -4 ] 40014980: ba 10 00 08 mov %o0, %i5 if (rc > 0) 40014984: 80 a7 60 00 cmp %i5, 0 40014988: 24 bf ff 8b ble,a 400147b4 <== ALWAYS TAKEN 4001498c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 rtems_rfs_group_bitmap_free (fs, false, block); 40014990: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED 40014994: 92 10 20 00 clr %o1 <== NOT EXECUTED 40014998: 7f ff d1 40 call 40008e98 <== NOT EXECUTED 4001499c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } 400149a0: 81 c7 e0 08 ret 400149a4: 91 e8 00 1d restore %g0, %i5, %o0 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 400149a8: 82 05 60 08 add %l5, 8, %g1 400149ac: 83 28 60 02 sll %g1, 2, %g1 400149b0: 82 06 40 01 add %i1, %g1, %g1 400149b4: d4 00 60 04 ld [ %g1 + 4 ], %o2 400149b8: 96 10 20 01 mov 1, %o3 400149bc: 92 10 00 10 mov %l0, %o1 400149c0: 7f ff ca 18 call 40007220 400149c4: 90 10 00 18 mov %i0, %o0 400149c8: 10 bf ff 77 b 400147a4 400149cc: ba 10 00 08 mov %o0, %i5 rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 400149d0: 82 05 e0 08 add %l7, 8, %g1 <== NOT EXECUTED 400149d4: 83 28 60 02 sll %g1, 2, %g1 400149d8: 82 06 40 01 add %i1, %g1, %g1 400149dc: d4 00 60 04 ld [ %g1 + 4 ], %o2 400149e0: 96 10 20 01 mov 1, %o3 400149e4: 92 10 00 11 mov %l1, %o1 400149e8: 7f ff ca 0e call 40007220 400149ec: 90 10 00 18 mov %i0, %o0 if (rc > 0) 400149f0: ba 92 20 00 orcc %o0, 0, %i5 400149f4: 24 bf ff b0 ble,a 400148b4 <== ALWAYS TAKEN 400149f8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 rtems_rfs_group_bitmap_free (fs, false, singly_block); 400149fc: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED 40014a00: 92 10 20 00 clr %o1 <== NOT EXECUTED 40014a04: 7f ff d1 25 call 40008e98 <== NOT EXECUTED 40014a08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, block); 40014a0c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED 40014a10: 92 10 20 00 clr %o1 <== NOT EXECUTED 40014a14: 7f ff d1 21 call 40008e98 <== NOT EXECUTED 40014a18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return rc; 40014a1c: 30 bf ff e1 b,a 400149a0 <== NOT EXECUTED printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n", 40014a20: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40014a24: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40014a28: 7f ff b8 b4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40014a2c: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400235f8 <== NOT EXECUTED if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs)) 40014a30: 10 bf ff 19 b 40014694 <== NOT EXECUTED 40014a34: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED return 0; 40014a38: ba 10 20 00 clr %i5 } 40014a3c: 81 c7 e0 08 ret 40014a40: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 4001412c : { 4001412c: 9d e3 bf a0 save %sp, -96, %sp map->dirty = false; 40014130: c0 2e 80 00 clrb [ %i2 ] rc = rtems_rfs_inode_load (fs, inode); 40014134: 92 10 00 19 mov %i1, %o1 map->inode = NULL; 40014138: c0 26 a0 04 clr [ %i2 + 4 ] rc = rtems_rfs_inode_load (fs, inode); 4001413c: 90 10 00 18 mov %i0, %o0 * @param[in] size is a pointer to the block size. */ static inline void rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size) { size->count = 0; 40014140: c0 26 a0 08 clr [ %i2 + 8 ] { 40014144: ba 10 00 1a mov %i2, %i5 size->offset = 0; 40014148: c0 26 a0 0c clr [ %i2 + 0xc ] bpos->bno = 0; 4001414c: c0 26 a0 10 clr [ %i2 + 0x10 ] bpos->boff = 0; 40014150: c0 26 a0 14 clr [ %i2 + 0x14 ] bpos->block = 0; 40014154: c0 26 a0 18 clr [ %i2 + 0x18 ] handle->dirty = false; 40014158: c0 2e a0 38 clrb [ %i2 + 0x38 ] handle->bnum = 0; 4001415c: c0 26 a0 3c clr [ %i2 + 0x3c ] handle->buffer = NULL; 40014160: c0 26 a0 40 clr [ %i2 + 0x40 ] handle->dirty = false; 40014164: c0 2e a0 44 clrb [ %i2 + 0x44 ] handle->bnum = 0; 40014168: c0 26 a0 48 clr [ %i2 + 0x48 ] rc = rtems_rfs_inode_load (fs, inode); 4001416c: 7f ff d3 bc call 4000905c 40014170: c0 26 a0 4c clr [ %i2 + 0x4c ] if (rc > 0) 40014174: b8 92 20 00 orcc %o0, 0, %i4 40014178: 14 80 00 3d bg 4001426c <== NEVER TAKEN 4001417c: 86 10 20 00 clr %g3 map->inode = inode; 40014180: f6 06 60 0c ld [ %i1 + 0xc ], %i3 40014184: f2 26 a0 04 st %i1, [ %i2 + 4 ] for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 40014188: b4 06 a0 24 add %i2, 0x24, %i2 return rtems_rfs_read_u32 (&handle->node->data.blocks[block]); 4001418c: 88 06 c0 03 add %i3, %g3, %g4 40014190: f8 09 20 1c ldub [ %g4 + 0x1c ], %i4 40014194: c4 09 20 1d ldub [ %g4 + 0x1d ], %g2 40014198: c2 09 20 1e ldub [ %g4 + 0x1e ], %g1 4001419c: c8 09 20 1f ldub [ %g4 + 0x1f ], %g4 400141a0: b9 2f 20 18 sll %i4, 0x18, %i4 400141a4: 85 28 a0 10 sll %g2, 0x10, %g2 400141a8: 83 28 60 08 sll %g1, 8, %g1 400141ac: 84 10 80 1c or %g2, %i4, %g2 400141b0: 82 10 40 02 or %g1, %g2, %g1 400141b4: 82 11 00 01 or %g4, %g1, %g1 map->blocks[b] = rtems_rfs_inode_get_block (inode, b); 400141b8: c2 26 80 03 st %g1, [ %i2 + %g3 ] for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 400141bc: 86 00 e0 04 add %g3, 4, %g3 400141c0: 80 a0 e0 14 cmp %g3, 0x14 400141c4: 12 bf ff f3 bne 40014190 400141c8: 88 06 c0 03 add %i3, %g3, %g4 return rtems_rfs_read_u32 (&handle->node->block_count); 400141cc: c6 0e e0 0f ldub [ %i3 + 0xf ], %g3 400141d0: c8 0e e0 0c ldub [ %i3 + 0xc ], %g4 400141d4: c4 0e e0 0d ldub [ %i3 + 0xd ], %g2 400141d8: c2 0e e0 0e ldub [ %i3 + 0xe ], %g1 400141dc: 89 29 20 18 sll %g4, 0x18, %g4 400141e0: 85 28 a0 10 sll %g2, 0x10, %g2 400141e4: 83 28 60 08 sll %g1, 8, %g1 400141e8: 84 10 80 04 or %g2, %g4, %g2 400141ec: 82 10 40 02 or %g1, %g2, %g1 400141f0: 82 10 c0 01 or %g3, %g1, %g1 map->size.count = rtems_rfs_inode_get_block_count (inode); 400141f4: c2 27 60 08 st %g1, [ %i5 + 8 ] map->size.offset = rtems_rfs_inode_get_block_offset (inode); 400141f8: c4 0e e0 0a ldub [ %i3 + 0xa ], %g2 400141fc: c2 0e e0 0b ldub [ %i3 + 0xb ], %g1 40014200: 85 28 a0 08 sll %g2, 8, %g2 40014204: 82 10 40 02 or %g1, %g2, %g1 40014208: c2 27 60 0c st %g1, [ %i5 + 0xc ] return rtems_rfs_read_u32 (&handle->node->last_map_block); 4001420c: c6 0e e0 33 ldub [ %i3 + 0x33 ], %g3 40014210: c8 0e e0 30 ldub [ %i3 + 0x30 ], %g4 40014214: c4 0e e0 31 ldub [ %i3 + 0x31 ], %g2 40014218: c2 0e e0 32 ldub [ %i3 + 0x32 ], %g1 4001421c: 89 29 20 18 sll %g4, 0x18, %g4 40014220: 85 28 a0 10 sll %g2, 0x10, %g2 40014224: 83 28 60 08 sll %g1, 8, %g1 40014228: 84 10 80 04 or %g2, %g4, %g2 4001422c: 82 10 40 02 or %g1, %g2, %g1 40014230: 82 10 c0 01 or %g3, %g1, %g1 map->last_map_block = rtems_rfs_inode_get_last_map_block (inode); 40014234: c2 27 60 1c st %g1, [ %i5 + 0x1c ] return rtems_rfs_read_u32 (&handle->node->last_data_block); 40014238: c8 0e e0 34 ldub [ %i3 + 0x34 ], %g4 4001423c: c4 0e e0 35 ldub [ %i3 + 0x35 ], %g2 40014240: c2 0e e0 36 ldub [ %i3 + 0x36 ], %g1 40014244: c6 0e e0 37 ldub [ %i3 + 0x37 ], %g3 40014248: 89 29 20 18 sll %g4, 0x18, %g4 4001424c: 85 28 a0 10 sll %g2, 0x10, %g2 40014250: 83 28 60 08 sll %g1, 8, %g1 40014254: 84 10 80 04 or %g2, %g4, %g2 40014258: 82 10 40 02 or %g1, %g2, %g1 4001425c: 82 10 c0 01 or %g3, %g1, %g1 map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 40014260: c2 27 60 20 st %g1, [ %i5 + 0x20 ] rc = rtems_rfs_inode_unload (fs, inode, false); 40014264: 7f ff d3 e6 call 400091fc 40014268: 95 e8 20 00 restore %g0, 0, %o2 rtems_rfs_buffer_handle_release (fs, handle); 4001426c: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED 40014270: 7f ff cc b5 call 40007544 <== NOT EXECUTED 40014274: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->dirty = false; 40014278: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001427c: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED handle->bnum = 0; 40014280: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40014284: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->buffer = NULL; 40014288: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001428c: 7f ff cc ae call 40007544 <== NOT EXECUTED 40014290: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED handle->dirty = false; 40014294: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED handle->bnum = 0; 40014298: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED handle->buffer = NULL; 4001429c: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED } 400142a0: 81 c7 e0 08 ret <== NOT EXECUTED 400142a4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40014a44 : int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks) { 40014a44: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK)) 40014a48: 90 10 20 00 clr %o0 40014a4c: 7f ff d8 5e call 4000abc4 40014a50: 13 00 00 10 sethi %hi(0x4000), %o1 40014a54: 80 a2 20 00 cmp %o0, 0 40014a58: 32 80 00 a4 bne,a 40014ce8 <== NEVER TAKEN 40014a5c: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n", blocks, map->size.count); if (map->size.count == 0) 40014a60: c2 06 60 08 ld [ %i1 + 8 ], %g1 40014a64: 80 a0 60 00 cmp %g1, 0 40014a68: 02 80 00 9b be 40014cd4 40014a6c: 80 a0 40 1a cmp %g1, %i2 return 0; if (blocks > map->size.count) 40014a70: 18 80 00 9c bgu 40014ce0 40014a74: ba 10 00 01 mov %g1, %i5 blocks = map->size.count; while (blocks) 40014a78: 80 a7 60 00 cmp %i5, 0 40014a7c: 02 80 00 8f be 40014cb8 <== NEVER TAKEN 40014a80: b4 06 60 44 add %i1, 0x44, %i2 doubly_singly); /* * Read the singly indirect table and get the block number. */ rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014a84: b6 06 60 38 add %i1, 0x38, %i3 if (rc > 0) return rc; map->size.count--; map->size.offset = 0; map->last_data_block = block_to_free; map->dirty = true; 40014a88: 10 80 00 13 b 40014ad4 40014a8c: b8 10 20 01 mov 1, %i4 block_to_free = map->blocks[block]; 40014a90: 82 06 40 01 add %i1, %g1, %g1 40014a94: e0 00 60 20 ld [ %g1 + 0x20 ], %l0 map->blocks[block] = 0; 40014a98: c0 20 60 20 clr [ %g1 + 0x20 ] rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free); 40014a9c: 94 10 00 10 mov %l0, %o2 40014aa0: 92 10 20 00 clr %o1 40014aa4: 7f ff d0 fd call 40008e98 40014aa8: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40014aac: 80 a2 20 00 cmp %o0, 0 40014ab0: 14 80 00 61 bg 40014c34 <== NEVER TAKEN 40014ab4: ba 87 7f ff addcc %i5, -1, %i5 map->size.count--; 40014ab8: c2 06 60 08 ld [ %i1 + 8 ], %g1 40014abc: 82 00 7f ff add %g1, -1, %g1 map->size.offset = 0; 40014ac0: c0 26 60 0c clr [ %i1 + 0xc ] map->size.count--; 40014ac4: c2 26 60 08 st %g1, [ %i1 + 8 ] map->last_data_block = block_to_free; 40014ac8: e0 26 60 20 st %l0, [ %i1 + 0x20 ] while (blocks) 40014acc: 02 80 00 78 be 40014cac 40014ad0: f8 2e 40 00 stb %i4, [ %i1 ] block = map->size.count - 1; 40014ad4: 84 00 7f ff add %g1, -1, %g2 if (block < RTEMS_RFS_INODE_BLOCKS) 40014ad8: 80 a0 a0 04 cmp %g2, 4 40014adc: 28 bf ff ed bleu,a 40014a90 40014ae0: 83 28 60 02 sll %g1, 2, %g1 direct = block % fs->blocks_per_block; 40014ae4: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 if (block < fs->block_map_singly_blocks) 40014ae8: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 direct = block % fs->blocks_per_block; 40014aec: 81 80 20 00 wr %g0, %y 40014af0: 01 00 00 00 nop 40014af4: 01 00 00 00 nop 40014af8: 01 00 00 00 nop 40014afc: a2 70 80 03 udiv %g2, %g3, %l1 if (block < fs->block_map_singly_blocks) 40014b00: 80 a1 00 02 cmp %g4, %g2 direct = block % fs->blocks_per_block; 40014b04: a6 5c 40 03 smul %l1, %g3, %l3 if (block < fs->block_map_singly_blocks) 40014b08: 18 80 00 4d bgu 40014c3c <== ALWAYS TAKEN 40014b0c: a6 20 80 13 sub %g2, %l3, %l3 else if (block < fs->block_map_doubly_blocks) 40014b10: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 <== NOT EXECUTED 40014b14: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED 40014b18: 08 80 00 65 bleu 40014cac <== NOT EXECUTED 40014b1c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED doubly = singly / fs->blocks_per_block; 40014b20: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40014b24: 01 00 00 00 nop <== NOT EXECUTED 40014b28: 01 00 00 00 nop <== NOT EXECUTED 40014b2c: 01 00 00 00 nop <== NOT EXECUTED 40014b30: a4 74 40 03 udiv %l1, %g3, %l2 <== NOT EXECUTED doubly_singly = singly % fs->blocks_per_block; 40014b34: 86 5c 80 03 smul %l2, %g3, %g3 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 40014b38: 82 04 a0 08 add %l2, 8, %g1 <== NOT EXECUTED 40014b3c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 40014b40: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED 40014b44: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED doubly_singly = singly % fs->blocks_per_block; 40014b48: a2 24 40 03 sub %l1, %g3, %l1 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 40014b4c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40014b50: 7f ff c9 b4 call 40007220 <== NOT EXECUTED 40014b54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 40014b58: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40014b5c: 14 80 00 36 bg 40014c34 <== NOT EXECUTED 40014b60: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40014b64: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 40014b68: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 40014b6c: 83 2c 60 02 sll %l1, 2, %g1 <== NOT EXECUTED 40014b70: e8 08 c0 01 ldub [ %g3 + %g1 ], %l4 <== NOT EXECUTED 40014b74: 84 00 c0 01 add %g3, %g1, %g2 <== NOT EXECUTED 40014b78: c2 08 a0 01 ldub [ %g2 + 1 ], %g1 <== NOT EXECUTED 40014b7c: d4 08 a0 02 ldub [ %g2 + 2 ], %o2 <== NOT EXECUTED 40014b80: c6 08 a0 03 ldub [ %g2 + 3 ], %g3 <== NOT EXECUTED 40014b84: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED 40014b88: 95 2a a0 08 sll %o2, 8, %o2 <== NOT EXECUTED 40014b8c: a9 2d 20 18 sll %l4, 0x18, %l4 <== NOT EXECUTED 40014b90: a8 15 00 03 or %l4, %g3, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014b94: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40014b98: a8 15 00 01 or %l4, %g1, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014b9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40014ba0: a8 15 00 0a or %l4, %o2, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014ba4: 7f ff c9 9f call 40007220 <== NOT EXECUTED 40014ba8: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED if (rc > 0) 40014bac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40014bb0: 14 80 00 21 bg 40014c34 <== NOT EXECUTED 40014bb4: 85 2c e0 02 sll %l3, 2, %g2 <== NOT EXECUTED block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 40014bb8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED 40014bbc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 40014bc0: e0 08 c0 02 ldub [ %g3 + %g2 ], %l0 <== NOT EXECUTED 40014bc4: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED 40014bc8: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 40014bcc: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 40014bd0: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 40014bd4: a1 2c 20 18 sll %l0, 0x18, %l0 <== NOT EXECUTED 40014bd8: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 40014bdc: a0 14 00 03 or %l0, %g3, %l0 <== NOT EXECUTED 40014be0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 40014be4: a0 14 00 02 or %l0, %g2, %l0 <== NOT EXECUTED if (direct == 0) 40014be8: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED 40014bec: 12 bf ff ac bne 40014a9c <== NOT EXECUTED 40014bf0: a0 14 00 01 or %l0, %g1, %l0 <== NOT EXECUTED rc = rtems_rfs_group_bitmap_free (fs, false, singly); 40014bf4: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 40014bf8: 92 10 20 00 clr %o1 <== NOT EXECUTED 40014bfc: 7f ff d0 a7 call 40008e98 <== NOT EXECUTED 40014c00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 40014c04: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40014c08: 14 80 00 0b bg 40014c34 <== NOT EXECUTED 40014c0c: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED map->last_map_block = singly; 40014c10: e8 26 60 1c st %l4, [ %i1 + 0x1c ] <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer, 40014c14: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED 40014c18: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40014c1c: 92 10 00 19 mov %i1, %o1 40014c20: 7f ff fc 5f call 40013d9c 40014c24: 90 10 00 18 mov %i0, %o0 if (rc) 40014c28: 80 a2 20 00 cmp %o0, 0 40014c2c: 02 bf ff 9d be 40014aa0 <== ALWAYS TAKEN 40014c30: 94 10 00 10 mov %l0, %o2 */ if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); return 0; } 40014c34: 81 c7 e0 08 ret <== NOT EXECUTED 40014c38: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40014c3c: 82 04 60 08 add %l1, 8, %g1 40014c40: 83 28 60 02 sll %g1, 2, %g1 40014c44: 82 06 40 01 add %i1, %g1, %g1 40014c48: d4 00 60 04 ld [ %g1 + 4 ], %o2 40014c4c: 96 10 20 01 mov 1, %o3 40014c50: 92 10 00 1b mov %i3, %o1 40014c54: 7f ff c9 73 call 40007220 40014c58: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40014c5c: 80 a2 20 00 cmp %o0, 0 40014c60: 14 bf ff f5 bg 40014c34 <== NEVER TAKEN 40014c64: 85 2c e0 02 sll %l3, 2, %g2 block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 40014c68: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 40014c6c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 40014c70: e0 08 c0 02 ldub [ %g3 + %g2 ], %l0 40014c74: 82 00 c0 02 add %g3, %g2, %g1 40014c78: c6 08 60 03 ldub [ %g1 + 3 ], %g3 40014c7c: c4 08 60 01 ldub [ %g1 + 1 ], %g2 40014c80: c2 08 60 02 ldub [ %g1 + 2 ], %g1 40014c84: a1 2c 20 18 sll %l0, 0x18, %l0 40014c88: 85 28 a0 10 sll %g2, 0x10, %g2 40014c8c: a0 14 00 03 or %l0, %g3, %l0 40014c90: 83 28 60 08 sll %g1, 8, %g1 40014c94: a0 14 00 02 or %l0, %g2, %l0 rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 40014c98: 98 10 00 13 mov %l3, %o4 block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 40014c9c: a0 14 00 01 or %l0, %g1, %l0 rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 40014ca0: 96 10 00 11 mov %l1, %o3 40014ca4: 10 bf ff de b 40014c1c 40014ca8: 94 10 00 1b mov %i3, %o2 if (map->size.count == 0) 40014cac: 80 a0 60 00 cmp %g1, 0 40014cb0: 22 80 00 14 be,a 40014d00 40014cb4: c0 26 60 1c clr [ %i1 + 0x1c ] if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) 40014cb8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 40014cbc: 80 a0 80 01 cmp %g2, %g1 40014cc0: 1a 80 00 21 bcc 40014d44 <== NEVER TAKEN 40014cc4: 86 00 7f ff add %g1, -1, %g3 40014cc8: 80 a0 80 03 cmp %g2, %g3 40014ccc: 22 80 00 18 be,a 40014d2c <== ALWAYS TAKEN 40014cd0: c4 06 60 0c ld [ %i1 + 0xc ], %g2 return 0; 40014cd4: 90 10 20 00 clr %o0 } 40014cd8: 81 c7 e0 08 ret 40014cdc: 91 e8 00 08 restore %g0, %o0, %o0 40014ce0: 10 bf ff 66 b 40014a78 40014ce4: ba 10 00 1a mov %i2, %i5 printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n", 40014ce8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40014cec: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40014cf0: 7f ff b8 02 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40014cf4: 90 12 22 30 or %o0, 0x230, %o0 ! 40023630 <== NOT EXECUTED if (map->size.count == 0) 40014cf8: 10 bf ff 5b b 40014a64 <== NOT EXECUTED 40014cfc: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED map->last_data_block = 0; 40014d00: c0 26 60 20 clr [ %i1 + 0x20 ] rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 40014d04: c4 06 60 0c ld [ %i1 + 0xc ], %g2 40014d08: c2 26 60 10 st %g1, [ %i1 + 0x10 ] 40014d0c: 80 a0 a0 00 cmp %g2, 0 40014d10: c4 26 60 14 st %g2, [ %i1 + 0x14 ] 40014d14: 02 bf ff f0 be 40014cd4 <== ALWAYS TAKEN 40014d18: c0 26 60 18 clr [ %i1 + 0x18 ] 40014d1c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED return 0; 40014d20: 90 10 20 00 clr %o0 <== NOT EXECUTED rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 40014d24: 10 bf ff c4 b 40014c34 <== NOT EXECUTED 40014d28: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) 40014d2c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3 40014d30: 80 a0 c0 02 cmp %g3, %g2 40014d34: 38 bf ff f6 bgu,a 40014d0c <== ALWAYS TAKEN 40014d38: c2 26 60 10 st %g1, [ %i1 + 0x10 ] return 0; 40014d3c: 10 bf ff e7 b 40014cd8 <== NOT EXECUTED 40014d40: 90 10 20 00 clr %o0 <== NOT EXECUTED rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 40014d44: 10 bf ff f1 b 40014d08 <== NOT EXECUTED 40014d48: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED =============================================================================== 40014dac : int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer, bool modified) { 40014dac: 9d e3 bf a0 save %sp, -96, %sp rtems_status_code sc; int rc = 0; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) 40014db0: 90 10 20 00 clr %o0 40014db4: 7f ff d7 84 call 4000abc4 40014db8: 92 10 20 40 mov 0x40, %o1 40014dbc: 80 a2 20 00 cmp %o0, 0 40014dc0: 02 80 00 0b be 40014dec <== ALWAYS TAKEN 40014dc4: 80 a6 60 00 cmp %i1, 0 printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", 40014dc8: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED 40014dcc: 12 80 00 18 bne 40014e2c <== NOT EXECUTED 40014dd0: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED 40014dd4: 17 10 00 84 sethi %hi(0x40021000), %o3 <== NOT EXECUTED 40014dd8: 96 12 e3 58 or %o3, 0x358, %o3 ! 40021358 <_rodata_start+0x898> <== NOT EXECUTED 40014ddc: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40014de0: 7f ff b7 c6 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40014de4: 90 12 22 80 or %o0, 0x280, %o0 ! 40023680 <== NOT EXECUTED ((intptr_t) buffer->user), buffer->block, modified ? "(modified)" : ""); if (modified) 40014de8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40014dec: 02 80 00 09 be 40014e10 40014df0: 90 10 00 18 mov %i0, %o0 sc = rtems_bdbuf_release_modified (buffer); 40014df4: 7f ff f5 0f call 40012230 40014df8: 01 00 00 00 nop #if RTEMS_RFS_BUFFER_ERRORS printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n", modified ? "modified" : "not-modified", rtems_status_text (sc), sc); #endif rc = EIO; 40014dfc: 80 a0 00 08 cmp %g0, %o0 40014e00: b0 40 3f ff addx %g0, -1, %i0 40014e04: b0 0e 3f fb and %i0, -5, %i0 } return rc; } 40014e08: 81 c7 e0 08 ret 40014e0c: 91 ee 20 05 restore %i0, 5, %o0 sc = rtems_bdbuf_release (buffer); 40014e10: 7f ff f4 c1 call 40012114 40014e14: 01 00 00 00 nop rc = EIO; 40014e18: 80 a0 00 08 cmp %g0, %o0 40014e1c: b0 40 3f ff addx %g0, -1, %i0 40014e20: b0 0e 3f fb and %i0, -5, %i0 } 40014e24: 81 c7 e0 08 ret 40014e28: 91 ee 20 05 restore %i0, 5, %o0 printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", 40014e2c: 17 10 00 8d sethi %hi(0x40023400), %o3 <== NOT EXECUTED 40014e30: 10 bf ff eb b 40014ddc <== NOT EXECUTED 40014e34: 96 12 e2 70 or %o3, 0x270, %o3 ! 40023670 <== NOT EXECUTED =============================================================================== 40007920 : { 40007920: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 40007924: 90 10 20 00 clr %o0 40007928: 92 10 20 10 mov 0x10, %o1 4000792c: 40 00 0c a6 call 4000abc4 40007930: ba 10 00 18 mov %i0, %i5 40007934: 80 a2 20 00 cmp %o0, 0 40007938: 12 80 00 30 bne 400079f8 <== NEVER TAKEN 4000793c: 11 10 00 88 sethi %hi(0x40022000), %o0 rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs)); 40007940: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 40007944: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 40007948: 7f ff ff b5 call 4000781c 4000794c: 90 10 00 1d mov %i5, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 40007950: b0 92 20 00 orcc %o0, 0, %i0 40007954: 14 80 00 1c bg 400079c4 <== NEVER TAKEN 40007958: 90 10 20 00 clr %o0 if (close (fs->device) < 0) 4000795c: 40 00 2c bc call 40012c4c 40007960: d0 07 60 0c ld [ %i5 + 0xc ], %o0 40007964: 80 a2 20 00 cmp %o0, 0 40007968: 06 80 00 04 bl 40007978 <== NEVER TAKEN 4000796c: 01 00 00 00 nop } 40007970: 81 c7 e0 08 ret 40007974: 81 e8 00 00 restore rc = errno; 40007978: 40 00 5a 69 call 4001e31c <__errno> <== NOT EXECUTED 4000797c: 01 00 00 00 nop <== NOT EXECUTED 40007980: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 40007984: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED rc = errno; 40007988: f0 00 40 00 ld [ %g1 ], %i0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4000798c: 40 00 0c 8e call 4000abc4 <== NOT EXECUTED 40007990: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007994: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007998: 02 80 00 09 be 400079bc <== NOT EXECUTED 4000799c: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 400079a0: 40 00 5f 1b call 4001f60c <== NOT EXECUTED 400079a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400079a8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400079ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400079b0: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 400079b4: 7f ff ec d1 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400079b8: 90 12 22 98 or %o0, 0x298, %o0 ! 40022298 <== NOT EXECUTED } 400079bc: 81 c7 e0 08 ret <== NOT EXECUTED 400079c0: 81 e8 00 00 restore <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 400079c4: 40 00 0c 80 call 4000abc4 <== NOT EXECUTED 400079c8: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED 400079cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400079d0: 02 bf ff e3 be 4000795c <== NOT EXECUTED 400079d4: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n", 400079d8: 40 00 5f 0d call 4001f60c <== NOT EXECUTED 400079dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400079e0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400079e4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400079e8: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 400079ec: 7f ff ec c3 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400079f0: 90 12 22 58 or %o0, 0x258, %o0 ! 40022258 <== NOT EXECUTED 400079f4: 30 bf ff da b,a 4000795c <== NOT EXECUTED printf ("rtems-rfs: buffer-close: closing\n"); 400079f8: 7f ff ec ce call 40002d30 <__wrap_puts> <== NOT EXECUTED 400079fc: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs)); 40007a00: 10 bf ff d1 b 40007944 <== NOT EXECUTED 40007a04: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED =============================================================================== 40006fe0 : rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs, 40006fe0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE)) 40006fe4: 90 10 20 00 clr %o0 <== NOT EXECUTED 40006fe8: 92 10 22 00 mov 0x200, %o1 <== NOT EXECUTED 40006fec: 40 00 0e f6 call 4000abc4 <== NOT EXECUTED 40006ff0: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED 40006ff4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006ff8: 22 80 00 12 be,a 40007040 <== NOT EXECUTED 40006ffc: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n", 40007000: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED 40007004: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007008: 12 80 00 3b bne 400070f4 <== NOT EXECUTED 4000700c: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED 40007010: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 40007014: d6 00 60 30 ld [ %g1 + 0x30 ], %o3 <== NOT EXECUTED 40007018: 15 10 00 84 sethi %hi(0x40021000), %o2 <== NOT EXECUTED 4000701c: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 40007020: 02 80 00 3b be 4000710c <== NOT EXECUTED 40007024: 94 12 a3 58 or %o2, 0x358, %o2 <== NOT EXECUTED 40007028: 19 10 00 84 sethi %hi(0x40021000), %o4 <== NOT EXECUTED 4000702c: 98 13 23 58 or %o4, 0x358, %o4 ! 40021358 <_rodata_start+0x898> <== NOT EXECUTED 40007030: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 40007034: 7f ff ef 31 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007038: 90 12 22 38 or %o0, 0x238, %o0 ! 40021e38 <== NOT EXECUTED if (rtems_rfs_buffer_refs (handle) > 0) 4000703c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 40007040: f0 00 60 30 ld [ %g1 + 0x30 ], %i0 <== NOT EXECUTED 40007044: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 40007048: 04 80 00 05 ble 4000705c <== NOT EXECUTED 4000704c: 01 00 00 00 nop <== NOT EXECUTED rtems_rfs_buffer_refs_down (handle); 40007050: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED 40007054: f0 20 60 30 st %i0, [ %g1 + 0x30 ] <== NOT EXECUTED if (rtems_rfs_buffer_refs (handle) == 0) 40007058: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000705c: 32 80 00 24 bne,a 400070ec <== NOT EXECUTED 40007060: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED next = the_node->next; 40007064: c8 00 40 00 ld [ %g1 ], %g4 <== NOT EXECUTED previous = the_node->previous; 40007068: c6 00 60 04 ld [ %g1 + 4 ], %g3 <== NOT EXECUTED next->previous = previous; 4000706c: c6 21 20 04 st %g3, [ %g4 + 4 ] <== NOT EXECUTED fs->buffers_count--; 40007070: c4 07 60 50 ld [ %i5 + 0x50 ], %g2 <== NOT EXECUTED previous->next = next; 40007074: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED 40007078: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000707c: c4 27 60 50 st %g2, [ %i5 + 0x50 ] <== NOT EXECUTED if (rtems_rfs_fs_no_local_cache (fs)) 40007080: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED 40007084: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED 40007088: 32 80 00 2f bne,a 40007144 <== NOT EXECUTED 4000708c: c0 20 60 34 clr [ %g1 + 0x34 ] <== NOT EXECUTED if ((fs->release_count + 40007090: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED 40007094: c8 07 60 70 ld [ %i5 + 0x70 ], %g4 <== NOT EXECUTED 40007098: c6 07 60 40 ld [ %i5 + 0x40 ], %g3 <== NOT EXECUTED 4000709c: 84 00 80 04 add %g2, %g4, %g2 <== NOT EXECUTED 400070a0: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 400070a4: 3a 80 00 2e bcc,a 4000715c <== NOT EXECUTED 400070a8: 90 10 20 00 clr %o0 <== NOT EXECUTED if (rtems_rfs_buffer_dirty (handle)) 400070ac: c4 0e 40 00 ldub [ %i1 ], %g2 <== NOT EXECUTED 400070b0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400070b4: 22 80 00 19 be,a 40007118 <== NOT EXECUTED 400070b8: c6 07 60 5c ld [ %i5 + 0x5c ], %g3 <== NOT EXECUTED old_last = tail->previous; 400070bc: c6 07 60 6c ld [ %i5 + 0x6c ], %g3 <== NOT EXECUTED return &the_chain->Tail.Node; 400070c0: 84 07 60 68 add %i5, 0x68, %g2 <== NOT EXECUTED the_node->next = tail; 400070c4: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED tail->previous = the_node; 400070c8: c2 27 60 6c st %g1, [ %i5 + 0x6c ] <== NOT EXECUTED old_last->next = the_node; 400070cc: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED fs->release_modified_count++; 400070d0: c4 07 60 70 ld [ %i5 + 0x70 ], %g2 <== NOT EXECUTED the_node->previous = old_last; 400070d4: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED 400070d8: 84 00 a0 01 inc %g2 <== NOT EXECUTED 400070dc: c4 27 60 70 st %g2, [ %i5 + 0x70 ] <== NOT EXECUTED handle->buffer = NULL; 400070e0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED } 400070e4: 81 c7 e0 08 ret <== NOT EXECUTED 400070e8: 81 e8 00 00 restore <== NOT EXECUTED 400070ec: 81 c7 e0 08 ret <== NOT EXECUTED 400070f0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n", 400070f4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 400070f8: d6 00 60 30 ld [ %g1 + 0x30 ], %o3 <== NOT EXECUTED 400070fc: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 40007100: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 40007104: 12 bf ff c9 bne 40007028 <== NOT EXECUTED 40007108: 94 12 a2 20 or %o2, 0x220, %o2 <== NOT EXECUTED 4000710c: 19 10 00 87 sethi %hi(0x40021c00), %o4 <== NOT EXECUTED 40007110: 10 bf ff c8 b 40007030 <== NOT EXECUTED 40007114: 98 13 22 28 or %o4, 0x228, %o4 ! 40021e28 <== NOT EXECUTED return &the_chain->Tail.Node; 40007118: 84 07 60 58 add %i5, 0x58, %g2 <== NOT EXECUTED the_node->next = tail; 4000711c: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED tail->previous = the_node; 40007120: c2 27 60 5c st %g1, [ %i5 + 0x5c ] <== NOT EXECUTED old_last->next = the_node; 40007124: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED fs->release_count++; 40007128: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED the_node->previous = old_last; 4000712c: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED 40007130: 84 00 a0 01 inc %g2 <== NOT EXECUTED 40007134: c4 27 60 60 st %g2, [ %i5 + 0x60 ] <== NOT EXECUTED handle->buffer = NULL; 40007138: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED } 4000713c: 81 c7 e0 08 ret <== NOT EXECUTED 40007140: 81 e8 00 00 restore <== NOT EXECUTED rc = rtems_rfs_buffer_io_release (handle->buffer, 40007144: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 40007148: 40 00 37 19 call 40014dac <== NOT EXECUTED 4000714c: d2 0e 40 00 ldub [ %i1 ], %o1 <== NOT EXECUTED handle->buffer = NULL; 40007150: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED } 40007154: 81 c7 e0 08 ret <== NOT EXECUTED 40007158: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE)) 4000715c: 40 00 0e 9a call 4000abc4 <== NOT EXECUTED 40007160: 92 10 22 00 mov 0x200, %o1 <== NOT EXECUTED 40007164: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007168: 32 80 00 27 bne,a 40007204 <== NOT EXECUTED 4000716c: d2 07 60 60 ld [ %i5 + 0x60 ], %o1 <== NOT EXECUTED if (fs->release_count > fs->release_modified_count) 40007170: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED 40007174: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 <== NOT EXECUTED 40007178: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4000717c: 28 80 00 0e bleu,a 400071b4 <== NOT EXECUTED 40007180: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 40007184: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED return &the_chain->Tail.Node; 40007188: 82 07 60 58 add %i5, 0x58, %g1 <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 4000718c: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 40007190: 02 80 00 19 be 400071f4 <== NOT EXECUTED 40007194: 86 07 60 54 add %i5, 0x54, %g3 <== NOT EXECUTED new_first = old_first->next; 40007198: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED head->next = new_first; 4000719c: c2 27 60 54 st %g1, [ %i5 + 0x54 ] <== NOT EXECUTED new_first->previous = head; 400071a0: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED fs->release_count--; 400071a4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED modified = false; 400071a8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400071ac: 10 80 00 0c b 400071dc <== NOT EXECUTED 400071b0: c4 27 60 60 st %g2, [ %i5 + 0x60 ] <== NOT EXECUTED return &the_chain->Tail.Node; 400071b4: 84 07 60 68 add %i5, 0x68, %g2 <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 400071b8: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED 400071bc: 02 80 00 10 be 400071fc <== NOT EXECUTED 400071c0: 86 07 60 64 add %i5, 0x64, %g3 <== NOT EXECUTED new_first = old_first->next; 400071c4: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED head->next = new_first; 400071c8: c4 27 60 64 st %g2, [ %i5 + 0x64 ] <== NOT EXECUTED new_first->previous = head; 400071cc: c6 20 a0 04 st %g3, [ %g2 + 4 ] <== NOT EXECUTED fs->release_modified_count--; 400071d0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400071d4: c2 27 60 70 st %g1, [ %i5 + 0x70 ] <== NOT EXECUTED modified = true; 400071d8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED buffer->user = (void*) 0; 400071dc: c0 22 20 34 clr [ %o0 + 0x34 ] <== NOT EXECUTED rc = rtems_rfs_buffer_io_release (buffer, modified); 400071e0: 40 00 36 f3 call 40014dac <== NOT EXECUTED 400071e4: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED rtems_rfs_buffer_link (handle)); 400071e8: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED rc = rtems_rfs_buffer_io_release (buffer, modified); 400071ec: 10 bf ff b0 b 400070ac <== NOT EXECUTED 400071f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED return NULL; 400071f4: 10 bf ff ec b 400071a4 <== NOT EXECUTED 400071f8: 90 10 20 00 clr %o0 <== NOT EXECUTED 400071fc: 10 bf ff f5 b 400071d0 <== NOT EXECUTED 40007200: 90 10 20 00 clr %o0 <== NOT EXECUTED printf ("rtems-rfs: buffer-release: local cache overflow:" 40007204: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 <== NOT EXECUTED 40007208: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 4000720c: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 40007210: 7f ff ee ba call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007214: 90 12 22 70 or %o0, 0x270, %o0 ! 40021e70 <== NOT EXECUTED if (fs->release_count > fs->release_modified_count) 40007218: 10 bf ff d7 b 40007174 <== NOT EXECUTED 4000721c: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED =============================================================================== 40007220 : { 40007220: 9d e3 bf 98 save %sp, -104, %sp if (rtems_rfs_buffer_handle_has_block (handle)) 40007224: c2 06 60 08 ld [ %i1 + 8 ], %g1 40007228: 80 a0 60 00 cmp %g1, 0 4000722c: 02 80 00 1a be 40007294 40007230: ba 10 00 18 mov %i0, %i5 if (block && (rtems_rfs_buffer_bnum (handle) == block)) 40007234: 80 a6 a0 00 cmp %i2, 0 40007238: 02 80 00 06 be 40007250 <== NEVER TAKEN 4000723c: 90 10 20 00 clr %o0 40007240: c2 06 60 04 ld [ %i1 + 4 ], %g1 40007244: 80 a0 40 1a cmp %g1, %i2 40007248: 02 80 00 79 be 4000742c 4000724c: 01 00 00 00 nop if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 40007250: 40 00 0e 5d call 4000abc4 40007254: 92 10 21 00 mov 0x100, %o1 ! 100 <_TLS_Alignment+0xff> 40007258: 80 a2 20 00 cmp %o0, 0 4000725c: 32 80 00 6b bne,a 40007408 <== NEVER TAKEN 40007260: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (handle)) 40007264: c2 06 60 08 ld [ %i1 + 8 ], %g1 40007268: 80 a0 60 00 cmp %g1, 0 4000726c: 22 80 00 09 be,a 40007290 <== NEVER TAKEN 40007270: c0 2e 40 00 clrb [ %i1 ] <== NOT EXECUTED 40007274: 92 10 00 19 mov %i1, %o1 40007278: 7f ff ff 5a call 40006fe0 4000727c: 90 10 00 1d mov %i5, %o0 if (rc > 0) 40007280: b0 92 20 00 orcc %o0, 0, %i0 40007284: 14 80 00 a3 bg 40007510 <== NEVER TAKEN 40007288: 01 00 00 00 nop handle->dirty = false; 4000728c: c0 2e 40 00 clrb [ %i1 ] handle->bnum = 0; 40007290: c0 26 60 04 clr [ %i1 + 4 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 40007294: 90 10 20 00 clr %o0 40007298: 40 00 0e 4b call 4000abc4 4000729c: 92 10 21 00 mov 0x100, %o1 400072a0: 80 a2 20 00 cmp %o0, 0 400072a4: 32 80 00 50 bne,a 400073e4 <== NEVER TAKEN 400072a8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED if (fs->buffers_count) 400072ac: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 400072b0: 80 a0 60 00 cmp %g1, 0 400072b4: 12 80 00 38 bne 40007394 400072b8: 94 10 00 1a mov %i2, %o2 if (!rtems_rfs_fs_no_local_cache (fs) && 400072bc: c4 07 40 00 ld [ %i5 ], %g2 400072c0: 80 88 a0 02 btst 2, %g2 400072c4: 12 80 00 26 bne 4000735c 400072c8: c2 06 60 08 ld [ %i1 + 8 ], %g1 400072cc: 80 a0 60 00 cmp %g1, 0 400072d0: 22 80 00 69 be,a 40007474 400072d4: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 rtems_rfs_buffer_refs_up (handle); 400072d8: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 old_last = tail->previous; 400072dc: c6 07 60 4c ld [ %i5 + 0x4c ], %g3 return &the_chain->Tail.Node; 400072e0: 88 07 60 48 add %i5, 0x48, %g4 400072e4: 84 00 a0 01 inc %g2 the_node->next = tail; 400072e8: c8 20 40 00 st %g4, [ %g1 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 400072ec: 90 10 20 00 clr %o0 rtems_rfs_buffer_refs_up (handle); 400072f0: c4 20 60 30 st %g2, [ %g1 + 0x30 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 400072f4: 92 10 21 00 mov 0x100, %o1 tail->previous = the_node; 400072f8: c2 27 60 4c st %g1, [ %i5 + 0x4c ] old_last->next = the_node; 400072fc: c2 20 c0 00 st %g1, [ %g3 ] fs->buffers_count++; 40007300: c4 07 60 50 ld [ %i5 + 0x50 ], %g2 the_node->previous = old_last; 40007304: c6 20 60 04 st %g3, [ %g1 + 4 ] 40007308: 84 00 a0 01 inc %g2 4000730c: c4 27 60 50 st %g2, [ %i5 + 0x50 ] handle->buffer->user = (void*) ((intptr_t) block); 40007310: f4 20 60 34 st %i2, [ %g1 + 0x34 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 40007314: 40 00 0e 2c call 4000abc4 40007318: f4 26 60 04 st %i2, [ %i1 + 4 ] 4000731c: 80 a2 20 00 cmp %o0, 0 40007320: 02 80 00 43 be 4000742c <== ALWAYS TAKEN 40007324: 80 a6 e0 00 cmp %i3, 0 printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 40007328: 12 80 00 43 bne 40007434 <== NOT EXECUTED 4000732c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 40007330: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED 40007334: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED return 0; 40007338: b0 10 20 00 clr %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4000733c: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 40007340: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40007344: 94 12 a2 b0 or %o2, 0x2b0, %o2 <== NOT EXECUTED 40007348: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000734c: 7f ff ee 6b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007350: 90 12 23 88 or %o0, 0x388, %o0 ! 40021f88 <== NOT EXECUTED 40007354: 81 c7 e0 08 ret <== NOT EXECUTED 40007358: 81 e8 00 00 restore <== NOT EXECUTED if (!rtems_rfs_buffer_handle_has_block (handle)) 4000735c: 80 a0 60 00 cmp %g1, 0 40007360: 32 bf ff df bne,a 400072dc <== NEVER TAKEN 40007364: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 <== NOT EXECUTED rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer); 40007368: 96 06 60 08 add %i1, 8, %o3 4000736c: 94 10 00 1b mov %i3, %o2 40007370: 92 10 00 1a mov %i2, %o1 40007374: 40 00 36 7a call 40014d5c 40007378: 90 10 00 1d mov %i5, %o0 if (rc > 0) 4000737c: b0 92 20 00 orcc %o0, 0, %i0 40007380: 14 80 00 4f bg 400074bc <== NEVER TAKEN 40007384: 90 10 20 00 clr %o0 rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle)); 40007388: c2 06 60 08 ld [ %i1 + 8 ], %g1 RTEMS_INLINE_ROUTINE void rtems_chain_set_off_chain( rtems_chain_node *node ) { _Chain_Set_off_chain( node ); } 4000738c: 10 bf ff d3 b 400072d8 40007390: c0 20 40 00 clr [ %g1 ] handle->buffer = rtems_rfs_scan_chain (&fs->buffers, 40007394: 92 07 60 50 add %i5, 0x50, %o1 40007398: 7f ff fe 9f call 40006e14 4000739c: 90 07 60 44 add %i5, 0x44, %o0 if (rtems_rfs_buffer_handle_has_block (handle) && 400073a0: 80 a2 20 00 cmp %o0, 0 400073a4: 02 80 00 2f be 40007460 400073a8: d0 26 60 08 st %o0, [ %i1 + 8 ] rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 400073ac: 90 10 20 00 clr %o0 400073b0: 40 00 0e 05 call 4000abc4 400073b4: 92 10 21 00 mov 0x100, %o1 if (rtems_rfs_buffer_handle_has_block (handle) && 400073b8: 80 a2 20 00 cmp %o0, 0 400073bc: 22 bf ff c1 be,a 400072c0 <== ALWAYS TAKEN 400073c0: c4 07 40 00 ld [ %i5 ], %g2 rtems_rfs_buffer_refs (handle) + 1); 400073c4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", 400073c8: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED 400073cc: 92 02 60 01 inc %o1 <== NOT EXECUTED 400073d0: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 400073d4: 7f ff ee 49 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400073d8: 90 12 23 18 or %o0, 0x318, %o0 ! 40021f18 <== NOT EXECUTED if (!rtems_rfs_fs_no_local_cache (fs) && 400073dc: 10 bf ff b9 b 400072c0 <== NOT EXECUTED 400073e0: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block); 400073e4: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 400073e8: 7f ff ee 44 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400073ec: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40021ef0 <== NOT EXECUTED if (fs->buffers_count) 400073f0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED 400073f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400073f8: 22 bf ff b2 be,a 400072c0 <== NOT EXECUTED 400073fc: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->buffers, 40007400: 10 bf ff e5 b 40007394 <== NOT EXECUTED 40007404: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n", 40007408: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000740c: 7f ff ee 3b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007410: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40021eb8 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (handle)) 40007414: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 40007418: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000741c: 32 bf ff 97 bne,a 40007278 <== NOT EXECUTED 40007420: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED handle->dirty = false; 40007424: 10 bf ff 9b b 40007290 <== NOT EXECUTED 40007428: c0 2e 40 00 clrb [ %i1 ] <== NOT EXECUTED return 0; 4000742c: 81 c7 e0 08 ret 40007430: 91 e8 20 00 restore %g0, 0, %o0 printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 40007434: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED 40007438: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED return 0; 4000743c: b0 10 20 00 clr %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 40007440: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 40007444: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40007448: 94 12 a2 a8 or %o2, 0x2a8, %o2 <== NOT EXECUTED 4000744c: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 40007450: 7f ff ee 2a call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007454: 90 12 23 88 or %o0, 0x388, %o0 ! 40021f88 <== NOT EXECUTED 40007458: 81 c7 e0 08 ret <== NOT EXECUTED 4000745c: 81 e8 00 00 restore <== NOT EXECUTED if (!rtems_rfs_fs_no_local_cache (fs) && 40007460: c2 07 40 00 ld [ %i5 ], %g1 40007464: 80 88 60 02 btst 2, %g1 40007468: 12 bf ff c1 bne 4000736c 4000746c: 96 06 60 08 add %i1, 8, %o3 if (fs->release_count) 40007470: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 40007474: 80 a0 60 00 cmp %g1, 0 40007478: 12 80 00 28 bne 40007518 4000747c: 94 10 00 1a mov %i2, %o2 if (!rtems_rfs_buffer_handle_has_block (handle) && 40007480: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 40007484: 80 a0 60 00 cmp %g1, 0 40007488: 02 bf ff b9 be 4000736c 4000748c: 96 06 60 08 add %i1, 8, %o3 handle->buffer = rtems_rfs_scan_chain (&fs->release_modified, 40007490: 94 10 00 1a mov %i2, %o2 40007494: 92 07 60 70 add %i5, 0x70, %o1 40007498: 7f ff fe 5f call 40006e14 4000749c: 90 07 60 64 add %i5, 0x64, %o0 400074a0: d0 26 60 08 st %o0, [ %i1 + 8 ] if (rtems_rfs_buffer_handle_has_block (handle)) 400074a4: 80 a2 20 00 cmp %o0, 0 400074a8: 02 bf ff b0 be 40007368 400074ac: 82 10 00 08 mov %o0, %g1 rtems_rfs_buffer_mark_dirty (handle); 400074b0: 84 10 20 01 mov 1, %g2 400074b4: 10 bf ff 89 b 400072d8 400074b8: c4 2e 40 00 stb %g2, [ %i1 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 400074bc: 40 00 0d c2 call 4000abc4 <== NOT EXECUTED 400074c0: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED 400074c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400074c8: 02 bf ff a3 be 40007354 <== NOT EXECUTED 400074cc: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", 400074d0: 12 80 00 1b bne 4000753c <== NOT EXECUTED 400074d4: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 400074d8: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 400074dc: 94 12 a2 b0 or %o2, 0x2b0, %o2 ! 40021eb0 <== NOT EXECUTED 400074e0: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED 400074e4: 40 00 60 4a call 4001f60c <== NOT EXECUTED 400074e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400074ec: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED 400074f0: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 400074f4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 400074f8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 400074fc: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 40007500: 7f ff ed fe call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007504: 90 12 23 50 or %o0, 0x350, %o0 ! 40021f50 <== NOT EXECUTED 40007508: 81 c7 e0 08 ret <== NOT EXECUTED 4000750c: 81 e8 00 00 restore <== NOT EXECUTED } 40007510: 81 c7 e0 08 ret <== NOT EXECUTED 40007514: 81 e8 00 00 restore <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->release, 40007518: 92 07 60 60 add %i5, 0x60, %o1 4000751c: 7f ff fe 3e call 40006e14 40007520: 90 07 60 54 add %i5, 0x54, %o0 40007524: d0 26 60 08 st %o0, [ %i1 + 8 ] if (!rtems_rfs_buffer_handle_has_block (handle) && 40007528: 80 a2 20 00 cmp %o0, 0 4000752c: 12 bf ff 6b bne 400072d8 40007530: 82 10 00 08 mov %o0, %g1 40007534: 10 bf ff d4 b 40007484 40007538: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", 4000753c: 10 bf ff e9 b 400074e0 <== NOT EXECUTED 40007540: 94 12 a2 a8 or %o2, 0x2a8, %o2 <== NOT EXECUTED =============================================================================== 40007568 : { 40007568: 9d e3 bf 38 save %sp, -200, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4000756c: 90 10 20 00 clr %o0 40007570: 40 00 0d 95 call 4000abc4 40007574: 92 10 20 20 mov 0x20, %o1 40007578: 80 a2 20 00 cmp %o0, 0 4000757c: 12 80 00 29 bne 40007620 <== NEVER TAKEN 40007580: 92 10 20 02 mov 2, %o1 fs->device = open (name, O_RDWR); 40007584: 40 00 2f 0a call 400131ac 40007588: 90 10 00 18 mov %i0, %o0 if (fs->device < 0) 4000758c: 80 a2 20 00 cmp %o0, 0 40007590: 06 80 00 2e bl 40007648 <== NEVER TAKEN 40007594: d0 26 60 0c st %o0, [ %i1 + 0xc ] if (fstat (fs->device, &st) < 0) 40007598: 40 00 2d fa call 40012d80 4000759c: 92 07 bf 98 add %fp, -104, %o1 400075a0: 80 a2 20 00 cmp %o0, 0 400075a4: 06 80 00 4b bl 400076d0 <== NEVER TAKEN 400075a8: 05 00 00 3c sethi %hi(0xf000), %g2 if (!S_ISBLK (st.st_mode)) 400075ac: c2 07 bf a8 ld [ %fp + -88 ], %g1 400075b0: 82 08 40 02 and %g1, %g2, %g1 400075b4: 05 00 00 18 sethi %hi(0x6000), %g2 400075b8: 80 a0 40 02 cmp %g1, %g2 400075bc: 12 80 00 11 bne 40007600 <== NEVER TAKEN 400075c0: 94 06 60 10 add %i1, 0x10, %o2 static inline int rtems_disk_fd_get_disk_device( int fd, rtems_disk_device **dd_ptr ) { return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr); 400075c4: d0 06 60 0c ld [ %i1 + 0xc ], %o0 400075c8: 13 10 01 10 sethi %hi(0x40044000), %o1 400075cc: 40 00 2e 38 call 40012eac 400075d0: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x17509> 400075d4: b0 10 00 08 mov %o0, %i0 if (rv != 0) 400075d8: 80 a6 20 00 cmp %i0, 0 400075dc: 12 80 00 33 bne 400076a8 <== NEVER TAKEN 400075e0: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 400075e4: 40 00 0d 78 call 4000abc4 400075e8: 92 10 20 20 mov 0x20, %o1 400075ec: 80 a2 20 00 cmp %o0, 0 400075f0: 32 80 00 21 bne,a 40007674 <== NEVER TAKEN 400075f4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED } 400075f8: 81 c7 e0 08 ret 400075fc: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 40007600: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007604: 40 00 0d 70 call 4000abc4 <== NOT EXECUTED 40007608: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4000760c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007610: 12 80 00 20 bne 40007690 <== NOT EXECUTED 40007614: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return ENXIO; 40007618: 81 c7 e0 08 ret <== NOT EXECUTED 4000761c: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: opening: %s\n", name); 40007620: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40007624: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 40007628: 7f ff ed b4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4000762c: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40021fc8 <== NOT EXECUTED fs->device = open (name, O_RDWR); 40007630: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 40007634: 40 00 2e de call 400131ac <== NOT EXECUTED 40007638: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (fs->device < 0) 4000763c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007640: 16 bf ff d6 bge 40007598 <== NOT EXECUTED 40007644: d0 26 60 0c st %o0, [ %i1 + 0xc ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 40007648: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000764c: 40 00 0d 5e call 4000abc4 <== NOT EXECUTED 40007650: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 40007654: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007658: 02 bf ff f0 be 40007618 <== NOT EXECUTED 4000765c: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED return ENXIO; 40007660: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: cannot open file\n"); 40007664: 7f ff ed b3 call 40002d30 <__wrap_puts> <== NOT EXECUTED 40007668: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED 4000766c: 81 c7 e0 08 ret <== NOT EXECUTED 40007670: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n", 40007674: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED 40007678: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED 4000767c: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 40007680: 7f ff ed 9e call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007684: 90 12 20 b8 or %o0, 0xb8, %o0 ! 400220b8 <== NOT EXECUTED } 40007688: 81 c7 e0 08 ret <== NOT EXECUTED 4000768c: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name); 40007690: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED return ENXIO; 40007694: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name); 40007698: 7f ff ed 98 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4000769c: 90 12 20 50 or %o0, 0x50, %o0 <== NOT EXECUTED 400076a0: 81 c7 e0 08 ret <== NOT EXECUTED 400076a4: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 400076a8: 40 00 0d 47 call 4000abc4 <== NOT EXECUTED 400076ac: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 400076b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400076b4: 02 bf ff d9 be 40007618 <== NOT EXECUTED 400076b8: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED return ENXIO; 400076bc: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: cannot obtain the disk\n"); 400076c0: 7f ff ed 9c call 40002d30 <__wrap_puts> <== NOT EXECUTED 400076c4: 90 12 20 88 or %o0, 0x88, %o0 <== NOT EXECUTED 400076c8: 81 c7 e0 08 ret <== NOT EXECUTED 400076cc: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 400076d0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400076d4: 40 00 0d 3c call 4000abc4 <== NOT EXECUTED 400076d8: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 400076dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400076e0: 02 bf ff ce be 40007618 <== NOT EXECUTED 400076e4: 01 00 00 00 nop <== NOT EXECUTED name, strerror (errno)); 400076e8: 40 00 5b 0d call 4001e31c <__errno> <== NOT EXECUTED 400076ec: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n", 400076f0: 40 00 5f c7 call 4001f60c <== NOT EXECUTED 400076f4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 400076f8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400076fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED return ENXIO; 40007700: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n", 40007704: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 40007708: 7f ff ed 7c call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4000770c: 90 12 20 20 or %o0, 0x20, %o0 ! 40022020 <== NOT EXECUTED 40007710: 81 c7 e0 08 ret <== NOT EXECUTED 40007714: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000781c : { 4000781c: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 40007820: 90 10 20 00 clr %o0 { 40007824: f2 27 a0 48 st %i1, [ %fp + 0x48 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 40007828: 40 00 0c e7 call 4000abc4 4000782c: 92 10 24 00 mov 0x400, %o1 40007830: 80 a2 20 00 cmp %o0, 0 40007834: 12 80 00 37 bne 40007910 <== NEVER TAKEN 40007838: d2 07 a0 48 ld [ %fp + 0x48 ], %o1 rc = rtems_rfs_buffers_release (fs); 4000783c: 7f ff ff d5 call 40007790 40007840: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 40007844: ba 92 20 00 orcc %o0, 0, %i5 40007848: 14 80 00 25 bg 400078dc <== NEVER TAKEN 4000784c: 90 10 20 00 clr %o0 rc = rtems_rfs_buffer_sync (fs); 40007850: 7f ff ff b2 call 40007718 40007854: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 40007858: ba 92 20 00 orcc %o0, 0, %i5 4000785c: 14 80 00 12 bg 400078a4 <== NEVER TAKEN 40007860: 90 10 20 00 clr %o0 rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size); 40007864: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 40007868: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 4000786c: 94 07 a0 48 add %fp, 0x48, %o2 40007870: 13 20 01 10 sethi %hi(0x80044000), %o1 40007874: 9f c0 40 00 call %g1 40007878: 92 12 62 04 or %o1, 0x204, %o1 ! 80044204 if (rc < 0) 4000787c: b0 92 20 00 orcc %o0, 0, %i0 40007880: 06 80 00 04 bl 40007890 <== NEVER TAKEN 40007884: 01 00 00 00 nop } 40007888: 81 c7 e0 08 ret 4000788c: 81 e8 00 00 restore rc = errno; 40007890: 40 00 5a a3 call 4001e31c <__errno> <== NOT EXECUTED 40007894: 01 00 00 00 nop <== NOT EXECUTED 40007898: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 4000789c: 81 c7 e0 08 ret <== NOT EXECUTED 400078a0: 81 e8 00 00 restore <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 400078a4: 40 00 0c c8 call 4000abc4 <== NOT EXECUTED 400078a8: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED 400078ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400078b0: 22 bf ff ee be,a 40007868 <== NOT EXECUTED 400078b4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n", 400078b8: 40 00 5f 55 call 4001f60c <== NOT EXECUTED 400078bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 400078c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 400078c4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400078c8: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 400078cc: 7f ff ed 0b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400078d0: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400221f0 <== NOT EXECUTED rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size); 400078d4: 10 bf ff e5 b 40007868 <== NOT EXECUTED 400078d8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 400078dc: 40 00 0c ba call 4000abc4 <== NOT EXECUTED 400078e0: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED 400078e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400078e8: 02 bf ff da be 40007850 <== NOT EXECUTED 400078ec: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n", 400078f0: 40 00 5f 47 call 4001f60c <== NOT EXECUTED 400078f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 400078f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 400078fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40007900: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 40007904: 7f ff ec fd call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007908: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400221b0 <== NOT EXECUTED 4000790c: 30 bf ff d1 b,a 40007850 <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size); 40007910: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 40007914: 7f ff ec f9 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007918: 90 12 21 80 or %o0, 0x180, %o0 ! 40022180 <== NOT EXECUTED 4000791c: 30 bf ff c8 b,a 4000783c <== NOT EXECUTED =============================================================================== 40007718 : { 40007718: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4000771c: 90 10 20 00 clr %o0 40007720: 40 00 0d 29 call 4000abc4 40007724: 92 10 20 20 mov 0x20, %o1 40007728: 80 a2 20 00 cmp %o0, 0 4000772c: 12 80 00 16 bne 40007784 <== NEVER TAKEN 40007730: 11 10 00 88 sethi %hi(0x40022000), %o0 sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs)); 40007734: 40 00 2a e1 call 400122b8 40007738: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 if (sc != RTEMS_SUCCESSFUL) 4000773c: ba 92 20 00 orcc %o0, 0, %i5 40007740: 02 80 00 0f be 4000777c <== ALWAYS TAKEN 40007744: b0 10 20 00 clr %i0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 40007748: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000774c: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED 40007750: 40 00 0d 1d call 4000abc4 <== NOT EXECUTED 40007754: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 40007758: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000775c: 02 80 00 08 be 4000777c <== NOT EXECUTED 40007760: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-sync: device sync failed: %s\n", 40007764: 40 00 0d 22 call 4000abec <== NOT EXECUTED 40007768: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4000776c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 40007770: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 40007774: 7f ff ed 61 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007778: 90 12 21 08 or %o0, 0x108, %o0 ! 40022108 <== NOT EXECUTED } 4000777c: 81 c7 e0 08 ret 40007780: 81 e8 00 00 restore printf ("rtems-rfs: buffer-sync: syncing\n"); 40007784: 7f ff ed 6b call 40002d30 <__wrap_puts> <== NOT EXECUTED 40007788: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED 4000778c: 30 bf ff ea b,a 40007734 <== NOT EXECUTED =============================================================================== 40007790 : int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) { 40007790: 9d e3 bf a0 save %sp, -96, %sp int rrc = 0; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) 40007794: 90 10 20 00 clr %o0 40007798: 40 00 0d 0b call 4000abc4 4000779c: 92 10 20 40 mov 0x40, %o1 400077a0: 80 a2 20 00 cmp %o0, 0 400077a4: 32 80 00 17 bne,a 40007800 <== NEVER TAKEN 400077a8: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED printf ("rtems-rfs: buffers-release: active:%" PRIu32 " " "release:%" PRIu32 " release-modified:%" PRIu32 "\n", fs->buffers_count, fs->release_count, fs->release_modified_count); rc = rtems_rfs_release_chain (&fs->release, 400077ac: 92 06 20 60 add %i0, 0x60, %o1 400077b0: 94 10 20 00 clr %o2 400077b4: 7f ff fd e0 call 40006f34 400077b8: 90 06 20 54 add %i0, 0x54, %o0 &fs->release_count, false); if ((rc > 0) && (rrc == 0)) rrc = rc; rc = rtems_rfs_release_chain (&fs->release_modified, 400077bc: 92 06 20 70 add %i0, 0x70, %o1 400077c0: 94 10 20 01 mov 1, %o2 rc = rtems_rfs_release_chain (&fs->release, 400077c4: ba 10 00 08 mov %o0, %i5 rc = rtems_rfs_release_chain (&fs->release_modified, 400077c8: 7f ff fd db call 40006f34 400077cc: 90 06 20 64 add %i0, 0x64, %o0 &fs->release_modified_count, true); if ((rc > 0) && (rrc == 0)) 400077d0: b0 92 20 00 orcc %o0, 0, %i0 400077d4: 04 80 00 06 ble 400077ec <== ALWAYS TAKEN 400077d8: 80 a7 60 00 cmp %i5, 0 400077dc: 34 80 00 05 bg,a 400077f0 <== NOT EXECUTED 400077e0: b0 38 00 1d xnor %g0, %i5, %i0 <== NOT EXECUTED rrc = rc; return rrc; } 400077e4: 81 c7 e0 08 ret <== NOT EXECUTED 400077e8: 81 e8 00 00 restore <== NOT EXECUTED 400077ec: b0 38 00 1d xnor %g0, %i5, %i0 400077f0: b1 3e 20 1f sra %i0, 0x1f, %i0 400077f4: b0 0f 40 18 and %i5, %i0, %i0 400077f8: 81 c7 e0 08 ret 400077fc: 81 e8 00 00 restore printf ("rtems-rfs: buffers-release: active:%" PRIu32 " " 40007800: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED 40007804: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED 40007808: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000780c: 7f ff ed 3b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40007810: 90 12 21 38 or %o0, 0x138, %o0 ! 40022138 <== NOT EXECUTED rc = rtems_rfs_release_chain (&fs->release, 40007814: 10 bf ff e7 b 400077b0 <== NOT EXECUTED 40007818: 92 06 20 60 add %i0, 0x60, %o1 <== NOT EXECUTED =============================================================================== 400153a8 : rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, const char* name, size_t length, rtems_rfs_ino ino) { 400153a8: 9d e3 bf 28 save %sp, -216, %sp rtems_rfs_block_map map; rtems_rfs_block_pos bpos; rtems_rfs_buffer_handle buffer; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 400153ac: 90 10 20 00 clr %o0 400153b0: 13 08 00 00 sethi %hi(0x20000000), %o1 400153b4: 7f ff d6 04 call 4000abc4 400153b8: a6 10 00 18 mov %i0, %l3 400153bc: 80 a2 20 00 cmp %o0, 0 400153c0: 12 80 00 a3 bne 4001564c <== NEVER TAKEN 400153c4: 92 10 00 19 mov %i1, %o1 for (c = 0; c < length; c++) printf ("%c", name[c]); printf (", len=%zd\n", length); } rc = rtems_rfs_block_map_open (fs, dir, &map); 400153c8: 94 07 bf b0 add %fp, -80, %o2 400153cc: 7f ff fb 58 call 4001412c 400153d0: 90 10 00 13 mov %l3, %o0 if (rc > 0) 400153d4: b0 92 20 00 orcc %o0, 0, %i0 400153d8: 14 80 00 34 bg 400154a8 <== NEVER TAKEN 400153dc: 29 00 00 3f sethi %hi(0xfc00), %l4 handle->dirty = false; 400153e0: c0 2f bf a4 clrb [ %fp + -92 ] handle->bnum = 0; 400153e4: c0 27 bf a8 clr [ %fp + -88 ] int elength; elength = rtems_rfs_dir_entry_length (entry); eino = rtems_rfs_dir_entry_ino (entry); if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 400153e8: a8 15 23 ff or %l4, 0x3ff, %l4 handle->buffer = NULL; 400153ec: c0 27 bf ac clr [ %fp + -84 ] { if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < 400153f0: a4 06 e0 0a add %i3, 0xa, %l2 bpos->bno = 0; 400153f4: c0 27 bf 98 clr [ %fp + -104 ] bpos->boff = 0; 400153f8: c0 27 bf 9c clr [ %fp + -100 ] bpos->block = 0; 400153fc: c0 27 bf a0 clr [ %fp + -96 ] rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block); 40015400: 96 07 bf 94 add %fp, -108, %o3 40015404: 94 07 bf 98 add %fp, -104, %o2 40015408: 92 07 bf b0 add %fp, -80, %o1 4001540c: 7f ff fc 16 call 40014464 40015410: 90 10 00 13 mov %l3, %o0 if (rc > 0) 40015414: b0 92 20 00 orcc %o0, 0, %i0 40015418: 04 80 00 a1 ble 4001569c 4001541c: 80 a6 20 06 cmp %i0, 6 if (rc != ENXIO) 40015420: 12 80 00 d1 bne 40015764 <== NEVER TAKEN 40015424: 96 07 bf 94 add %fp, -108, %o3 rc = rtems_rfs_block_map_grow (fs, &map, 1, &block); 40015428: 94 10 20 01 mov 1, %o2 4001542c: 92 07 bf b0 add %fp, -80, %o1 40015430: 7f ff fc 91 call 40014674 40015434: 90 10 00 13 mov %l3, %o0 if (rc > 0) 40015438: b0 92 20 00 orcc %o0, 0, %i0 4001543c: 14 80 00 b8 bg 4001571c <== NEVER TAKEN 40015440: c2 07 bf 98 ld [ %fp + -104 ], %g1 bpos.bno++; 40015444: 82 00 60 01 inc %g1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 40015448: d4 07 bf 94 ld [ %fp + -108 ], %o2 bpos.bno++; 4001544c: c2 27 bf 98 st %g1, [ %fp + -104 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 40015450: 96 10 20 00 clr %o3 40015454: 92 07 bf a4 add %fp, -92, %o1 40015458: 7f ff c7 72 call 40007220 4001545c: 90 10 00 13 mov %l3, %o0 if (rc > 0) 40015460: b0 92 20 00 orcc %o0, 0, %i0 40015464: 04 80 00 13 ble 400154b0 <== ALWAYS TAKEN 40015468: c2 07 bf ac ld [ %fp + -84 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001546c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40015470: 7f ff d5 d5 call 4000abc4 <== NOT EXECUTED 40015474: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 40015478: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001547c: 32 80 00 cc bne,a 400157ac <== NOT EXECUTED 40015480: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015484: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 40015488: 7f ff c8 2f call 40007544 <== NOT EXECUTED 4001548c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED offset += elength; } } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); 40015490: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 40015494: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 40015498: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED handle->bnum = 0; 4001549c: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 400154a0: 7f ff fb 82 call 400142a8 <== NOT EXECUTED 400154a4: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return rc; 400154a8: 81 c7 e0 08 ret <== NOT EXECUTED 400154ac: 81 e8 00 00 restore <== NOT EXECUTED entry = rtems_rfs_buffer_data (&buffer); 400154b0: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 memset (entry, 0xff, rtems_rfs_fs_block_size (fs)); 400154b4: d4 04 e0 08 ld [ %l3 + 8 ], %o2 400154b8: 92 10 20 ff mov 0xff, %o1 400154bc: 40 00 24 f8 call 4001e89c 400154c0: 90 10 00 1d mov %i5, %o0 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 400154c4: de 04 e0 08 ld [ %l3 + 8 ], %o7 400154c8: 88 83 ff f6 addcc %o7, -10, %g4 400154cc: 02 bf ff cd be 40015400 <== NEVER TAKEN 400154d0: b0 10 20 00 clr %i0 400154d4: 10 80 00 13 b 40015520 400154d8: 86 10 20 00 clr %g3 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 400154dc: 80 a4 20 0a cmp %l0, 0xa 400154e0: 04 80 00 4b ble 4001560c <== NEVER TAKEN 400154e4: 90 10 20 00 clr %o0 400154e8: c2 04 e0 1c ld [ %l3 + 0x1c ], %g1 400154ec: 80 a0 40 10 cmp %g1, %l0 400154f0: 08 80 00 47 bleu 4001560c <== NEVER TAKEN 400154f4: 80 a4 60 00 cmp %l1, 0 400154f8: 02 80 00 45 be 4001560c <== NEVER TAKEN 400154fc: 01 00 00 00 nop 40015500: c2 04 e0 14 ld [ %l3 + 0x14 ], %g1 40015504: 80 a0 40 11 cmp %g1, %l1 40015508: 0a 80 00 41 bcs 4001560c <== NEVER TAKEN 4001550c: ba 07 40 10 add %i5, %l0, %i5 offset += elength; 40015510: b0 06 00 10 add %i0, %l0, %i0 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40015514: 80 a1 00 18 cmp %g4, %i0 40015518: 08 bf ff ba bleu 40015400 <== NEVER TAKEN 4001551c: 86 10 00 18 mov %i0, %g3 entry += elength; 40015520: d4 0f 60 08 ldub [ %i5 + 8 ], %o2 40015524: e0 0f 60 09 ldub [ %i5 + 9 ], %l0 eino = rtems_rfs_dir_entry_ino (entry); 40015528: c4 0f 40 00 ldub [ %i5 ], %g2 4001552c: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 40015530: d6 0f 60 02 ldub [ %i5 + 2 ], %o3 40015534: e2 0f 60 03 ldub [ %i5 + 3 ], %l1 40015538: 95 2a a0 08 sll %o2, 8, %o2 4001553c: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 40015540: a0 14 00 0a or %l0, %o2, %l0 eino = rtems_rfs_dir_entry_ino (entry); 40015544: 83 28 60 10 sll %g1, 0x10, %g1 40015548: 97 2a e0 08 sll %o3, 8, %o3 4001554c: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40015550: 80 a4 00 14 cmp %l0, %l4 eino = rtems_rfs_dir_entry_ino (entry); 40015554: 96 12 c0 01 or %o3, %g1, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40015558: 12 bf ff e1 bne 400154dc 4001555c: a2 14 40 0b or %l1, %o3, %l1 (rtems_rfs_fs_block_size (fs) - offset)) 40015560: 86 23 c0 03 sub %o7, %g3, %g3 if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < 40015564: 80 a4 80 03 cmp %l2, %g3 40015568: 1a bf ff a7 bcc 40015404 <== NEVER TAKEN 4001556c: 96 07 bf 94 add %fp, -108, %o3 hash = rtems_rfs_dir_hash (name, length); 40015570: 92 10 00 1b mov %i3, %o1 40015574: 40 00 03 32 call 4001623c 40015578: 90 10 00 1a mov %i2, %o0 rtems_rfs_dir_set_entry_hash (entry, hash); 4001557c: 87 32 20 18 srl %o0, 0x18, %g3 40015580: 85 32 20 10 srl %o0, 0x10, %g2 40015584: 83 32 20 08 srl %o0, 8, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 40015588: f8 2f 60 03 stb %i4, [ %i5 + 3 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001558c: 94 10 00 1b mov %i3, %o2 rtems_rfs_dir_set_entry_hash (entry, hash); 40015590: c6 2f 60 04 stb %g3, [ %i5 + 4 ] rtems_rfs_dir_set_entry_ino (entry, ino); 40015594: 87 37 20 18 srl %i4, 0x18, %g3 rtems_rfs_dir_set_entry_hash (entry, hash); 40015598: c4 2f 60 05 stb %g2, [ %i5 + 5 ] rtems_rfs_dir_set_entry_ino (entry, ino); 4001559c: 85 37 20 10 srl %i4, 0x10, %g2 rtems_rfs_dir_set_entry_hash (entry, hash); 400155a0: c2 2f 60 06 stb %g1, [ %i5 + 6 ] rtems_rfs_dir_set_entry_ino (entry, ino); 400155a4: b9 37 20 08 srl %i4, 8, %i4 rtems_rfs_dir_set_entry_hash (entry, hash); 400155a8: d0 2f 60 07 stb %o0, [ %i5 + 7 ] rtems_rfs_dir_set_entry_length (entry, 400155ac: 83 2c a0 10 sll %l2, 0x10, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 400155b0: c6 2f 40 00 stb %g3, [ %i5 ] rtems_rfs_dir_set_entry_length (entry, 400155b4: 83 30 60 18 srl %g1, 0x18, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 400155b8: c4 2f 60 01 stb %g2, [ %i5 + 1 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 400155bc: 92 10 00 1a mov %i2, %o1 rtems_rfs_dir_set_entry_length (entry, 400155c0: c2 2f 60 08 stb %g1, [ %i5 + 8 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 400155c4: 90 07 60 0a add %i5, 0xa, %o0 rtems_rfs_dir_set_entry_length (entry, 400155c8: e4 2f 60 09 stb %l2, [ %i5 + 9 ] return 0; 400155cc: b0 10 20 00 clr %i0 memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 400155d0: 40 00 24 29 call 4001e674 400155d4: f8 2f 60 02 stb %i4, [ %i5 + 2 ] rtems_rfs_buffer_mark_dirty (&buffer); 400155d8: 82 10 20 01 mov 1, %g1 rtems_rfs_buffer_handle_release (fs, handle); 400155dc: 92 07 bf a4 add %fp, -92, %o1 400155e0: c2 2f bf a4 stb %g1, [ %fp + -92 ] 400155e4: 7f ff c7 d8 call 40007544 400155e8: 90 10 00 13 mov %l3, %o0 rtems_rfs_block_map_close (fs, &map); 400155ec: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 400155f0: c0 2f bf a4 clrb [ %fp + -92 ] 400155f4: 90 10 00 13 mov %l3, %o0 handle->bnum = 0; 400155f8: c0 27 bf a8 clr [ %fp + -88 ] 400155fc: 7f ff fb 2b call 400142a8 40015600: c0 27 bf ac clr [ %fp + -84 ] return 0; 40015604: 81 c7 e0 08 ret 40015608: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001560c: 7f ff d5 6e call 4000abc4 <== NOT EXECUTED 40015610: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 40015614: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015618: 12 80 00 2e bne 400156d0 <== NOT EXECUTED 4001561c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015620: 7f ff c7 c9 call 40007544 <== NOT EXECUTED 40015624: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED return EIO; 40015628: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED handle->dirty = false; 4001562c: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 40015630: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->bnum = 0; 40015634: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 40015638: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001563c: 7f ff fb 1b call 400142a8 <== NOT EXECUTED 40015640: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return EIO; 40015644: 81 c7 e0 08 ret <== NOT EXECUTED 40015648: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=", 4001564c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015650: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 40015654: 7f ff b5 a9 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015658: 90 12 21 70 or %o0, 0x170, %o0 ! 40023970 <== NOT EXECUTED for (c = 0; c < length; c++) 4001565c: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 40015660: 02 80 00 09 be 40015684 <== NOT EXECUTED 40015664: b0 06 80 1b add %i2, %i3, %i0 <== NOT EXECUTED 40015668: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED printf ("%c", name[c]); 4001566c: 40 00 24 d1 call 4001e9b0 <== NOT EXECUTED 40015670: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED for (c = 0; c < length; c++) 40015674: ba 07 60 01 inc %i5 <== NOT EXECUTED 40015678: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED 4001567c: 12 bf ff fc bne 4001566c <== NOT EXECUTED 40015680: 01 00 00 00 nop <== NOT EXECUTED printf (", len=%zd\n", length); 40015684: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40015688: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001568c: 7f ff b5 9b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015690: 90 12 21 98 or %o0, 0x198, %o0 ! 40023998 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 40015694: 10 bf ff 4d b 400153c8 <== NOT EXECUTED 40015698: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED bpos.bno++; 4001569c: c2 07 bf 98 ld [ %fp + -104 ], %g1 400156a0: 82 00 60 01 inc %g1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 400156a4: d4 07 bf 94 ld [ %fp + -108 ], %o2 bpos.bno++; 400156a8: c2 27 bf 98 st %g1, [ %fp + -104 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 400156ac: 96 10 20 01 mov 1, %o3 400156b0: 92 07 bf a4 add %fp, -92, %o1 400156b4: 7f ff c6 db call 40007220 400156b8: 90 10 00 13 mov %l3, %o0 if (rc > 0) 400156bc: b0 92 20 00 orcc %o0, 0, %i0 400156c0: 14 bf ff 6b bg 4001546c <== NEVER TAKEN 400156c4: c2 07 bf ac ld [ %fp + -84 ], %g1 entry = rtems_rfs_buffer_data (&buffer); 400156c8: 10 bf ff 7f b 400154c4 400156cc: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 printf ("rtems-rfs: dir-add-entry: " 400156d0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 400156d4: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED 400156d8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED 400156dc: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 400156e0: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 400156e4: 7f ff b5 85 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400156e8: 90 12 22 80 or %o0, 0x280, %o0 ! 40023a80 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 400156ec: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 400156f0: 7f ff c7 95 call 40007544 <== NOT EXECUTED 400156f4: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED return EIO; 400156f8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED handle->dirty = false; 400156fc: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 40015700: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->bnum = 0; 40015704: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 40015708: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001570c: 7f ff fa e7 call 400142a8 <== NOT EXECUTED 40015710: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return EIO; 40015714: 81 c7 e0 08 ret <== NOT EXECUTED 40015718: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001571c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40015720: 7f ff d5 29 call 4000abc4 <== NOT EXECUTED 40015724: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 40015728: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001572c: 22 bf ff 57 be,a 40015488 <== NOT EXECUTED 40015730: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 40015734: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015738: d2 27 bf 8c st %o1, [ %fp + -116 ] <== NOT EXECUTED 4001573c: 40 00 27 b4 call 4001f60c <== NOT EXECUTED 40015740: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40015744: d2 07 bf 8c ld [ %fp + -116 ], %o1 <== NOT EXECUTED 40015748: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001574c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED 40015750: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 40015754: 7f ff b5 69 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015758: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400239f0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001575c: 10 bf ff 4b b 40015488 <== NOT EXECUTED 40015760: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 40015764: 90 10 20 00 clr %o0 <== NOT EXECUTED 40015768: 7f ff d5 17 call 4000abc4 <== NOT EXECUTED 4001576c: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 40015770: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015774: 22 bf ff 45 be,a 40015488 <== NOT EXECUTED 40015778: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 4001577c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015780: d2 27 bf 8c st %o1, [ %fp + -116 ] <== NOT EXECUTED 40015784: 40 00 27 a2 call 4001f60c <== NOT EXECUTED 40015788: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001578c: d2 07 bf 8c ld [ %fp + -116 ], %o1 <== NOT EXECUTED 40015790: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40015794: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED 40015798: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001579c: 7f ff b5 57 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400157a0: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400239a8 <== NOT EXECUTED 400157a4: 10 bf ff 39 b 40015488 <== NOT EXECUTED 400157a8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 400157ac: d2 27 bf 8c st %o1, [ %fp + -116 ] <== NOT EXECUTED 400157b0: 40 00 27 97 call 4001f60c <== NOT EXECUTED 400157b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400157b8: d2 07 bf 8c ld [ %fp + -116 ], %o1 <== NOT EXECUTED 400157bc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 400157c0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED 400157c4: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 400157c8: 7f ff b5 4c call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400157cc: 90 12 22 38 or %o0, 0x238, %o0 ! 40023a38 <== NOT EXECUTED 400157d0: 10 bf ff 2e b 40015488 <== NOT EXECUTED 400157d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 400157d8 : int rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_ino ino, uint32_t offset) { 400157d8: 9d e3 bf 38 save %sp, -200, %sp rtems_rfs_block_no block; rtems_rfs_buffer_handle buffer; bool search; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 400157dc: 90 10 20 00 clr %o0 400157e0: 13 10 00 00 sethi %hi(0x40000000), %o1 400157e4: 7f ff d4 f8 call 4000abc4 400157e8: a2 10 00 18 mov %i0, %l1 400157ec: 80 a2 20 00 cmp %o0, 0 400157f0: 32 80 00 77 bne,a 400159cc <== NEVER TAKEN 400157f4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n", rtems_rfs_inode_ino (dir), ino, offset); rc = rtems_rfs_block_map_open (fs, dir, &map); 400157f8: 92 10 00 19 mov %i1, %o1 400157fc: 94 07 bf b0 add %fp, -80, %o2 40015800: 7f ff fa 4b call 4001412c 40015804: 90 10 00 11 mov %l1, %o0 if (rc > 0) 40015808: b0 92 20 00 orcc %o0, 0, %i0 4001580c: 14 80 00 6e bg 400159c4 <== NEVER TAKEN 40015810: 94 10 20 00 clr %o2 return rc; rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 40015814: 98 07 bf a0 add %fp, -96, %o4 40015818: 96 10 00 1b mov %i3, %o3 4001581c: 92 07 bf b0 add %fp, -80, %o1 40015820: 7f ff fb 6a call 400145c8 40015824: 90 10 00 11 mov %l1, %o0 if (rc > 0) 40015828: b0 92 20 00 orcc %o0, 0, %i0 4001582c: 14 80 00 81 bg 40015a30 <== NEVER TAKEN 40015830: 27 00 00 3f sethi %hi(0xfc00), %l3 handle->dirty = false; 40015834: c0 2f bf a4 clrb [ %fp + -92 ] handle->bnum = 0; 40015838: c0 27 bf a8 clr [ %fp + -88 ] int elength; elength = rtems_rfs_dir_entry_length (entry); eino = rtems_rfs_dir_entry_ino (entry); if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001583c: a6 14 e3 ff or %l3, 0x3ff, %l3 handle->buffer = NULL; 40015840: c0 27 bf ac clr [ %fp + -84 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 40015844: 96 10 20 01 mov 1, %o3 40015848: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001584c: 92 07 bf a4 add %fp, -92, %o1 40015850: 7f ff c6 74 call 40007220 40015854: 90 10 00 11 mov %l1, %o0 if (rc > 0) 40015858: b0 92 20 00 orcc %o0, 0, %i0 4001585c: 14 80 00 d9 bg 40015bc0 <== NEVER TAKEN 40015860: 80 a6 e0 00 cmp %i3, 0 if (search) 40015864: 02 80 00 46 be 4001597c <== NEVER TAKEN 40015868: de 04 60 08 ld [ %l1 + 8 ], %o7 eoffset = offset % rtems_rfs_fs_block_size (fs); 4001586c: 81 80 20 00 wr %g0, %y 40015870: 01 00 00 00 nop 40015874: 01 00 00 00 nop 40015878: 01 00 00 00 nop 4001587c: 82 76 c0 0f udiv %i3, %o7, %g1 40015880: 82 58 40 0f smul %g1, %o7, %g1 40015884: 82 26 c0 01 sub %i3, %g1, %g1 40015888: a4 10 00 01 mov %g1, %l2 entry = rtems_rfs_buffer_data (&buffer) + eoffset; 4001588c: c4 07 bf ac ld [ %fp + -84 ], %g2 40015890: fa 00 a0 1c ld [ %g2 + 0x1c ], %i5 while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40015894: 9a 03 ff f6 add %o7, -10, %o5 40015898: 80 a3 40 01 cmp %o5, %g1 4001589c: 18 80 00 19 bgu 40015900 <== ALWAYS TAKEN 400158a0: ba 07 40 01 add %i5, %g1, %i5 entry += elength; eoffset += elength; } if (rc == 0) 400158a4: 10 80 00 28 b 40015944 <== NOT EXECUTED 400158a8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 400158ac: 80 a7 20 0a cmp %i4, 0xa 400158b0: 04 80 00 36 ble 40015988 <== NEVER TAKEN 400158b4: 90 10 20 00 clr %o0 400158b8: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 400158bc: 80 a0 40 1c cmp %g1, %i4 400158c0: 08 80 00 32 bleu 40015988 <== NEVER TAKEN 400158c4: 80 a4 20 00 cmp %l0, 0 400158c8: 02 80 00 31 be 4001598c <== NEVER TAKEN 400158cc: 13 10 00 00 sethi %hi(0x40000000), %o1 400158d0: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 400158d4: 80 a0 40 10 cmp %g1, %l0 400158d8: 0a 80 00 2c bcs 40015988 <== NEVER TAKEN 400158dc: 80 a6 80 10 cmp %i2, %l0 if (ino == rtems_rfs_dir_entry_ino (entry)) 400158e0: 02 80 00 5c be 40015a50 <== ALWAYS TAKEN 400158e4: 80 a6 e0 00 cmp %i3, 0 if (!search) 400158e8: 32 80 00 2e bne,a 400159a0 <== NOT EXECUTED 400158ec: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED eoffset += elength; 400158f0: a4 04 80 1c add %l2, %i4, %l2 <== NOT EXECUTED while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 400158f4: 80 a3 40 12 cmp %o5, %l2 <== NOT EXECUTED 400158f8: 08 80 00 12 bleu 40015940 <== NOT EXECUTED 400158fc: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED entry += elength; 40015900: c8 0f 60 08 ldub [ %i5 + 8 ], %g4 40015904: f8 0f 60 09 ldub [ %i5 + 9 ], %i4 eino = rtems_rfs_dir_entry_ino (entry); 40015908: c6 0f 40 00 ldub [ %i5 ], %g3 4001590c: c4 0f 60 01 ldub [ %i5 + 1 ], %g2 40015910: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 40015914: e0 0f 60 03 ldub [ %i5 + 3 ], %l0 40015918: 89 29 20 08 sll %g4, 8, %g4 4001591c: 87 28 e0 18 sll %g3, 0x18, %g3 elength = rtems_rfs_dir_entry_length (entry); 40015920: b8 17 00 04 or %i4, %g4, %i4 eino = rtems_rfs_dir_entry_ino (entry); 40015924: 85 28 a0 10 sll %g2, 0x10, %g2 40015928: 83 28 60 08 sll %g1, 8, %g1 4001592c: 84 10 80 03 or %g2, %g3, %g2 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40015930: 80 a7 00 13 cmp %i4, %l3 eino = rtems_rfs_dir_entry_ino (entry); 40015934: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40015938: 12 bf ff dd bne 400158ac <== ALWAYS TAKEN 4001593c: a0 14 00 01 or %l0, %g1, %l0 if (rc == 0) 40015940: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 40015944: 12 80 00 18 bne 400159a4 <== NOT EXECUTED 40015948: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED { rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001594c: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED 40015950: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 40015954: 7f ff fb 3b call 40014640 <== NOT EXECUTED 40015958: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED if (rc == ENXIO) 4001595c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED 40015960: 02 80 00 aa be 40015c08 <== NOT EXECUTED 40015964: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED while (rc == 0) 40015968: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001596c: 02 bf ff b7 be 40015848 <== NOT EXECUTED 40015970: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015974: 10 80 00 0c b 400159a4 <== NOT EXECUTED 40015978: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001597c: 82 10 20 00 clr %g1 <== NOT EXECUTED eoffset = 0; 40015980: 10 bf ff c3 b 4001588c <== NOT EXECUTED 40015984: a4 10 20 00 clr %l2 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 40015988: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001598c: 7f ff d4 8e call 4000abc4 <== NOT EXECUTED 40015990: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 40015994: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015998: 12 80 00 14 bne 400159e8 <== NOT EXECUTED 4001599c: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED 400159a0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 400159a4: 7f ff c6 e8 call 40007544 <== NOT EXECUTED 400159a8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED rc = ENOENT; } } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); 400159ac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 400159b0: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 400159b4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED handle->bnum = 0; 400159b8: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 400159bc: 7f ff fa 3b call 400142a8 <== NOT EXECUTED 400159c0: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return rc; 400159c4: 81 c7 e0 08 ret <== NOT EXECUTED 400159c8: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n", 400159cc: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 400159d0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 400159d4: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 400159d8: 7f ff b4 c8 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400159dc: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 40023ac8 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 400159e0: 10 bf ff 87 b 400157fc <== NOT EXECUTED 400159e4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 400159e8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 400159ec: 9a 10 00 12 mov %l2, %o5 <== NOT EXECUTED 400159f0: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 400159f4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 400159f8: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 400159fc: 7f ff b4 bf call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015a00: 90 12 23 48 or %o0, 0x348, %o0 ! 40023b48 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015a04: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 40015a08: 7f ff c6 cf call 40007544 <== NOT EXECUTED 40015a0c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 40015a10: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 40015a14: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 40015a18: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED handle->bnum = 0; 40015a1c: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 40015a20: 7f ff fa 22 call 400142a8 <== NOT EXECUTED 40015a24: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return rc; 40015a28: 81 c7 e0 08 ret <== NOT EXECUTED 40015a2c: 81 e8 00 00 restore <== NOT EXECUTED if (rc == ENXIO) 40015a30: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED 40015a34: 22 80 00 02 be,a 40015a3c <== NOT EXECUTED 40015a38: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 40015a3c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 40015a40: 7f ff fa 1a call 400142a8 <== NOT EXECUTED 40015a44: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED return rc; 40015a48: 81 c7 e0 08 ret <== NOT EXECUTED 40015a4c: 81 e8 00 00 restore <== NOT EXECUTED memmove (entry, entry + elength, remaining); 40015a50: 92 07 40 1c add %i5, %i4, %o1 40015a54: 90 10 00 1d mov %i5, %o0 remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength); 40015a58: b6 04 80 1c add %l2, %i4, %i3 40015a5c: b6 23 c0 1b sub %o7, %i3, %i3 memmove (entry, entry + elength, remaining); 40015a60: 40 00 23 44 call 4001e770 40015a64: 94 10 00 1b mov %i3, %o2 memset (entry + remaining, 0xff, elength); 40015a68: 94 10 00 1c mov %i4, %o2 40015a6c: 92 10 20 ff mov 0xff, %o1 40015a70: 40 00 23 8b call 4001e89c 40015a74: 90 07 40 1b add %i5, %i3, %o0 elength = rtems_rfs_dir_entry_length (entry); 40015a78: d4 0f 60 08 ldub [ %i5 + 8 ], %o2 40015a7c: 95 2a a0 08 sll %o2, 8, %o2 40015a80: fa 0f 60 09 ldub [ %i5 + 9 ], %i5 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 40015a84: 90 10 20 00 clr %o0 40015a88: 13 10 00 00 sethi %hi(0x40000000), %o1 40015a8c: 7f ff d4 4e call 4000abc4 40015a90: ba 17 40 0a or %i5, %o2, %i5 40015a94: 80 a2 20 00 cmp %o0, 0 40015a98: 02 80 00 10 be 40015ad8 <== ALWAYS TAKEN 40015a9c: 03 3f ff c0 sethi %hi(0xffff0000), %g1 rtems_rfs_block_map_last (&map) ? "yes" : "no"); 40015aa0: c4 07 bf c0 ld [ %fp + -64 ], %g2 <== NOT EXECUTED 40015aa4: c2 07 bf b8 ld [ %fp + -72 ], %g1 <== NOT EXECUTED 40015aa8: 80 90 80 01 orcc %g2, %g1, %g0 <== NOT EXECUTED 40015aac: 12 80 00 3f bne 40015ba8 <== NOT EXECUTED 40015ab0: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 40015ab4: 1b 10 00 8b sethi %hi(0x40022c00), %o5 <== NOT EXECUTED 40015ab8: 9a 13 60 f8 or %o5, 0xf8, %o5 ! 40022cf8 <== NOT EXECUTED 40015abc: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 40015ac0: 98 10 00 12 mov %l2, %o4 <== NOT EXECUTED 40015ac4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 40015ac8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 40015acc: 7f ff b4 8b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015ad0: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) && 40015ad4: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED 40015ad8: 82 38 40 1d xnor %g1, %i5, %g1 40015adc: 80 a0 60 00 cmp %g1, 0 40015ae0: 12 80 00 1f bne 40015b5c 40015ae4: 80 a4 a0 00 cmp %l2, 0 40015ae8: 12 80 00 1d bne 40015b5c <== ALWAYS TAKEN 40015aec: c4 07 bf c0 ld [ %fp + -64 ], %g2 (eoffset == 0) && rtems_rfs_block_map_last (&map)) 40015af0: c2 07 bf b8 ld [ %fp + -72 ], %g1 <== NOT EXECUTED 40015af4: 80 90 80 01 orcc %g2, %g1, %g0 <== NOT EXECUTED 40015af8: 12 80 00 27 bne 40015b94 <== NOT EXECUTED 40015afc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED rc = rtems_rfs_block_map_shrink (fs, &map, 1); 40015b00: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 40015b04: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 40015b08: 7f ff fb cf call 40014a44 <== NOT EXECUTED 40015b0c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED if (rc > 0) 40015b10: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 40015b14: 04 80 00 13 ble 40015b60 <== NOT EXECUTED 40015b18: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 40015b1c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40015b20: 7f ff d4 29 call 4000abc4 <== NOT EXECUTED 40015b24: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 40015b28: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015b2c: 02 80 00 0d be 40015b60 <== NOT EXECUTED 40015b30: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 40015b34: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015b38: d2 27 bf 9c st %o1, [ %fp + -100 ] <== NOT EXECUTED 40015b3c: 40 00 26 b4 call 4001f60c <== NOT EXECUTED 40015b40: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 40015b44: d2 07 bf 9c ld [ %fp + -100 ], %o1 <== NOT EXECUTED 40015b48: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40015b4c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 40015b50: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 40015b54: 7f ff b4 69 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015b58: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 40023bf8 <== NOT EXECUTED rtems_rfs_buffer_mark_dirty (&buffer); 40015b5c: 82 10 20 01 mov 1, %g1 rtems_rfs_buffer_handle_release (fs, handle); 40015b60: 92 07 bf a4 add %fp, -92, %o1 40015b64: c2 2f bf a4 stb %g1, [ %fp + -92 ] 40015b68: 7f ff c6 77 call 40007544 40015b6c: 90 10 00 11 mov %l1, %o0 return 0; 40015b70: b0 10 20 00 clr %i0 handle->dirty = false; 40015b74: c0 2f bf a4 clrb [ %fp + -92 ] rtems_rfs_block_map_close (fs, &map); 40015b78: 92 07 bf b0 add %fp, -80, %o1 handle->bnum = 0; 40015b7c: c0 27 bf a8 clr [ %fp + -88 ] 40015b80: 90 10 00 11 mov %l1, %o0 40015b84: 7f ff f9 c9 call 400142a8 40015b88: c0 27 bf ac clr [ %fp + -84 ] return 0; 40015b8c: 81 c7 e0 08 ret 40015b90: 81 e8 00 00 restore (eoffset == 0) && rtems_rfs_block_map_last (&map)) 40015b94: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40015b98: 12 bf ff f2 bne 40015b60 <== NOT EXECUTED 40015b9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40015ba0: 10 bf ff d9 b 40015b04 <== NOT EXECUTED 40015ba4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED rtems_rfs_block_map_last (&map) ? "yes" : "no"); 40015ba8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40015bac: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40015bb0: 02 bf ff c1 be 40015ab4 <== NOT EXECUTED 40015bb4: 1b 10 00 8b sethi %hi(0x40022c00), %o5 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 40015bb8: 10 bf ff c1 b 40015abc <== NOT EXECUTED 40015bbc: 9a 13 61 00 or %o5, 0x100, %o5 ! 40022d00 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 40015bc0: 90 10 20 00 clr %o0 <== NOT EXECUTED 40015bc4: 7f ff d4 00 call 4000abc4 <== NOT EXECUTED 40015bc8: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 40015bcc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015bd0: 22 bf ff 75 be,a 400159a4 <== NOT EXECUTED 40015bd4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 40015bd8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015bdc: d2 27 bf 9c st %o1, [ %fp + -100 ] <== NOT EXECUTED 40015be0: 40 00 26 8b call 4001f60c <== NOT EXECUTED 40015be4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40015be8: d2 07 bf 9c ld [ %fp + -100 ], %o1 <== NOT EXECUTED 40015bec: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40015bf0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED 40015bf4: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 40015bf8: 7f ff b4 40 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015bfc: 90 12 23 00 or %o0, 0x300, %o0 ! 40023b00 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015c00: 10 bf ff 69 b 400159a4 <== NOT EXECUTED 40015c04: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = ENOENT; 40015c08: 10 bf ff 66 b 400159a0 <== NOT EXECUTED 40015c0c: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED =============================================================================== 40015fdc : int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) { 40015fdc: 9d e3 bf 40 save %sp, -192, %sp rtems_rfs_buffer_handle buffer; rtems_rfs_block_no block; bool empty; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015fe0: 90 10 20 00 clr %o0 40015fe4: 13 20 00 00 sethi %hi(0x80000000), %o1 40015fe8: 7f ff d2 f7 call 4000abc4 40015fec: a2 10 00 18 mov %i0, %l1 40015ff0: 80 a2 20 00 cmp %o0, 0 40015ff4: 32 80 00 7b bne,a 400161e0 <== NEVER TAKEN 40015ff8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir)); empty = true; rc = rtems_rfs_block_map_open (fs, dir, &map); 40015ffc: 92 10 00 19 mov %i1, %o1 40016000: 94 07 bf b0 add %fp, -80, %o2 40016004: 7f ff f8 4a call 4001412c 40016008: 90 10 00 11 mov %l1, %o0 if (rc > 0) 4001600c: b0 92 20 00 orcc %o0, 0, %i0 40016010: 14 80 00 5c bg 40016180 <== NEVER TAKEN 40016014: 94 10 20 00 clr %o2 return rc; rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 40016018: 96 10 20 00 clr %o3 4001601c: 98 07 bf a0 add %fp, -96, %o4 40016020: 92 07 bf b0 add %fp, -80, %o1 40016024: 7f ff f9 69 call 400145c8 40016028: 90 10 00 11 mov %l1, %o0 if (rc > 0) 4001602c: b0 92 20 00 orcc %o0, 0, %i0 40016030: 14 80 00 71 bg 400161f4 <== NEVER TAKEN 40016034: 25 00 00 3f sethi %hi(0xfc00), %l2 handle->dirty = false; 40016038: c0 2f bf a4 clrb [ %fp + -92 ] handle->bnum = 0; 4001603c: c0 27 bf a8 clr [ %fp + -88 ] break; if (rtems_rfs_dir_entry_valid (fs, elength, eino)) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) printf ("rtems-rfs: dir-empty: " 40016040: 21 10 00 8f sethi %hi(0x40023c00), %l0 handle->buffer = NULL; 40016044: c0 27 bf ac clr [ %fp + -84 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40016048: a4 14 a3 ff or %l2, 0x3ff, %l2 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) 4001604c: b4 10 20 01 mov 1, %i2 40016050: b6 10 20 00 clr %i3 printf ("rtems-rfs: dir-empty: " 40016054: a0 14 21 48 or %l0, 0x148, %l0 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 40016058: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001605c: 96 10 20 01 mov 1, %o3 40016060: 92 07 bf a4 add %fp, -92, %o1 40016064: 7f ff c4 6f call 40007220 40016068: 90 10 00 11 mov %l1, %o0 if (rc > 0) 4001606c: b0 92 20 00 orcc %o0, 0, %i0 40016070: 14 80 00 3b bg 4001615c <== NEVER TAKEN 40016074: c2 07 bf ac ld [ %fp + -84 ], %g1 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40016078: c8 04 60 08 ld [ %l1 + 8 ], %g4 4001607c: 88 81 3f f6 addcc %g4, -10, %g4 40016080: 02 80 00 4c be 400161b0 <== NEVER TAKEN 40016084: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 offset = 0; 40016088: 10 80 00 10 b 400160c8 4001608c: a6 10 20 00 clr %l3 /* * Ignore the current (.) and parent (..) entries. Anything else means * the directory is not empty. */ if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) || (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) && 40016090: 12 80 00 31 bne 40016154 40016094: 80 a6 20 00 cmp %i0, 0 ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) || 40016098: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 4001609c: 80 a0 a0 2e cmp %g2, 0x2e 400160a0: 12 80 00 2d bne 40016154 <== NEVER TAKEN 400160a4: 80 a6 20 00 cmp %i0, 0 (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') || 400160a8: c4 08 60 0b ldub [ %g1 + 0xb ], %g2 400160ac: 80 a0 a0 2e cmp %g2, 0x2e 400160b0: 12 80 00 29 bne 40016154 <== NEVER TAKEN 400160b4: 80 a6 20 00 cmp %i0, 0 empty = false; break; } entry += elength; offset += elength; 400160b8: a6 04 c0 1d add %l3, %i5, %l3 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 400160bc: 80 a4 c0 04 cmp %l3, %g4 400160c0: 1a 80 00 3c bcc 400161b0 <== NEVER TAKEN 400160c4: 82 00 40 1d add %g1, %i5, %g1 elength = rtems_rfs_dir_entry_length (entry); 400160c8: d4 08 60 08 ldub [ %g1 + 8 ], %o2 400160cc: fa 08 60 09 ldub [ %g1 + 9 ], %i5 eino = rtems_rfs_dir_entry_ino (entry); 400160d0: c6 08 40 00 ldub [ %g1 ], %g3 400160d4: c4 08 60 01 ldub [ %g1 + 1 ], %g2 400160d8: d6 08 60 02 ldub [ %g1 + 2 ], %o3 400160dc: f8 08 60 03 ldub [ %g1 + 3 ], %i4 400160e0: 95 2a a0 08 sll %o2, 8, %o2 400160e4: 87 28 e0 18 sll %g3, 0x18, %g3 elength = rtems_rfs_dir_entry_length (entry); 400160e8: ba 17 40 0a or %i5, %o2, %i5 eino = rtems_rfs_dir_entry_ino (entry); 400160ec: 85 28 a0 10 sll %g2, 0x10, %g2 400160f0: 97 2a e0 08 sll %o3, 8, %o3 400160f4: 84 10 80 03 or %g2, %g3, %g2 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 400160f8: 80 a7 40 12 cmp %i5, %l2 eino = rtems_rfs_dir_entry_ino (entry); 400160fc: 96 12 c0 02 or %o3, %g2, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40016100: 02 80 00 2c be 400161b0 40016104: b8 17 00 0b or %i4, %o3, %i4 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 40016108: 80 a7 60 0a cmp %i5, 0xa 4001610c: 04 80 00 1f ble 40016188 <== NEVER TAKEN 40016110: 90 10 00 1a mov %i2, %o0 40016114: c4 04 60 1c ld [ %l1 + 0x1c ], %g2 40016118: 80 a0 80 1d cmp %g2, %i5 4001611c: 08 80 00 1b bleu 40016188 <== NEVER TAKEN 40016120: 80 a7 20 00 cmp %i4, 0 40016124: 02 80 00 19 be 40016188 <== NEVER TAKEN 40016128: 01 00 00 00 nop 4001612c: c4 04 60 14 ld [ %l1 + 0x14 ], %g2 40016130: 80 a0 80 1c cmp %g2, %i4 40016134: 0a 80 00 15 bcs 40016188 <== NEVER TAKEN 40016138: 80 a7 60 0b cmp %i5, 0xb if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) || 4001613c: 12 bf ff d5 bne 40016090 40016140: 80 a7 60 0c cmp %i5, 0xc 40016144: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 40016148: 80 a0 a0 2e cmp %g2, 0x2e 4001614c: 02 bf ff db be 400160b8 <== ALWAYS TAKEN 40016150: 80 a6 20 00 cmp %i0, 0 break; } } } if ((rc == 0) && !empty) 40016154: 22 80 00 02 be,a 4001615c <== ALWAYS TAKEN 40016158: b0 10 20 5a mov 0x5a, %i0 rtems_rfs_buffer_handle_release (fs, handle); 4001615c: 92 07 bf a4 add %fp, -92, %o1 40016160: 7f ff c4 f9 call 40007544 40016164: 90 10 00 11 mov %l1, %o0 rc = ENOTEMPTY; rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); 40016168: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001616c: c0 2f bf a4 clrb [ %fp + -92 ] 40016170: 90 10 00 11 mov %l1, %o0 handle->bnum = 0; 40016174: c0 27 bf a8 clr [ %fp + -88 ] 40016178: 7f ff f8 4c call 400142a8 4001617c: c0 27 bf ac clr [ %fp + -84 ] return rc; 40016180: 81 c7 e0 08 ret 40016184: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) 40016188: 7f ff d2 8f call 4000abc4 <== NOT EXECUTED 4001618c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40016190: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40016194: 02 80 00 07 be 400161b0 <== NOT EXECUTED 40016198: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED printf ("rtems-rfs: dir-empty: " 4001619c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 400161a0: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 400161a4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 400161a8: 7f ff b2 d4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400161ac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 400161b0: 94 07 bf a0 add %fp, -96, %o2 400161b4: 92 07 bf b0 add %fp, -80, %o1 400161b8: 7f ff f9 22 call 40014640 400161bc: 90 10 00 11 mov %l1, %o0 if (rc > 0) 400161c0: b0 92 20 00 orcc %o0, 0, %i0 400161c4: 04 bf ff a6 ble 4001605c <== NEVER TAKEN 400161c8: d4 07 bf a0 ld [ %fp + -96 ], %o2 rc = 0; 400161cc: 82 1e 20 06 xor %i0, 6, %g1 400161d0: 80 a0 00 01 cmp %g0, %g1 400161d4: 82 60 20 00 subx %g0, 0, %g1 400161d8: 10 bf ff e1 b 4001615c 400161dc: b0 0e 00 01 and %i0, %g1, %i0 printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir)); 400161e0: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 400161e4: 7f ff b2 c5 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400161e8: 90 12 21 28 or %o0, 0x128, %o0 ! 40023d28 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 400161ec: 10 bf ff 85 b 40016000 <== NOT EXECUTED 400161f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 400161f4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 400161f8: 7f ff f8 2c call 400142a8 <== NOT EXECUTED 400161fc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED return rc; 40016200: 81 c7 e0 08 ret <== NOT EXECUTED 40016204: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40014e38 : rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) { 40014e38: 9d e3 bf 30 save %sp, -208, %sp rtems_rfs_block_map map; rtems_rfs_buffer_handle entries; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40014e3c: 90 10 20 00 clr %o0 40014e40: 13 01 00 00 sethi %hi(0x4000000), %o1 40014e44: 7f ff d7 60 call 4000abc4 40014e48: a0 10 00 18 mov %i0, %l0 40014e4c: 80 a2 20 00 cmp %o0, 0 40014e50: 32 80 00 e3 bne,a 400151dc <== NEVER TAKEN 40014e54: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED for (c = 0; c < length; c++) printf ("%c", name[c]); printf (", len=%d\n", length); } *ino = RTEMS_RFS_EMPTY_INO; 40014e58: c0 27 00 00 clr [ %i4 ] *offset = 0; rc = rtems_rfs_block_map_open (fs, inode, &map); 40014e5c: 94 07 bf b0 add %fp, -80, %o2 *offset = 0; 40014e60: c0 27 40 00 clr [ %i5 ] rc = rtems_rfs_block_map_open (fs, inode, &map); 40014e64: 92 10 00 19 mov %i1, %o1 40014e68: 7f ff fc b1 call 4001412c 40014e6c: 90 10 00 10 mov %l0, %o0 if (rc > 0) 40014e70: b0 92 20 00 orcc %o0, 0, %i0 40014e74: 14 80 00 d2 bg 400151bc <== NEVER TAKEN 40014e78: 90 10 00 1a mov %i2, %o0 uint32_t hash; /* * Calculate the hash of the look up string. */ hash = rtems_rfs_dir_hash (name, length); 40014e7c: 92 10 00 1b mov %i3, %o1 handle->dirty = false; 40014e80: c0 2f bf a4 clrb [ %fp + -92 ] handle->bnum = 0; 40014e84: c0 27 bf a8 clr [ %fp + -88 ] 40014e88: 40 00 04 ed call 4001623c 40014e8c: c0 27 bf ac clr [ %fp + -84 ] /* * Locate the first block. The map points to the start after open so just * seek 0. If an error the block will be 0. */ rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 40014e90: 98 07 bf a0 add %fp, -96, %o4 hash = rtems_rfs_dir_hash (name, length); 40014e94: a4 10 00 08 mov %o0, %l2 rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 40014e98: 94 10 20 00 clr %o2 40014e9c: 96 10 20 00 clr %o3 40014ea0: 92 07 bf b0 add %fp, -80, %o1 40014ea4: 7f ff fd c9 call 400145c8 40014ea8: 90 10 00 10 mov %l0, %o0 if (rc > 0) 40014eac: b0 92 20 00 orcc %o0, 0, %i0 40014eb0: 14 80 00 de bg 40015228 <== NEVER TAKEN 40014eb4: 2d 10 00 8d sethi %hi(0x40023400), %l6 while ((rc == 0) && block) { uint8_t* entry; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 40014eb8: 82 15 a3 78 or %l6, 0x378, %g1 ! 40023778 { rc = rtems_rfs_block_map_next_block (fs, &map, &block); if ((rc > 0) && (rc != ENXIO)) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) printf ("rtems-rfs: dir-lookup-ino: " 40014ebc: 2f 10 00 8e sethi %hi(0x40023800), %l7 printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 40014ec0: c2 27 bf 9c st %g1, [ %fp + -100 ] printf ("rtems-rfs: dir-lookup-ino: " 40014ec4: 82 15 e0 e0 or %l7, 0xe0, %g1 40014ec8: c2 27 bf 98 st %g1, [ %fp + -104 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40014ecc: 23 00 00 3f sethi %hi(0xfc00), %l1 printf ("rtems-rfs: dir-lookup-ino: " 40014ed0: 27 10 00 8e sethi %hi(0x40023800), %l3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40014ed4: a2 14 63 ff or %l1, 0x3ff, %l1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 40014ed8: a8 10 20 00 clr %l4 40014edc: 2b 02 00 00 sethi %hi(0x8000000), %l5 printf ("rtems-rfs: dir-lookup-ino: " 40014ee0: a6 14 e0 38 or %l3, 0x38, %l3 while ((rc == 0) && block) 40014ee4: 80 a6 20 00 cmp %i0, 0 40014ee8: 12 80 00 75 bne 400150bc <== NEVER TAKEN 40014eec: c2 07 bf a0 ld [ %fp + -96 ], %g1 40014ef0: 80 a0 60 00 cmp %g1, 0 40014ef4: 02 80 00 ec be 400152a4 <== NEVER TAKEN 40014ef8: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40014efc: 7f ff d7 32 call 4000abc4 40014f00: 13 01 00 00 sethi %hi(0x4000000), %o1 40014f04: 80 a2 20 00 cmp %o0, 0 40014f08: 12 80 00 9a bne 40015170 <== NEVER TAKEN 40014f0c: d4 07 bf c0 ld [ %fp + -64 ], %o2 rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 40014f10: d4 07 bf a0 ld [ %fp + -96 ], %o2 40014f14: 96 10 20 01 mov 1, %o3 40014f18: 92 07 bf a4 add %fp, -92, %o1 40014f1c: 7f ff c8 c1 call 40007220 40014f20: 90 10 00 10 mov %l0, %o0 if (rc > 0) 40014f24: b0 92 20 00 orcc %o0, 0, %i0 40014f28: 34 80 00 fc bg,a 40015318 <== NEVER TAKEN 40014f2c: 90 10 20 00 clr %o0 <== NOT EXECUTED map.bpos.boff = 0; 40014f30: c0 27 bf c4 clr [ %fp + -60 ] while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40014f34: c4 04 20 08 ld [ %l0 + 8 ], %g2 entry = rtems_rfs_buffer_data (&entries); 40014f38: c2 07 bf ac ld [ %fp + -84 ], %g1 while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40014f3c: 80 a0 a0 0a cmp %g2, 0xa 40014f40: 12 80 00 0b bne 40014f6c <== ALWAYS TAKEN 40014f44: ec 00 60 1c ld [ %g1 + 0x1c ], %l6 if (rc == 0) 40014f48: 10 80 00 90 b 40015188 <== NOT EXECUTED 40014f4c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED map.bpos.boff += elength; 40014f50: 86 05 c0 03 add %l7, %g3, %g3 40014f54: c6 27 bf c4 st %g3, [ %fp + -60 ] while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40014f58: c4 04 20 08 ld [ %l0 + 8 ], %g2 40014f5c: 84 00 bf f6 add %g2, -10, %g2 40014f60: 80 a0 c0 02 cmp %g3, %g2 40014f64: 1a 80 00 88 bcc 40015184 <== NEVER TAKEN 40014f68: ac 05 80 17 add %l6, %l7, %l6 *ino = rtems_rfs_dir_entry_ino (entry); 40014f6c: d0 0d 80 00 ldub [ %l6 ], %o0 40014f70: de 0d a0 01 ldub [ %l6 + 1 ], %o7 40014f74: d4 0d a0 02 ldub [ %l6 + 2 ], %o2 40014f78: d2 0d a0 03 ldub [ %l6 + 3 ], %o1 ehash = rtems_rfs_dir_entry_hash (entry); 40014f7c: d6 0d a0 04 ldub [ %l6 + 4 ], %o3 40014f80: c8 0d a0 05 ldub [ %l6 + 5 ], %g4 40014f84: c6 0d a0 06 ldub [ %l6 + 6 ], %g3 40014f88: da 0d a0 07 ldub [ %l6 + 7 ], %o5 40014f8c: c4 0d a0 08 ldub [ %l6 + 8 ], %g2 40014f90: d8 0d a0 09 ldub [ %l6 + 9 ], %o4 *ino = rtems_rfs_dir_entry_ino (entry); 40014f94: 91 2a 20 18 sll %o0, 0x18, %o0 40014f98: 9f 2b e0 10 sll %o7, 0x10, %o7 40014f9c: 95 2a a0 08 sll %o2, 8, %o2 40014fa0: 9e 13 c0 08 or %o7, %o0, %o7 40014fa4: 9e 12 80 0f or %o2, %o7, %o7 40014fa8: 9e 12 40 0f or %o1, %o7, %o7 40014fac: de 27 00 00 st %o7, [ %i4 ] ehash = rtems_rfs_dir_entry_hash (entry); 40014fb0: 97 2a e0 18 sll %o3, 0x18, %o3 40014fb4: 89 29 20 10 sll %g4, 0x10, %g4 40014fb8: 87 28 e0 08 sll %g3, 8, %g3 40014fbc: 88 11 00 0b or %g4, %o3, %g4 40014fc0: 85 28 a0 08 sll %g2, 8, %g2 40014fc4: 86 10 c0 04 or %g3, %g4, %g3 elength = rtems_rfs_dir_entry_length (entry); 40014fc8: ae 13 00 02 or %o4, %g2, %l7 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40014fcc: 80 a5 c0 11 cmp %l7, %l1 40014fd0: 02 80 00 6d be 40015184 40014fd4: 86 13 40 03 or %o5, %g3, %g3 if (rtems_rfs_dir_entry_valid (fs, elength, *ino)) 40014fd8: 80 a5 e0 0a cmp %l7, 0xa 40014fdc: 24 80 00 32 ble,a 400150a4 <== NEVER TAKEN 40014fe0: 90 10 20 00 clr %o0 <== NOT EXECUTED 40014fe4: c8 04 20 1c ld [ %l0 + 0x1c ], %g4 40014fe8: 80 a5 c0 04 cmp %l7, %g4 40014fec: 1a 80 00 2d bcc 400150a0 <== NEVER TAKEN 40014ff0: 80 a3 e0 00 cmp %o7, 0 40014ff4: 22 80 00 2c be,a 400150a4 <== NEVER TAKEN 40014ff8: 90 10 20 00 clr %o0 <== NOT EXECUTED 40014ffc: c8 04 20 14 ld [ %l0 + 0x14 ], %g4 40015000: 80 a3 c0 04 cmp %o7, %g4 40015004: 18 80 00 27 bgu 400150a0 <== NEVER TAKEN 40015008: 80 a4 80 03 cmp %l2, %g3 if (ehash == hash) 4001500c: 12 bf ff d1 bne 40014f50 40015010: c6 07 bf c4 ld [ %fp + -60 ], %g3 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 40015014: 90 10 00 14 mov %l4, %o0 40015018: 7f ff d6 eb call 4000abc4 4001501c: 92 10 00 15 mov %l5, %o1 40015020: 80 a2 20 00 cmp %o0, 0 40015024: 32 80 00 43 bne,a 40015130 <== NEVER TAKEN 40015028: de 0d 80 00 ldub [ %l6 ], %o7 <== NOT EXECUTED if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0) 4001502c: 90 05 a0 0a add %l6, 0xa, %o0 40015030: 94 10 00 1b mov %i3, %o2 40015034: 40 00 25 6e call 4001e5ec 40015038: 92 10 00 1a mov %i2, %o1 4001503c: 80 a2 20 00 cmp %o0, 0 40015040: 12 bf ff c4 bne 40014f50 <== NEVER TAKEN 40015044: c6 07 bf c4 ld [ %fp + -60 ], %g3 *offset = rtems_rfs_block_map_pos (fs, &map); 40015048: 92 07 bf c0 add %fp, -64, %o1 4001504c: 7f ff fc 1e call 400140c4 40015050: 90 10 00 10 mov %l0, %o0 40015054: d2 27 40 00 st %o1, [ %i5 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND)) 40015058: 90 10 20 00 clr %o0 4001505c: 7f ff d6 da call 4000abc4 40015060: 13 04 00 00 sethi %hi(0x10000000), %o1 40015064: 80 a2 20 00 cmp %o0, 0 40015068: 32 80 00 c9 bne,a 4001538c <== NEVER TAKEN 4001506c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015070: 92 07 bf a4 add %fp, -92, %o1 40015074: 7f ff c9 34 call 40007544 40015078: 90 10 00 10 mov %l0, %o0 return 0; 4001507c: b0 10 20 00 clr %i0 handle->dirty = false; 40015080: c0 2f bf a4 clrb [ %fp + -92 ] rtems_rfs_block_map_close (fs, &map); 40015084: 92 07 bf b0 add %fp, -80, %o1 handle->bnum = 0; 40015088: c0 27 bf a8 clr [ %fp + -88 ] 4001508c: 90 10 00 10 mov %l0, %o0 40015090: 7f ff fc 86 call 400142a8 40015094: c0 27 bf ac clr [ %fp + -84 ] return 0; 40015098: 81 c7 e0 08 ret 4001509c: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 400150a0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400150a4: 7f ff d6 c8 call 4000abc4 <== NOT EXECUTED 400150a8: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 400150ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400150b0: 12 80 00 0e bne 400150e8 <== NOT EXECUTED 400150b4: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED rc = EIO; 400150b8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 400150bc: 92 07 bf a4 add %fp, -92, %o1 400150c0: 7f ff c9 21 call 40007544 400150c4: 90 10 00 10 mov %l0, %o0 rtems_rfs_inode_ino (inode), rc, strerror (rc)); } } rtems_rfs_buffer_handle_close (fs, &entries); rtems_rfs_block_map_close (fs, &map); 400150c8: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 400150cc: c0 2f bf a4 clrb [ %fp + -92 ] 400150d0: 90 10 00 10 mov %l0, %o0 handle->bnum = 0; 400150d4: c0 27 bf a8 clr [ %fp + -88 ] 400150d8: 7f ff fc 74 call 400142a8 400150dc: c0 27 bf ac clr [ %fp + -84 ] return rc; 400150e0: 81 c7 e0 08 ret 400150e4: 81 e8 00 00 restore printf ("rtems-rfs: dir-lookup-ino: " 400150e8: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED 400150ec: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 400150f0: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED 400150f4: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 400150f8: 7f ff b7 00 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400150fc: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 400237f0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015100: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 40015104: 7f ff c9 10 call 40007544 <== NOT EXECUTED 40015108: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rc = EIO; 4001510c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED handle->dirty = false; 40015110: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 40015114: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->bnum = 0; 40015118: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 4001511c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 40015120: 7f ff fc 62 call 400142a8 <== NOT EXECUTED 40015124: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return rc; 40015128: 81 c7 e0 08 ret <== NOT EXECUTED 4001512c: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 40015130: c8 0d a0 01 ldub [ %l6 + 1 ], %g4 <== NOT EXECUTED 40015134: c6 0d a0 02 ldub [ %l6 + 2 ], %g3 <== NOT EXECUTED 40015138: da 0d a0 03 ldub [ %l6 + 3 ], %o5 <== NOT EXECUTED 4001513c: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED 40015140: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== NOT EXECUTED 40015144: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015148: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED 4001514c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED 40015150: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED 40015154: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED 40015158: 98 10 00 17 mov %l7, %o4 <== NOT EXECUTED 4001515c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 40015160: 7f ff b6 e6 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015164: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0) 40015168: 10 bf ff b2 b 40015030 <== NOT EXECUTED 4001516c: 90 05 a0 0a add %l6, 0xa, %o0 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 40015170: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015174: 7f ff b6 e1 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015178: d0 07 bf 9c ld [ %fp + -100 ], %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 4001517c: 10 bf ff 66 b 40014f14 <== NOT EXECUTED 40015180: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED if (rc == 0) 40015184: 80 a6 20 00 cmp %i0, 0 40015188: 12 bf ff ce bne 400150c0 <== NEVER TAKEN 4001518c: 92 07 bf a4 add %fp, -92, %o1 rc = rtems_rfs_block_map_next_block (fs, &map, &block); 40015190: 94 07 bf a0 add %fp, -96, %o2 40015194: 92 07 bf b0 add %fp, -80, %o1 40015198: 7f ff fd 2a call 40014640 4001519c: 90 10 00 10 mov %l0, %o0 if ((rc > 0) && (rc != ENXIO)) 400151a0: b0 92 20 00 orcc %o0, 0, %i0 400151a4: 04 80 00 3c ble 40015294 <== NEVER TAKEN 400151a8: 80 a6 20 06 cmp %i0, 6 400151ac: 12 80 00 2a bne 40015254 <== NEVER TAKEN 400151b0: 90 10 20 00 clr %o0 rc = ENOENT; 400151b4: 10 bf ff c2 b 400150bc 400151b8: b0 10 20 02 mov 2, %i0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 400151bc: 90 10 20 00 clr %o0 <== NOT EXECUTED 400151c0: 7f ff d6 81 call 4000abc4 <== NOT EXECUTED 400151c4: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 400151c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400151cc: 32 80 00 48 bne,a 400152ec <== NOT EXECUTED 400151d0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED } 400151d4: 81 c7 e0 08 ret <== NOT EXECUTED 400151d8: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=", 400151dc: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 400151e0: 7f ff b6 c6 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400151e4: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 400236b0 <== NOT EXECUTED for (c = 0; c < length; c++) 400151e8: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 400151ec: 04 80 00 09 ble 40015210 <== NOT EXECUTED 400151f0: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED 400151f4: a2 06 c0 1a add %i3, %i2, %l1 <== NOT EXECUTED printf ("%c", name[c]); 400151f8: 40 00 25 ee call 4001e9b0 <== NOT EXECUTED 400151fc: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED for (c = 0; c < length; c++) 40015200: b0 06 20 01 inc %i0 <== NOT EXECUTED 40015204: 80 a4 40 18 cmp %l1, %i0 <== NOT EXECUTED 40015208: 12 bf ff fc bne 400151f8 <== NOT EXECUTED 4001520c: 01 00 00 00 nop <== NOT EXECUTED printf (", len=%d\n", length); 40015210: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40015214: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40015218: 7f ff b6 b8 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4001521c: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 400236e8 <== NOT EXECUTED *ino = RTEMS_RFS_EMPTY_INO; 40015220: 10 bf ff 0f b 40014e5c <== NOT EXECUTED 40015224: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40015228: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001522c: 7f ff d6 66 call 4000abc4 <== NOT EXECUTED 40015230: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 40015234: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015238: 12 80 00 4c bne 40015368 <== NOT EXECUTED 4001523c: 01 00 00 00 nop <== NOT EXECUTED if (rc == ENXIO) 40015240: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED 40015244: 12 bf ff 9f bne 400150c0 <== NOT EXECUTED 40015248: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001524c: 10 bf ff 9d b 400150c0 <== NOT EXECUTED 40015250: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40015254: 7f ff d6 5c call 4000abc4 <== NOT EXECUTED 40015258: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001525c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015260: 22 bf ff 22 be,a 40014ee8 <== NOT EXECUTED 40015264: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 40015268: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001526c: d2 27 bf 94 st %o1, [ %fp + -108 ] <== NOT EXECUTED 40015270: 40 00 28 e7 call 4001f60c <== NOT EXECUTED 40015274: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40015278: d2 07 bf 94 ld [ %fp + -108 ], %o1 <== NOT EXECUTED 4001527c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40015280: d0 07 bf 98 ld [ %fp + -104 ], %o0 <== NOT EXECUTED 40015284: 7f ff b6 9d call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015288: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED while ((rc == 0) && block) 4001528c: 10 bf ff 17 b 40014ee8 <== NOT EXECUTED 40015290: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED if (rc == ENXIO) 40015294: 12 bf ff 15 bne 40014ee8 <== NOT EXECUTED 40015298: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED rc = ENOENT; 4001529c: 10 bf ff 88 b 400150bc <== NOT EXECUTED 400152a0: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 400152a4: 7f ff d6 48 call 4000abc4 <== NOT EXECUTED 400152a8: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 400152ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400152b0: 22 bf ff 83 be,a 400150bc <== NOT EXECUTED 400152b4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n", 400152b8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 400152bc: d2 27 bf 9c st %o1, [ %fp + -100 ] <== NOT EXECUTED 400152c0: 40 00 28 d3 call 4001f60c <== NOT EXECUTED 400152c4: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED 400152c8: d2 07 bf 9c ld [ %fp + -100 ], %o1 <== NOT EXECUTED 400152cc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 400152d0: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED rc = EIO; 400152d4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n", 400152d8: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 400152dc: 7f ff b6 87 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400152e0: 90 12 21 30 or %o0, 0x130, %o0 ! 40023930 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 400152e4: 10 bf ff 77 b 400150c0 <== NOT EXECUTED 400152e8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s", 400152ec: d2 27 bf 9c st %o1, [ %fp + -100 ] <== NOT EXECUTED 400152f0: 40 00 28 c7 call 4001f60c <== NOT EXECUTED 400152f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400152f8: d2 07 bf 9c ld [ %fp + -100 ], %o1 <== NOT EXECUTED 400152fc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40015300: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED 40015304: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40015308: 7f ff b6 7c call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4001530c: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 400236f8 <== NOT EXECUTED 40015310: 81 c7 e0 08 ret <== NOT EXECUTED 40015314: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40015318: 7f ff d6 2b call 4000abc4 <== NOT EXECUTED 4001531c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 40015320: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015324: 22 bf ff 67 be,a 400150c0 <== NOT EXECUTED 40015328: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n", 4001532c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015330: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED 40015334: d2 27 bf 98 st %o1, [ %fp + -104 ] <== NOT EXECUTED 40015338: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001533c: 40 00 28 b4 call 4001f60c <== NOT EXECUTED 40015340: d4 27 bf 9c st %o2, [ %fp + -100 ] <== NOT EXECUTED 40015344: d4 07 bf 9c ld [ %fp + -100 ], %o2 <== NOT EXECUTED 40015348: d2 07 bf 98 ld [ %fp + -104 ], %o1 <== NOT EXECUTED 4001534c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 40015350: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 40015354: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40015358: 7f ff b6 68 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4001535c: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 400237b0 <== NOT EXECUTED 40015360: 10 bf ff 58 b 400150c0 <== NOT EXECUTED 40015364: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n", 40015368: 40 00 28 a9 call 4001f60c <== NOT EXECUTED 4001536c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40015370: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40015374: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40015378: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 4001537c: 7f ff b6 5f call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015380: 90 12 23 38 or %o0, 0x338, %o0 ! 40023738 <== NOT EXECUTED if (rc == ENXIO) 40015384: 10 bf ff b0 b 40015244 <== NOT EXECUTED 40015388: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001538c: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED 40015390: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015394: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 40015398: 7f ff b6 58 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 4001539c: 90 12 20 98 or %o0, 0x98, %o0 ! 40023898 <== NOT EXECUTED 400153a0: 10 bf ff 35 b 40015074 <== NOT EXECUTED 400153a4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 40015c10 : rtems_rfs_dir_read (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_pos_rel offset, struct dirent* dirent, size_t* length) { 40015c10: 9d e3 bf 38 save %sp, -200, %sp rtems_rfs_block_map map; rtems_rfs_buffer_handle buffer; rtems_rfs_block_no block; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015c14: 90 10 20 00 clr %o0 40015c18: 13 20 00 00 sethi %hi(0x80000000), %o1 40015c1c: 7f ff d3 ea call 4000abc4 40015c20: a4 10 00 1a mov %i2, %l2 40015c24: 80 a2 20 00 cmp %o0, 0 40015c28: 12 80 00 81 bne 40015e2c <== NEVER TAKEN 40015c2c: a6 10 00 1b mov %i3, %l3 printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n", rtems_rfs_inode_ino (dir), offset); *length = 0; 40015c30: c0 27 40 00 clr [ %i5 ] rc = rtems_rfs_block_map_open (fs, dir, &map); 40015c34: 92 10 00 19 mov %i1, %o1 40015c38: 94 07 bf b0 add %fp, -80, %o2 40015c3c: 7f ff f9 3c call 4001412c 40015c40: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40015c44: b6 92 20 00 orcc %o0, 0, %i3 40015c48: 14 80 00 58 bg 40015da8 <== NEVER TAKEN 40015c4c: b4 10 20 00 clr %i2 return rc; if (((rtems_rfs_fs_block_size (fs) - 40015c50: e0 06 20 08 ld [ %i0 + 8 ], %l0 (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE)) 40015c54: 90 10 00 12 mov %l2, %o0 40015c58: 92 10 00 13 mov %l3, %o1 40015c5c: 94 10 00 1a mov %i2, %o2 40015c60: 40 00 1f cb call 4001db8c <__moddi3> 40015c64: 96 10 00 10 mov %l0, %o3 if (((rtems_rfs_fs_block_size (fs) - 40015c68: 86 a4 00 09 subcc %l0, %o1, %g3 40015c6c: 84 66 80 08 subx %i2, %o0, %g2 40015c70: 80 a0 a0 00 cmp %g2, 0 40015c74: 04 80 00 4f ble 40015db0 <== ALWAYS TAKEN 40015c78: b6 10 00 10 mov %l0, %i3 offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * rtems_rfs_fs_block_size (fs)); rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 40015c7c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 40015c80: 96 10 00 13 mov %l3, %o3 40015c84: 98 07 bf a0 add %fp, -96, %o4 40015c88: 92 07 bf b0 add %fp, -80, %o1 40015c8c: 7f ff fa 4f call 400145c8 40015c90: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40015c94: b6 92 20 00 orcc %o0, 0, %i3 40015c98: 14 80 00 5d bg 40015e0c <== NEVER TAKEN 40015c9c: 80 a6 e0 06 cmp %i3, 6 entry += map.bpos.boff; elength = rtems_rfs_dir_entry_length (entry); eino = rtems_rfs_dir_entry_ino (entry); if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 40015ca0: 35 00 00 3f sethi %hi(0xfc00), %i2 } *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 40015ca4: 2d 10 00 8f sethi %hi(0x40023c00), %l6 handle->dirty = false; 40015ca8: c0 2f bf a4 clrb [ %fp + -92 ] if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 40015cac: b4 16 a3 ff or %i2, 0x3ff, %i2 handle->bnum = 0; 40015cb0: c0 27 bf a8 clr [ %fp + -88 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015cb4: a8 10 20 00 clr %l4 handle->buffer = NULL; 40015cb8: c0 27 bf ac clr [ %fp + -84 ] 40015cbc: 2b 20 00 00 sethi %hi(0x80000000), %l5 printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 40015cc0: 10 80 00 0b b 40015cec 40015cc4: ac 15 a0 f0 or %l6, 0xf0, %l6 offset, *length); rc = rtems_rfs_block_map_next_block (fs, &map, &block); 40015cc8: 92 07 bf b0 add %fp, -80, %o1 40015ccc: 7f ff fa 5d call 40014640 40015cd0: 90 10 00 18 mov %i0, %o0 if (rc == ENXIO) 40015cd4: 80 a2 20 06 cmp %o0, 6 40015cd8: 02 80 00 2a be 40015d80 <== ALWAYS TAKEN 40015cdc: b6 10 00 08 mov %o0, %i3 while (rc == 0) 40015ce0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015ce4: 12 80 00 29 bne 40015d88 <== NOT EXECUTED 40015ce8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 40015cec: d4 07 bf a0 ld [ %fp + -96 ], %o2 40015cf0: 92 07 bf a4 add %fp, -92, %o1 40015cf4: 96 10 20 01 mov 1, %o3 40015cf8: 7f ff c5 4a call 40007220 40015cfc: 90 10 00 18 mov %i0, %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015d00: 92 10 00 15 mov %l5, %o1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 40015d04: b6 10 00 08 mov %o0, %i3 if (rc > 0) 40015d08: 80 a6 e0 00 cmp %i3, 0 40015d0c: 14 80 00 1e bg 40015d84 <== NEVER TAKEN 40015d10: 90 10 00 14 mov %l4, %o0 entry = rtems_rfs_buffer_data (&buffer); 40015d14: c2 07 bf ac ld [ %fp + -84 ], %g1 40015d18: e0 00 60 1c ld [ %g1 + 0x1c ], %l0 entry += map.bpos.boff; 40015d1c: c6 07 bf c4 ld [ %fp + -60 ], %g3 40015d20: a0 04 00 03 add %l0, %g3, %l0 elength = rtems_rfs_dir_entry_length (entry); 40015d24: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 40015d28: e2 0c 20 09 ldub [ %l0 + 9 ], %l1 40015d2c: 83 28 60 08 sll %g1, 8, %g1 40015d30: a2 14 40 01 or %l1, %g1, %l1 if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 40015d34: 80 a4 40 1a cmp %l1, %i2 40015d38: 32 80 00 49 bne,a 40015e5c 40015d3c: c4 0c 00 00 ldub [ %l0 ], %g2 *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff; 40015d40: c4 06 20 08 ld [ %i0 + 8 ], %g2 40015d44: c2 07 40 00 ld [ %i5 ], %g1 40015d48: 84 20 80 03 sub %g2, %g3, %g2 40015d4c: 82 00 40 02 add %g1, %g2, %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015d50: 7f ff d3 9d call 4000abc4 40015d54: c2 27 40 00 st %g1, [ %i5 ] 40015d58: 80 a2 20 00 cmp %o0, 0 40015d5c: 22 bf ff db be,a 40015cc8 <== ALWAYS TAKEN 40015d60: 94 07 bf a0 add %fp, -96, %o2 printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 40015d64: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED 40015d68: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 40015d6c: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 40015d70: 7f ff b3 e2 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015d74: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 40015d78: 10 bf ff d4 b 40015cc8 <== NOT EXECUTED 40015d7c: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED rc = ENOENT; 40015d80: b6 10 20 02 mov 2, %i3 rtems_rfs_buffer_handle_release (fs, handle); 40015d84: 92 07 bf a4 add %fp, -92, %o1 40015d88: 7f ff c5 ef call 40007544 40015d8c: 90 10 00 18 mov %i0, %o0 } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); 40015d90: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 40015d94: c0 2f bf a4 clrb [ %fp + -92 ] 40015d98: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 40015d9c: c0 27 bf a8 clr [ %fp + -88 ] 40015da0: 7f ff f9 42 call 400142a8 40015da4: c0 27 bf ac clr [ %fp + -84 ] return rc; } 40015da8: 81 c7 e0 08 ret 40015dac: 91 e8 00 1b restore %g0, %i3, %o0 if (((rtems_rfs_fs_block_size (fs) - 40015db0: 02 80 00 27 be 40015e4c <== ALWAYS TAKEN 40015db4: 80 a0 e0 0a cmp %g3, 0xa offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 40015db8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 40015dbc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40015dc0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 40015dc4: 40 00 1e e7 call 4001d960 <__divdi3> <== NOT EXECUTED 40015dc8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40015dcc: 86 82 60 01 addcc %o1, 1, %g3 <== NOT EXECUTED 40015dd0: 84 42 20 00 addx %o0, 0, %g2 <== NOT EXECUTED 40015dd4: 82 58 80 10 smul %g2, %l0, %g1 <== NOT EXECUTED 40015dd8: a6 54 00 03 umul %l0, %g3, %l3 <== NOT EXECUTED 40015ddc: a5 40 00 00 rd %y, %l2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 40015de0: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 40015de4: a4 00 40 12 add %g1, %l2, %l2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 40015de8: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED 40015dec: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 40015df0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 40015df4: 7f ff f9 f5 call 400145c8 <== NOT EXECUTED 40015df8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 40015dfc: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED 40015e00: 24 bf ff a9 ble,a 40015ca4 <== NOT EXECUTED 40015e04: 35 00 00 3f sethi %hi(0xfc00), %i2 <== NOT EXECUTED if (rc == ENXIO) 40015e08: 80 a6 e0 06 cmp %i3, 6 <== NOT EXECUTED 40015e0c: 22 80 00 02 be,a 40015e14 <== NOT EXECUTED 40015e10: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 40015e14: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 40015e18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40015e1c: 7f ff f9 23 call 400142a8 <== NOT EXECUTED 40015e20: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED } 40015e24: 81 c7 e0 08 ret <== NOT EXECUTED 40015e28: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n", 40015e2c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015e30: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40015e34: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 40015e38: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 40015e3c: 7f ff b3 af call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015e40: 90 12 20 40 or %o0, 0x40, %o0 ! 40023c40 <== NOT EXECUTED *length = 0; 40015e44: 10 bf ff 7c b 40015c34 <== NOT EXECUTED 40015e48: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED if (((rtems_rfs_fs_block_size (fs) - 40015e4c: 38 bf ff 8d bgu,a 40015c80 <== ALWAYS TAKEN 40015e50: 94 10 00 12 mov %l2, %o2 offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 40015e54: 10 bf ff da b 40015dbc <== NOT EXECUTED 40015e58: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED eino = rtems_rfs_dir_entry_ino (entry); 40015e5c: c2 0c 20 01 ldub [ %l0 + 1 ], %g1 40015e60: d6 0c 20 02 ldub [ %l0 + 2 ], %o3 40015e64: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 40015e68: 85 28 a0 18 sll %g2, 0x18, %g2 40015e6c: 83 28 60 10 sll %g1, 0x10, %g1 40015e70: 97 2a e0 08 sll %o3, 8, %o3 40015e74: 82 10 40 02 or %g1, %g2, %g1 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 40015e78: 80 a4 60 0a cmp %l1, 0xa eino = rtems_rfs_dir_entry_ino (entry); 40015e7c: 96 12 c0 01 or %o3, %g1, %o3 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 40015e80: 04 80 00 47 ble 40015f9c <== NEVER TAKEN 40015e84: b4 10 c0 0b or %g3, %o3, %i2 40015e88: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 40015e8c: 80 a4 40 01 cmp %l1, %g1 40015e90: 1a 80 00 43 bcc 40015f9c <== NEVER TAKEN 40015e94: 80 a6 a0 00 cmp %i2, 0 40015e98: 02 80 00 42 be 40015fa0 <== NEVER TAKEN 40015e9c: 90 10 20 00 clr %o0 40015ea0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40015ea4: 80 a0 40 1a cmp %g1, %i2 40015ea8: 0a 80 00 3f bcs 40015fa4 <== NEVER TAKEN 40015eac: 13 20 00 00 sethi %hi(0x80000000), %o1 memset (dirent, 0, sizeof (struct dirent)); 40015eb0: 94 10 21 18 mov 0x118, %o2 40015eb4: 92 10 20 00 clr %o1 40015eb8: 40 00 22 79 call 4001e89c 40015ebc: 90 10 00 1c mov %i4, %o0 dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos); 40015ec0: 92 07 bf c0 add %fp, -64, %o1 40015ec4: 7f ff f8 80 call 400140c4 40015ec8: 90 10 00 18 mov %i0, %o0 *length += elength; 40015ecc: c2 07 40 00 ld [ %i5 ], %g1 dirent->d_reclen = sizeof (struct dirent); 40015ed0: 86 10 21 18 mov 0x118, %g3 dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos); 40015ed4: d0 3f 20 08 std %o0, [ %i4 + 8 ] *length += elength; 40015ed8: 84 04 40 01 add %l1, %g1, %g2 dirent->d_reclen = sizeof (struct dirent); 40015edc: c6 37 20 10 sth %g3, [ %i4 + 0x10 ] *length += elength; 40015ee0: c4 27 40 00 st %g2, [ %i5 ] remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength); 40015ee4: c6 07 bf c4 ld [ %fp + -60 ], %g3 40015ee8: c4 06 20 08 ld [ %i0 + 8 ], %g2 40015eec: 84 20 80 03 sub %g2, %g3, %g2 40015ef0: 86 20 80 11 sub %g2, %l1, %g3 if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE) 40015ef4: 80 a0 e0 0a cmp %g3, 0xa 40015ef8: 14 80 00 04 bg 40015f08 <== ALWAYS TAKEN 40015efc: a2 04 7f f6 add %l1, -10, %l1 *length += remaining; 40015f00: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 40015f04: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED if (elength > NAME_MAX) 40015f08: 80 a4 60 ff cmp %l1, 0xff 40015f0c: 34 80 00 02 bg,a 40015f14 <== NEVER TAKEN 40015f10: a2 10 20 ff mov 0xff, %l1 <== NOT EXECUTED memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength); 40015f14: 9a 07 20 16 add %i4, 0x16, %o5 40015f18: 94 10 00 11 mov %l1, %o2 40015f1c: da 27 bf 9c st %o5, [ %fp + -100 ] 40015f20: 90 10 00 0d mov %o5, %o0 40015f24: 40 00 21 d4 call 4001e674 40015f28: 92 04 20 0a add %l0, 0xa, %o1 dirent->d_ino = rtems_rfs_dir_entry_ino (entry); 40015f2c: c8 0c 00 00 ldub [ %l0 ], %g4 40015f30: c4 0c 20 01 ldub [ %l0 + 1 ], %g2 40015f34: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 40015f38: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 40015f3c: 89 29 20 18 sll %g4, 0x18, %g4 40015f40: c0 27 00 00 clr [ %i4 ] 40015f44: 85 28 a0 10 sll %g2, 0x10, %g2 dirent->d_namlen = elength; 40015f48: e2 37 20 14 sth %l1, [ %i4 + 0x14 ] dirent->d_ino = rtems_rfs_dir_entry_ino (entry); 40015f4c: 84 10 80 04 or %g2, %g4, %g2 40015f50: 83 28 60 08 sll %g1, 8, %g1 40015f54: 82 10 40 02 or %g1, %g2, %g1 40015f58: 82 10 c0 01 or %g3, %g1, %g1 40015f5c: c2 27 20 04 st %g1, [ %i4 + 4 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015f60: 90 10 20 00 clr %o0 40015f64: 7f ff d3 18 call 4000abc4 40015f68: 13 20 00 00 sethi %hi(0x80000000), %o1 40015f6c: 80 a2 20 00 cmp %o0, 0 40015f70: 02 bf ff 85 be 40015d84 <== ALWAYS TAKEN 40015f74: da 07 bf 9c ld [ %fp + -100 ], %o5 printf ("rtems-rfs: dir-read: found off:%" PRIooff_t 40015f78: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED 40015f7c: d8 07 20 04 ld [ %i4 + 4 ], %o4 <== NOT EXECUTED 40015f80: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED 40015f84: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED 40015f88: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 40015f8c: 7f ff b3 5b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015f90: 90 12 20 b8 or %o0, 0xb8, %o0 ! 40023cb8 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40015f94: 10 bf ff 7d b 40015d88 <== NOT EXECUTED 40015f98: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 40015f9c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40015fa0: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED 40015fa4: 7f ff d3 08 call 4000abc4 <== NOT EXECUTED 40015fa8: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED 40015fac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40015fb0: 22 bf ff 76 be,a 40015d88 <== NOT EXECUTED 40015fb4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-read: " 40015fb8: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED 40015fbc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 40015fc0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 40015fc4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 40015fc8: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 40015fcc: 7f ff b3 4b call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40015fd0: 90 12 20 70 or %o0, 0x70, %o0 ! 40023c70 <== NOT EXECUTED 40015fd4: 10 bf ff 6d b 40015d88 <== NOT EXECUTED 40015fd8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 400167d8 : { 400167d8: 9d e3 bf 98 save %sp, -104, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 400167dc: 90 10 20 10 mov 0x10, %o0 400167e0: 7f ff d0 f9 call 4000abc4 400167e4: 92 10 20 00 clr %o1 400167e8: 80 a2 20 00 cmp %o0, 0 400167ec: 32 80 00 79 bne,a 400169d0 <== NEVER TAKEN 400167f0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED if (handle->shared->references > 0) 400167f4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 400167f8: fa 02 60 08 ld [ %o1 + 8 ], %i5 400167fc: 80 a7 60 00 cmp %i5, 0 40016800: 04 80 00 05 ble 40016814 <== NEVER TAKEN 40016804: 01 00 00 00 nop handle->shared->references--; 40016808: ba 07 7f ff add %i5, -1, %i5 4001680c: fa 22 60 08 st %i5, [ %o1 + 8 ] if (handle->shared->references == 0) 40016810: 80 a7 60 00 cmp %i5, 0 40016814: 02 80 00 0b be 40016840 <== ALWAYS TAKEN 40016818: b6 06 60 04 add %i1, 4, %i3 4001681c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40016820: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40016824: 7f ff c3 48 call 40007544 <== NOT EXECUTED 40016828: ba 10 20 00 clr %i5 <== NOT EXECUTED free (handle); 4001682c: 90 10 00 19 mov %i1, %o0 40016830: 7f ff b1 f4 call 40003000 40016834: b0 10 00 1d mov %i5, %i0 } 40016838: 81 c7 e0 08 ret 4001683c: 81 e8 00 00 restore if (!rtems_rfs_inode_is_loaded (&handle->shared->inode)) 40016840: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 40016844: 80 a0 a0 00 cmp %g2, 0 40016848: 22 80 00 87 be,a 40016a64 <== ALWAYS TAKEN 4001684c: 92 02 60 0c add %o1, 0xc, %o1 rtems_rfs_inode_set_atime (&handle->shared->inode, 40016850: c2 02 60 8c ld [ %o1 + 0x8c ], %g1 rtems_rfs_write_u32 (&handle->node->atime, atime); 40016854: 87 30 60 18 srl %g1, 0x18, %g3 40016858: c6 28 a0 10 stb %g3, [ %g2 + 0x10 ] 4001685c: 87 30 60 10 srl %g1, 0x10, %g3 40016860: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 40016864: c6 28 a0 11 stb %g3, [ %g2 + 0x11 ] 40016868: 87 30 60 08 srl %g1, 8, %g3 4001686c: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 40016870: c6 28 a0 12 stb %g3, [ %g2 + 0x12 ] rtems_rfs_buffer_mark_dirty (&handle->buffer); 40016874: 88 10 20 01 mov 1, %g4 rtems_rfs_write_u32 (&handle->node->atime, atime); 40016878: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001687c: c2 28 a0 13 stb %g1, [ %g2 + 0x13 ] rtems_rfs_inode_set_mtime (&handle->shared->inode, 40016880: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 40016884: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 rtems_rfs_write_u32 (&handle->node->mtime, mtime); 40016888: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001688c: c8 2a 60 1c stb %g4, [ %o1 + 0x1c ] rtems_rfs_write_u32 (&handle->node->mtime, mtime); 40016890: b9 30 60 18 srl %g1, 0x18, %i4 40016894: f8 28 e0 14 stb %i4, [ %g3 + 0x14 ] 40016898: b9 30 60 10 srl %g1, 0x10, %i4 4001689c: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 400168a0: f8 28 e0 15 stb %i4, [ %g3 + 0x15 ] 400168a4: b9 30 60 08 srl %g1, 8, %i4 400168a8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 400168ac: f8 28 e0 16 stb %i4, [ %g3 + 0x16 ] 400168b0: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 400168b4: c2 28 e0 17 stb %g1, [ %g3 + 0x17 ] rtems_rfs_inode_set_ctime (&handle->shared->inode, 400168b8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 400168bc: c6 00 60 94 ld [ %g1 + 0x94 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 400168c0: c8 28 a0 1c stb %g4, [ %g2 + 0x1c ] rtems_rfs_write_u32 (&handle->node->ctime, ctime); 400168c4: b9 30 e0 18 srl %g3, 0x18, %i4 400168c8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 400168cc: f8 28 a0 18 stb %i4, [ %g2 + 0x18 ] 400168d0: b9 30 e0 10 srl %g3, 0x10, %i4 400168d4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 400168d8: f8 28 a0 19 stb %i4, [ %g2 + 0x19 ] 400168dc: b9 30 e0 08 srl %g3, 8, %i4 400168e0: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 400168e4: f8 28 a0 1a stb %i4, [ %g2 + 0x1a ] 400168e8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 400168ec: c6 28 a0 1b stb %g3, [ %g2 + 0x1b ] if (!rtems_rfs_block_size_equal (&handle->shared->size, 400168f0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 rtems_rfs_buffer_mark_dirty (&handle->buffer); 400168f4: c8 28 60 1c stb %g4, [ %g1 + 0x1c ] 400168f8: c2 02 60 84 ld [ %o1 + 0x84 ], %g1 400168fc: c4 02 60 3c ld [ %o1 + 0x3c ], %g2 40016900: 80 a0 40 02 cmp %g1, %g2 40016904: 02 80 00 77 be 40016ae0 <== ALWAYS TAKEN 40016908: c4 02 60 88 ld [ %o1 + 0x88 ], %g2 */ static inline void rtems_rfs_block_map_set_size (rtems_rfs_block_map* map, rtems_rfs_block_size* size) { rtems_rfs_block_copy_size (&map->size, size); 4001690c: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED map->dirty = true; 40016910: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED rtems_rfs_block_copy_size (&map->size, size); 40016914: c4 22 60 40 st %g2, [ %o1 + 0x40 ] <== NOT EXECUTED map->dirty = true; 40016918: c2 2a 60 34 stb %g1, [ %o1 + 0x34 ] <== NOT EXECUTED rc = rtems_rfs_block_map_close (fs, &handle->shared->map); 4001691c: 92 02 60 34 add %o1, 0x34, %o1 <== NOT EXECUTED 40016920: 7f ff f6 62 call 400142a8 40016924: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40016928: b8 92 20 00 orcc %o0, 0, %i4 4001692c: 14 80 00 44 bg 40016a3c <== NEVER TAKEN 40016930: 90 10 20 10 mov 0x10, %o0 rc = rtems_rfs_inode_close (fs, &handle->shared->inode); 40016934: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 40016938: 92 02 60 0c add %o1, 0xc, %o1 4001693c: 7f ff ca 6e call 400092f4 40016940: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40016944: b8 92 20 00 orcc %o0, 0, %i4 40016948: 34 80 00 28 bg,a 400169e8 <== NEVER TAKEN 4001694c: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED rtems_chain_extract_unprotected (&handle->shared->link); 40016950: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 next = the_node->next; 40016954: c4 02 00 00 ld [ %o0 ], %g2 previous = the_node->previous; 40016958: c2 02 20 04 ld [ %o0 + 4 ], %g1 next->previous = previous; 4001695c: c2 20 a0 04 st %g1, [ %g2 + 4 ] free (handle->shared); 40016960: 7f ff b1 a8 call 40003000 40016964: c4 20 40 00 st %g2, [ %g1 ] 40016968: 92 10 00 1b mov %i3, %o1 4001696c: 7f ff c2 f6 call 40007544 40016970: 90 10 00 18 mov %i0, %o0 handle->dirty = false; 40016974: c0 2e 60 04 clrb [ %i1 + 4 ] if (rrc > 0) 40016978: 80 a7 60 00 cmp %i5, 0 handle->bnum = 0; 4001697c: c0 26 60 08 clr [ %i1 + 8 ] 40016980: 04 bf ff ab ble 4001682c <== ALWAYS TAKEN 40016984: c0 26 60 0c clr [ %i1 + 0xc ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 40016988: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED 4001698c: 7f ff d0 8e call 4000abc4 <== NOT EXECUTED 40016990: 92 10 20 00 clr %o1 <== NOT EXECUTED 40016994: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40016998: 22 bf ff a6 be,a 40016830 <== NOT EXECUTED 4001699c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc)); 400169a0: 40 00 23 1b call 4001f60c <== NOT EXECUTED 400169a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 400169a8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 400169ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400169b0: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 400169b4: 7f ff b0 d1 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400169b8: 90 12 23 18 or %o0, 0x318, %o0 ! 40023f18 <== NOT EXECUTED free (handle); 400169bc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400169c0: 7f ff b1 90 call 40003000 <== NOT EXECUTED 400169c4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED } 400169c8: 81 c7 e0 08 ret <== NOT EXECUTED 400169cc: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n", 400169d0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED 400169d4: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 400169d8: 7f ff b0 c8 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 400169dc: 90 12 22 78 or %o0, 0x278, %o0 ! 40023e78 <== NOT EXECUTED if (handle->shared->references > 0) 400169e0: 10 bf ff 86 b 400167f8 <== NOT EXECUTED 400169e4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 400169e8: 7f ff d0 77 call 4000abc4 <== NOT EXECUTED 400169ec: 92 10 20 00 clr %o1 <== NOT EXECUTED 400169f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400169f4: 32 80 00 2f bne,a 40016ab0 <== NOT EXECUTED 400169f8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED rtems_chain_extract_unprotected (&handle->shared->link); 400169fc: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED next = the_node->next; 40016a00: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED if (rrc == 0) 40016a04: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 40016a08: 12 bf ff d5 bne 4001695c <== NOT EXECUTED 40016a0c: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; 40016a10: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED handle->buffer = NULL; 40016a14: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED free (handle->shared); 40016a18: 7f ff b1 7a call 40003000 <== NOT EXECUTED 40016a1c: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40016a20: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40016a24: 7f ff c2 c8 call 40007544 <== NOT EXECUTED 40016a28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->dirty = false; 40016a2c: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED handle->bnum = 0; 40016a30: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED handle->buffer = NULL; 40016a34: 10 bf ff d5 b 40016988 <== NOT EXECUTED 40016a38: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 40016a3c: 7f ff d0 62 call 4000abc4 <== NOT EXECUTED 40016a40: 92 10 20 00 clr %o1 <== NOT EXECUTED 40016a44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40016a48: 32 80 00 0e bne,a 40016a80 <== NOT EXECUTED 40016a4c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED if (rrc == 0) 40016a50: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 40016a54: 22 bf ff b8 be,a 40016934 <== NOT EXECUTED 40016a58: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED rc = rtems_rfs_inode_close (fs, &handle->shared->inode); 40016a5c: 10 bf ff b7 b 40016938 <== NOT EXECUTED 40016a60: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED rrc = rtems_rfs_inode_load (fs, &handle->shared->inode); 40016a64: 7f ff c9 7e call 4000905c 40016a68: 90 10 00 18 mov %i0, %o0 if (rrc == 0) 40016a6c: 80 a2 20 00 cmp %o0, 0 40016a70: 02 80 00 22 be 40016af8 <== ALWAYS TAKEN 40016a74: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 rc = rtems_rfs_block_map_close (fs, &handle->shared->map); 40016a78: 10 bf ff a9 b 4001691c <== NOT EXECUTED 40016a7c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n", 40016a80: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED 40016a84: d2 27 bf fc st %o1, [ %fp + -4 ] <== NOT EXECUTED 40016a88: 40 00 22 e1 call 4001f60c <== NOT EXECUTED 40016a8c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 40016a90: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED 40016a94: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40016a98: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 40016a9c: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 40016aa0: 7f ff b0 96 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40016aa4: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 40023ea0 <== NOT EXECUTED if (rrc == 0) 40016aa8: 10 bf ff eb b 40016a54 <== NOT EXECUTED 40016aac: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n", 40016ab0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED 40016ab4: d2 27 bf fc st %o1, [ %fp + -4 ] <== NOT EXECUTED 40016ab8: 40 00 22 d5 call 4001f60c <== NOT EXECUTED 40016abc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 40016ac0: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED 40016ac4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40016ac8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 40016acc: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 40016ad0: 7f ff b0 8a call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40016ad4: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 40023ed8 <== NOT EXECUTED rtems_chain_extract_unprotected (&handle->shared->link); 40016ad8: 10 bf ff ca b 40016a00 <== NOT EXECUTED 40016adc: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED if (!rtems_rfs_block_size_equal (&handle->shared->size, 40016ae0: c6 02 60 40 ld [ %o1 + 0x40 ], %g3 40016ae4: 80 a0 80 03 cmp %g2, %g3 40016ae8: 32 bf ff 8a bne,a 40016910 <== NEVER TAKEN 40016aec: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED 40016af0: 10 bf ff 8c b 40016920 40016af4: 92 02 60 34 add %o1, 0x34, %o1 rtems_rfs_write_u32 (&handle->node->atime, atime); 40016af8: 10 bf ff 56 b 40016850 40016afc: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 =============================================================================== 400174b8 : return _Chain_Immutable_head( the_chain )->next; 400174b8: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 return &the_chain->Tail.Node; 400174bc: 90 02 20 78 add %o0, 0x78, %o0 while (!rtems_chain_is_tail (&fs->file_shares, node)) 400174c0: 80 a0 40 08 cmp %g1, %o0 400174c4: 32 80 00 08 bne,a 400174e4 400174c8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 return shared; node = rtems_chain_next (node); } return NULL; 400174cc: 10 80 00 0b b 400174f8 400174d0: 82 10 20 00 clr %g1 while (!rtems_chain_is_tail (&fs->file_shares, node)) 400174d4: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 400174d8: 22 80 00 08 be,a 400174f8 <== NOT EXECUTED 400174dc: 82 10 20 00 clr %g1 <== NOT EXECUTED if (shared->inode.ino == ino) 400174e0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED 400174e4: 80 a0 80 09 cmp %g2, %o1 400174e8: 32 bf ff fb bne,a 400174d4 <== NEVER TAKEN 400174ec: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED } 400174f0: 81 c3 e0 08 retl 400174f4: 90 10 00 01 mov %g1, %o0 400174f8: 81 c3 e0 08 retl 400174fc: 90 10 00 01 mov %g1, %o0 =============================================================================== 40016d74 : { 40016d74: 9d e3 bf 98 save %sp, -104, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 40016d78: 90 10 20 20 mov 0x20, %o0 40016d7c: 92 10 20 00 clr %o1 40016d80: 7f ff cf 91 call 4000abc4 40016d84: b8 10 00 18 mov %i0, %i4 40016d88: 80 a2 20 00 cmp %o0, 0 40016d8c: 22 80 00 0c be,a 40016dbc <== ALWAYS TAKEN 40016d90: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 printf ("rtems-rfs: file-io: end: %s size=%zu\n", 40016d94: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 40016d98: 12 80 00 6e bne 40016f50 <== NOT EXECUTED 40016d9c: 13 10 00 87 sethi %hi(0x40021c00), %o1 <== NOT EXECUTED 40016da0: 13 10 00 8f sethi %hi(0x40023c00), %o1 <== NOT EXECUTED 40016da4: 92 12 63 40 or %o1, 0x340, %o1 ! 40023f40 <== NOT EXECUTED 40016da8: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED 40016dac: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 40016db0: 7f ff af d2 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40016db4: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 40016db8: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (&handle->buffer)) 40016dbc: c4 07 20 0c ld [ %i4 + 0xc ], %g2 40016dc0: 80 a0 a0 00 cmp %g2, 0 40016dc4: 02 80 00 73 be 40016f90 <== NEVER TAKEN 40016dc8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 if (!read) 40016dcc: 80 a6 a0 00 cmp %i2, 0 40016dd0: 12 80 00 50 bne 40016f10 40016dd4: 92 07 20 04 add %i4, 4, %o1 rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); 40016dd8: 82 10 20 01 mov 1, %g1 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 40016ddc: 7f ff c1 da call 40007544 40016de0: c2 2f 20 04 stb %g1, [ %i4 + 4 ] if (rc > 0) 40016de4: b0 92 20 00 orcc %o0, 0, %i0 40016de8: 14 80 00 84 bg 40016ff8 <== NEVER TAKEN 40016dec: 13 10 00 8f sethi %hi(0x40023c00), %o1 handle->bpos.boff += size; 40016df0: d4 07 20 14 ld [ %i4 + 0x14 ], %o2 rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 40016df4: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 40016df8: c4 00 60 98 ld [ %g1 + 0x98 ], %g2 handle->bpos.boff += size; 40016dfc: b2 06 40 0a add %i1, %o2, %i1 40016e00: f2 27 20 14 st %i1, [ %i4 + 0x14 ] rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 40016e04: c4 00 a0 08 ld [ %g2 + 8 ], %g2 if (handle->bpos.boff >= 40016e08: 80 a0 80 19 cmp %g2, %i1 40016e0c: 18 80 00 0a bgu 40016e34 40016e10: 88 10 20 01 mov 1, %g4 handle->bpos.bno++; 40016e14: c6 07 20 10 ld [ %i4 + 0x10 ], %g3 40016e18: 86 00 e0 01 inc %g3 handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 40016e1c: b2 26 40 02 sub %i1, %g2, %i1 handle->bpos.bno++; 40016e20: c6 27 20 10 st %g3, [ %i4 + 0x10 ] handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 40016e24: f2 27 20 14 st %i1, [ %i4 + 0x14 ] if (!read && 40016e28: 80 a6 a0 00 cmp %i2, 0 40016e2c: 12 80 00 0e bne 40016e64 40016e30: 84 10 20 00 clr %g2 rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 40016e34: fa 07 20 10 ld [ %i4 + 0x10 ], %i5 if (!read && 40016e38: 80 a7 60 00 cmp %i5, 0 40016e3c: 02 80 00 47 be 40016f58 40016e40: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 40016e44: 80 a0 a0 00 cmp %g2, 0 40016e48: 12 80 00 45 bne 40016f5c <== ALWAYS TAKEN 40016e4c: 80 a7 40 02 cmp %i5, %g2 40016e50: c6 07 20 14 ld [ %i4 + 0x14 ], %g3 <== NOT EXECUTED map->size.offset = offset; 40016e54: c6 20 60 40 st %g3, [ %g1 + 0x40 ] map->dirty = true; 40016e58: 86 10 20 01 mov 1, %g3 40016e5c: c6 28 60 34 stb %g3, [ %g1 + 0x34 ] length = true; 40016e60: 84 10 20 01 mov 1, %g2 atime = rtems_rfs_file_update_atime (handle); 40016e64: c2 07 00 00 ld [ %i4 ], %g1 40016e68: b2 08 60 01 and %g1, 1, %i1 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 40016e6c: b7 30 60 01 srl %g1, 1, %i3 length = rtems_rfs_file_update_length (handle) && length; 40016e70: bb 30 60 02 srl %g1, 2, %i5 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 40016e74: 90 10 20 20 mov 0x20, %o0 40016e78: 92 10 20 00 clr %o1 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 40016e7c: b6 1e e0 01 xor %i3, 1, %i3 length = rtems_rfs_file_update_length (handle) && length; 40016e80: ba 1f 60 01 xor %i5, 1, %i5 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 40016e84: b6 0e e0 01 and %i3, 1, %i3 length = rtems_rfs_file_update_length (handle) && length; 40016e88: ba 0f 60 01 and %i5, 1, %i5 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 40016e8c: b6 0e c0 04 and %i3, %g4, %i3 length = rtems_rfs_file_update_length (handle) && length; 40016e90: ba 0f 40 02 and %i5, %g2, %i5 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 40016e94: 7f ff cf 4c call 4000abc4 40016e98: a0 1e 60 01 xor %i1, 1, %l0 40016e9c: 80 a2 20 00 cmp %o0, 0 40016ea0: 02 80 00 0f be 40016edc <== ALWAYS TAKEN 40016ea4: ba 0f 60 ff and %i5, 0xff, %i5 printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n", 40016ea8: d4 07 20 14 ld [ %i4 + 0x14 ], %o2 <== NOT EXECUTED 40016eac: d2 07 20 10 ld [ %i4 + 0x10 ], %o1 <== NOT EXECUTED 40016eb0: 96 06 7f ff add %i1, -1, %o3 <== NOT EXECUTED 40016eb4: 99 2e e0 05 sll %i3, 5, %o4 <== NOT EXECUTED 40016eb8: 96 0a e0 14 and %o3, 0x14, %o3 <== NOT EXECUTED 40016ebc: 9a 20 00 1d neg %i5, %o5 <== NOT EXECUTED 40016ec0: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED 40016ec4: 9a 0b 60 1f and %o5, 0x1f, %o5 <== NOT EXECUTED 40016ec8: 98 03 20 2d add %o4, 0x2d, %o4 <== NOT EXECUTED 40016ecc: 9a 03 60 2d add %o5, 0x2d, %o5 <== NOT EXECUTED 40016ed0: 96 02 e0 2d add %o3, 0x2d, %o3 <== NOT EXECUTED 40016ed4: 7f ff af 89 call 40002cf8 <__wrap_printf> <== NOT EXECUTED 40016ed8: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED if (atime || mtime) 40016edc: 80 94 00 1b orcc %l0, %i3, %g0 40016ee0: 12 80 00 36 bne 40016fb8 <== ALWAYS TAKEN 40016ee4: 01 00 00 00 nop if (length) 40016ee8: 80 a7 60 00 cmp %i5, 0 40016eec: 02 80 00 5b be 40017058 40016ef0: 01 00 00 00 nop rtems_rfs_block_map_count (rtems_rfs_file_map (handle)); 40016ef4: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 handle->shared->size.count = 40016ef8: c6 00 60 3c ld [ %g1 + 0x3c ], %g3 handle->shared->size.offset = 40016efc: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 handle->shared->size.count = 40016f00: c6 20 60 84 st %g3, [ %g1 + 0x84 ] handle->shared->size.offset = 40016f04: c4 20 60 88 st %g2, [ %g1 + 0x88 ] 40016f08: 81 c7 e0 08 ret 40016f0c: 81 e8 00 00 restore rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 40016f10: 7f ff c1 8d call 40007544 40016f14: 01 00 00 00 nop if (rc > 0) 40016f18: b0 92 20 00 orcc %o0, 0, %i0 40016f1c: 14 80 00 44 bg 4001702c <== NEVER TAKEN 40016f20: 13 10 00 87 sethi %hi(0x40021c00), %o1 handle->bpos.boff += size; 40016f24: d4 07 20 14 ld [ %i4 + 0x14 ], %o2 rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 40016f28: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 40016f2c: c4 00 60 98 ld [ %g1 + 0x98 ], %g2 handle->bpos.boff += size; 40016f30: b2 06 40 0a add %i1, %o2, %i1 40016f34: f2 27 20 14 st %i1, [ %i4 + 0x14 ] rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 40016f38: c4 00 a0 08 ld [ %g2 + 8 ], %g2 if (handle->bpos.boff >= 40016f3c: 80 a6 40 02 cmp %i1, %g2 40016f40: 1a bf ff b5 bcc 40016e14 40016f44: 88 10 20 00 clr %g4 length = false; 40016f48: 10 bf ff c7 b 40016e64 40016f4c: 84 10 20 00 clr %g2 printf ("rtems-rfs: file-io: end: %s size=%zu\n", 40016f50: 10 bf ff 96 b 40016da8 <== NOT EXECUTED 40016f54: 92 12 62 a8 or %o1, 0x2a8, %o1 <== NOT EXECUTED rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 40016f58: 80 a7 40 02 cmp %i5, %g2 40016f5c: 3a bf ff be bcc,a 40016e54 40016f60: c6 07 20 14 ld [ %i4 + 0x14 ], %g3 40016f64: 86 00 bf ff add %g2, -1, %g3 40016f68: 80 a7 40 03 cmp %i5, %g3 40016f6c: 12 bf ff be bne 40016e64 40016f70: 84 10 20 00 clr %g2 40016f74: c6 07 20 14 ld [ %i4 + 0x14 ], %g3 40016f78: fa 00 60 40 ld [ %g1 + 0x40 ], %i5 40016f7c: 80 a0 c0 1d cmp %g3, %i5 40016f80: 28 bf ff ba bleu,a 40016e68 40016f84: c2 07 00 00 ld [ %i4 ], %g1 40016f88: 10 bf ff b4 b 40016e58 40016f8c: c6 20 60 40 st %g3, [ %g1 + 0x40 ] handle->bpos.boff += size; 40016f90: d4 07 20 14 ld [ %i4 + 0x14 ], %o2 <== NOT EXECUTED 40016f94: b2 06 40 0a add %i1, %o2, %i1 <== NOT EXECUTED 40016f98: f2 27 20 14 st %i1, [ %i4 + 0x14 ] <== NOT EXECUTED mtime = !read; 40016f9c: 88 1e a0 01 xor %i2, 1, %g4 <== NOT EXECUTED rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 40016fa0: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED if (handle->bpos.boff >= 40016fa4: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 40016fa8: 0a bf ff a0 bcs 40016e28 <== NOT EXECUTED 40016fac: b0 10 20 00 clr %i0 <== NOT EXECUTED handle->bpos.bno++; 40016fb0: 10 bf ff 9a b 40016e18 <== NOT EXECUTED 40016fb4: c6 07 20 10 ld [ %i4 + 0x10 ], %g3 <== NOT EXECUTED time_t now = time (NULL); 40016fb8: 40 00 22 93 call 4001fa04