RTEMS-6
Annotated Report
librfs
Sun Feb 28 22:23:30 2021
40006c90 <rtems_rfs_bitmap_create_search>:
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 <rtems_rfs_bitmap_create_search+0x124>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_bitmap_create_search+0x114> <== 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 <rtems_rfs_bitmap_create_search+0x8c> <== 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 <rtems_rfs_bitmap_create_search+0x94>
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 <rtems_rfs_bitmap_create_search+0x10c>
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 <rtems_rfs_bitmap_create_search+0xd4>
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 <rtems_rfs_bitmap_create_search+0xbc>
40006d38: 80 a1 20 00 cmp %g4, 0
while (size)
40006d3c: 02 bf ff f8 be 40006d1c <rtems_rfs_bitmap_create_search+0x8c>
40006d40: b2 06 60 01 inc %i1
40006d44: 10 bf ff ee b 40006cfc <rtems_rfs_bitmap_create_search+0x6c>
40006d48: b8 07 20 04 add %i4, 4, %i4
if (size > 0)
40006d4c: 02 bf ff f4 be 40006d1c <rtems_rfs_bitmap_create_search+0x8c>
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 <rtems_rfs_bitmap_create_search+0x6c>
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 <rtems_rfs_bitmap_create_search+0xf8>
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 <rtems_rfs_bitmap_create_search+0xe0>
40006d90: 87 2e 80 01 sll %i2, %g1, %g3
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
40006d94: 10 bf ff e8 b 40006d34 <rtems_rfs_bitmap_create_search+0xa4>
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 <rtems_rfs_bitmap_create_search+0xd8>
40006da0: 88 10 20 00 clr %g4
if (rc > 0)
40006da4: 04 bf ff ca ble 40006ccc <rtems_rfs_bitmap_create_search+0x3c> <== 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 <rtems_rfs_bitmap_map_alloc>:
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
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 <rtems_rfs_bitmap_map_alloc+0x88>
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 <rtems_rfs_bitmap_map_alloc+0x88>
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 <rtems_rfs_search_map_for_clear_bit.constprop.0>
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 <rtems_rfs_bitmap_map_alloc+0xf4> <== 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 <rtems_rfs_bitmap_map_alloc+0xf4>
40006bec: 80 a7 60 00 cmp %i5, 0
break;
}
if (lower_seed >= 0)
40006bf0: 36 80 00 14 bge,a 40006c40 <rtems_rfs_bitmap_map_alloc+0xac>
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 <rtems_rfs_bitmap_map_alloc+0x10> <== 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 <rtems_rfs_bitmap_map_alloc+0x20> <== 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 <rtems_rfs_bitmap_map_alloc+0xf4>
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 <rtems_rfs_bitmap_map_alloc+0xf4>
40006c30: 80 a6 40 01 cmp %i1, %g1
if (upper_seed < control->size)
40006c34: 2a bf ff e3 bcs,a 40006bc0 <rtems_rfs_bitmap_map_alloc+0x2c> <== 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 <rtems_rfs_search_map_for_clear_bit.constprop.0>
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 <rtems_rfs_bitmap_map_alloc+0xf4> <== 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 <rtems_rfs_bitmap_map_alloc+0xf4>
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 <rtems_rfs_bitmap_map_alloc+0xec>
40006c7c: b2 06 68 00 add %i1, 0x800, %i1
if (lower_seed >= 0)
lower_seed -= window;
40006c80: 10 bf ff c8 b 40006ba0 <rtems_rfs_bitmap_map_alloc+0xc>
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 <rtems_rfs_bitmap_map_clear>:
{
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 <rtems_rfs_bitmap_map_clear+0xac>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_bitmap_map_clear+0xb8> <== 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 <rtems_rfs_bitmap_map_clear+0xa4>
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 <rtems_rfs_bitmap_map_clear+0xa4> <== 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 <rtems_rfs_bitmap_map_clear+0xa4> <== NOT EXECUTED
40006980: 88 10 20 00 clr %g4 <== NOT EXECUTED
if (bit >= control->size)
40006984: 10 bf ff e0 b 40006904 <rtems_rfs_bitmap_map_clear+0x40> <== NOT EXECUTED
40006988: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
40006ac4 <rtems_rfs_bitmap_map_clear_all>:
{
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 <rtems_rfs_bitmap_map_clear_all+0xc8>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_bitmap_map_clear_all+0xb0> <== 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 <memset>
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 <rtems_rfs_bitmap_map_clear_all+0xa4>
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 <rtems_rfs_bitmap_map_clear_all+0x8c>
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 <memset>
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 <rtems_rfs_bitmap_map_clear_all+0x68>
40006b70: b3 36 40 1b srl %i1, %i3, %i1
if (rc > 0)
40006b74: 24 80 00 04 ble,a 40006b84 <rtems_rfs_bitmap_map_clear_all+0xc0> <== 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 <rtems_rfs_bitmap_map_clear_all+0x3c> <== 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 <rtems_rfs_bitmap_map_set>:
{
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 <rtems_rfs_bitmap_map_set+0xb4>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_bitmap_map_set+0xc8> <== 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 <rtems_rfs_bitmap_map_set+0xb8>
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 <rtems_rfs_bitmap_map_set+0xc0>
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 <rtems_rfs_bitmap_map_set+0xc0>
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 <rtems_rfs_bitmap_map_set+0xb8> <== NOT EXECUTED
400068b8: 86 10 20 00 clr %g3 <== NOT EXECUTED
if (bit >= control->size)
400068bc: 10 bf ff dc b 4000682c <rtems_rfs_bitmap_map_set+0x40> <== NOT EXECUTED
400068c0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
40006a20 <rtems_rfs_bitmap_map_set_all>:
{
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 <rtems_rfs_bitmap_map_set_all+0x9c>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_bitmap_map_set_all+0x84> <== 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 <memset>
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 <memset>
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 <rtems_rfs_bitmap_map_set_all+0x94> <== 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 <rtems_rfs_bitmap_map_set_all+0x3c> <== 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 <rtems_rfs_bitmap_map_test>:
{
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 <rtems_rfs_bitmap_map_test+0x8c>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_bitmap_map_test+0x7c> <== 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 <rtems_rfs_bitmap_map_test+0x74>
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 <rtems_rfs_bitmap_map_test+0x74> <== NOT EXECUTED
40006a0c: 84 10 20 00 clr %g2 <== NOT EXECUTED
if (bit >= control->size)
40006a10: 10 bf ff ef b 400069cc <rtems_rfs_bitmap_map_test+0x40> <== 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 <rtems_rfs_block_map_close>:
{
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 <rtems_rfs_block_map_close+0x38>
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 <rtems_rfs_block_map_close+0x3c> <== 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 <rtems_rfs_inode_load>
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 <rtems_rfs_block_map_close+0x78> <== 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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close+0x80>
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 <rtems_rfs_inode_unload>
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 <rtems_rfs_block_map_close+0x38>
40014460: ba 0a 00 01 and %o0, %g1, %i5
40014464 <rtems_rfs_block_map_find>:
{
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 <rtems_rfs_block_map_find+0x24>
40014478: c4 06 60 08 ld [ %i1 + 8 ], %g2
4001447c: 80 a0 a0 00 cmp %g2, 0
40014480: 02 80 00 1a be 400144e8 <rtems_rfs_block_map_find+0x84> <== 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 <rtems_rfs_block_map_find+0x84>
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 <rtems_rfs_block_map_find+0x11c>
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 <rtems_rfs_block_map_find+0x8c>
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 <rtems_rfs_block_map_find+0x130>
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 <rtems_rfs_block_map_find+0x84> <== 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 <rtems_rfs_block_find_indirect>
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 <rtems_rfs_block_map_find+0x84> <== 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 <rtems_rfs_block_map_find+0x144>
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 <rtems_rfs_block_map_find+0x44>
40014588: 80 a0 a0 05 cmp %g2, 5
*block = map->bpos.block;
4001458c: 10 bf ff ce b 400144c4 <rtems_rfs_block_map_find+0x60>
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 <rtems_rfs_block_find_indirect>
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 <rtems_rfs_block_map_find+0x64> <== ALWAYS TAKEN
400145c0: 90 10 20 00 clr %o0
400145c4: 30 bf ff c9 b,a 400144e8 <rtems_rfs_block_map_find+0x84> <== NOT EXECUTED
40014674 <rtems_rfs_block_map_grow>:
{
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 <rtems_rfs_trace>
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 <rtems_rfs_block_map_grow+0x3ac> <== 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 <rtems_rfs_block_map_grow+0x32c> <== 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 <rtems_rfs_block_map_grow+0x3c4> <== 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 <rtems_rfs_block_map_grow+0x90>
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 <rtems_rfs_block_map_grow+0x7c> <== 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 <rtems_rfs_block_map_grow+0x3c4> <== 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 <rtems_rfs_group_bitmap_alloc>
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 <rtems_rfs_block_map_grow+0x32c>
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 <rtems_rfs_block_map_grow+0x54>
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 <rtems_rfs_block_map_grow+0x1a0>
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 <rtems_rfs_block_map_grow+0x104>
40014764: 80 a0 40 16 cmp %g1, %l6
40014768: 1a 80 00 90 bcc 400149a8 <rtems_rfs_block_map_grow+0x334>
4001476c: 80 a4 e0 05 cmp %l3, 5
40014770: 32 80 00 8f bne,a 400149ac <rtems_rfs_block_map_grow+0x338>
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 <rtems_rfs_block_map_indirect_alloc>
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 <rtems_rfs_block_map_grow+0x320> <== 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 <rtems_rfs_block_map_grow+0x64>
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 <rtems_rfs_block_map_grow+0x298>
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 <rtems_rfs_block_map_indirect_alloc>
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 <rtems_rfs_block_map_grow+0x31c> <== NEVER TAKEN
40014858: 80 a5 20 00 cmp %l4, 0
if ((singly == 0) ||
4001485c: 02 80 00 06 be 40014874 <rtems_rfs_block_map_grow+0x200> <== NEVER TAKEN
40014860: 80 a5 40 16 cmp %l5, %l6
40014864: 1a 80 00 5b bcc 400149d0 <rtems_rfs_block_map_grow+0x35c> <== NEVER TAKEN
40014868: 80 a5 20 05 cmp %l4, 5
4001486c: 12 80 00 5a bne 400149d4 <rtems_rfs_block_map_grow+0x360>
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 <rtems_rfs_block_map_indirect_alloc>
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 <rtems_rfs_block_map_grow+0x38c> <== 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 <rtems_rfs_block_map_grow+0x13c>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_block_map_grow+0x31c> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_block_map_grow+0x140> <== 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 <rtems_rfs_group_bitmap_free> <== 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 <rtems_rfs_buffer_handle_request>
400149c4: 90 10 00 18 mov %i0, %o0
400149c8: 10 bf ff 77 b 400147a4 <rtems_rfs_block_map_grow+0x130>
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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_block_map_grow+0x240> <== 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 <rtems_rfs_group_bitmap_free> <== 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 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
40014a18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
40014a1c: 30 bf ff e1 b,a 400149a0 <rtems_rfs_block_map_grow+0x32c> <== 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 <IMFS_LIMITS_AND_OPTIONS+0xb8> <== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
40014a30: 10 bf ff 19 b 40014694 <rtems_rfs_block_map_grow+0x20> <== 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 <rtems_rfs_block_map_open>:
{
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 <rtems_rfs_inode_load>
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 <rtems_rfs_block_map_open+0x140> <== 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 <rtems_rfs_block_map_open+0x64>
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 <rtems_rfs_inode_unload>
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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_shrink>:
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 <rtems_rfs_trace>
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 <rtems_rfs_block_map_shrink+0x2a4> <== 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 <rtems_rfs_block_map_shrink+0x290>
40014a6c: 80 a0 40 1a cmp %g1, %i2
return 0;
if (blocks > map->size.count)
40014a70: 18 80 00 9c bgu 40014ce0 <rtems_rfs_block_map_shrink+0x29c>
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 <rtems_rfs_block_map_shrink+0x274> <== 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 <rtems_rfs_block_map_shrink+0x90>
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 <rtems_rfs_group_bitmap_free>
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 <rtems_rfs_block_map_shrink+0x1f0> <== 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 <rtems_rfs_block_map_shrink+0x268>
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 <rtems_rfs_block_map_shrink+0x4c>
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 <rtems_rfs_block_map_shrink+0x1f8> <== 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 <rtems_rfs_block_map_shrink+0x268> <== 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 <rtems_rfs_buffer_handle_request> <== 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 <rtems_rfs_block_map_shrink+0x1f0> <== 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 <rtems_rfs_buffer_handle_request> <== 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 <rtems_rfs_block_map_shrink+0x1f0> <== 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 <rtems_rfs_block_map_shrink+0x58> <== 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 <rtems_rfs_group_bitmap_free> <== 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 <rtems_rfs_block_map_shrink+0x1f0> <== 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 <rtems_rfs_block_map_indirect_shrink>
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 <rtems_rfs_block_map_shrink+0x5c> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_block_map_shrink+0x1f0> <== 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 <rtems_rfs_block_map_shrink+0x1d8>
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 <rtems_rfs_block_map_shrink+0x2bc>
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 <rtems_rfs_block_map_shrink+0x300> <== 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 <rtems_rfs_block_map_shrink+0x2e8> <== 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 <rtems_rfs_block_map_shrink+0x34>
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 <IMFS_LIMITS_AND_OPTIONS+0xf0> <== NOT EXECUTED
if (map->size.count == 0)
40014cf8: 10 bf ff 5b b 40014a64 <rtems_rfs_block_map_shrink+0x20> <== 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 <rtems_rfs_block_map_shrink+0x290> <== 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 <rtems_rfs_block_map_shrink+0x1f0> <== 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 <rtems_rfs_block_map_shrink+0x2c8> <== ALWAYS TAKEN
40014d38: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
return 0;
40014d3c: 10 bf ff e7 b 40014cd8 <rtems_rfs_block_map_shrink+0x294> <== 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 <rtems_rfs_block_map_shrink+0x2c4> <== NOT EXECUTED
40014d48: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
40014dac <rtems_rfs_buffer_bdbuf_release>:
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 <rtems_rfs_trace>
40014db8: 92 10 20 40 mov 0x40, %o1
40014dbc: 80 a2 20 00 cmp %o0, 0
40014dc0: 02 80 00 0b be 40014dec <rtems_rfs_buffer_bdbuf_release+0x40> <== 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 <rtems_rfs_buffer_bdbuf_release+0x80> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x140><== 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 <rtems_rfs_buffer_bdbuf_release+0x64>
40014df0: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
40014df4: 7f ff f5 0f call 40012230 <rtems_bdbuf_release_modified>
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 <rtems_bdbuf_release>
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 <rtems_rfs_buffer_bdbuf_release+0x30> <== NOT EXECUTED
40014e34: 96 12 e2 70 or %o3, 0x270, %o3 ! 40023670 <IMFS_LIMITS_AND_OPTIONS+0x130><== NOT EXECUTED
40007920 <rtems_rfs_buffer_close>:
{
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 <rtems_rfs_trace>
40007930: ba 10 00 18 mov %i0, %i5
40007934: 80 a2 20 00 cmp %o0, 0
40007938: 12 80 00 30 bne 400079f8 <rtems_rfs_buffer_close+0xd8> <== 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 <rtems_rfs_buffer_setblksize>
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 <rtems_rfs_buffer_close+0xa4> <== NEVER TAKEN
40007958: 90 10 20 00 clr %o0
if (close (fs->device) < 0)
4000795c: 40 00 2c bc call 40012c4c <close>
40007960: d0 07 60 0c ld [ %i5 + 0xc ], %o0
40007964: 80 a2 20 00 cmp %o0, 0
40007968: 06 80 00 04 bl 40007978 <rtems_rfs_buffer_close+0x58> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_close+0x9c> <== 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 <strerror> <== 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 <IMFS_node_control_sym_link+0x510><== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_close+0x3c> <== 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 <strerror> <== 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 <IMFS_node_control_sym_link+0x4d0><== NOT EXECUTED
400079f4: 30 bf ff da b,a 4000795c <rtems_rfs_buffer_close+0x3c> <== 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 <rtems_rfs_buffer_close+0x24> <== NOT EXECUTED
40007a04: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
40006fe0 <rtems_rfs_buffer_handle_release.part.0>:
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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x60> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x114> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x12c> <== 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 <IMFS_node_control_sym_link+0xb0><== 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 <rtems_rfs_buffer_handle_release.part.0+0x7c> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x10c><== 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 <rtems_rfs_buffer_handle_release.part.0+0x164><== 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 <rtems_rfs_buffer_handle_release.part.0+0x17c><== 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 <rtems_rfs_buffer_handle_release.part.0+0x138><== 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 <rtems_rfs_buffer_handle_release.part.0+0x48> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x50> <== NOT EXECUTED
40007114: 98 13 22 28 or %o4, 0x228, %o4 ! 40021e28 <IMFS_node_control_sym_link+0xa0><== 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 <rtems_rfs_buffer_bdbuf_release> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x224><== 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 <rtems_rfs_buffer_handle_release.part.0+0x1d4><== 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 <rtems_rfs_buffer_handle_release.part.0+0x214> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x1fc> <== 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 <rtems_rfs_buffer_handle_release.part.0+0x21c> <== 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 <rtems_rfs_buffer_bdbuf_release> <== 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 <rtems_rfs_buffer_handle_release.part.0+0xcc> <== NOT EXECUTED
400071f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return NULL;
400071f4: 10 bf ff ec b 400071a4 <rtems_rfs_buffer_handle_release.part.0+0x1c4> <== NOT EXECUTED
400071f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
400071fc: 10 bf ff f5 b 400071d0 <rtems_rfs_buffer_handle_release.part.0+0x1f0> <== 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 <IMFS_node_control_sym_link+0xe8><== NOT EXECUTED
if (fs->release_count > fs->release_modified_count)
40007218: 10 bf ff d7 b 40007174 <rtems_rfs_buffer_handle_release.part.0+0x194> <== NOT EXECUTED
4000721c: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
40007220 <rtems_rfs_buffer_handle_request>:
{
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 <rtems_rfs_buffer_handle_request+0x74>
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 <rtems_rfs_buffer_handle_request+0x30> <== 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 <rtems_rfs_buffer_handle_request+0x20c>
4000724c: 01 00 00 00 nop
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
40007250: 40 00 0e 5d call 4000abc4 <rtems_rfs_trace>
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 <rtems_rfs_buffer_handle_request+0x1e8> <== 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 <rtems_rfs_buffer_handle_request+0x70> <== 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 <rtems_rfs_buffer_handle_release.part.0>
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 <rtems_rfs_buffer_handle_request+0x2f0> <== 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 <rtems_rfs_trace>
4000729c: 92 10 21 00 mov 0x100, %o1
400072a0: 80 a2 20 00 cmp %o0, 0
400072a4: 32 80 00 50 bne,a 400073e4 <rtems_rfs_buffer_handle_request+0x1c4> <== 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 <rtems_rfs_buffer_handle_request+0x174>
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 <rtems_rfs_buffer_handle_request+0x13c>
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 <rtems_rfs_buffer_handle_request+0x254>
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 <rtems_rfs_trace>
40007318: f4 26 60 04 st %i2, [ %i1 + 4 ]
4000731c: 80 a2 20 00 cmp %o0, 0
40007320: 02 80 00 43 be 4000742c <rtems_rfs_buffer_handle_request+0x20c> <== 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 <rtems_rfs_buffer_handle_request+0x214> <== 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 <IMFS_node_control_sym_link+0x200><== 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 <rtems_rfs_buffer_handle_request+0xbc> <== 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 <rtems_rfs_buffer_bdbuf_request>
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 <rtems_rfs_buffer_handle_request+0x29c> <== 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 <rtems_rfs_buffer_handle_request+0xb8>
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 <rtems_rfs_scan_chain>
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 <rtems_rfs_buffer_handle_request+0x240>
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 <rtems_rfs_trace>
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 <rtems_rfs_buffer_handle_request+0xa0> <== 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 <IMFS_node_control_sym_link+0x190><== NOT EXECUTED
if (!rtems_rfs_fs_no_local_cache (fs) &&
400073dc: 10 bf ff b9 b 400072c0 <rtems_rfs_buffer_handle_request+0xa0> <== 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 <IMFS_node_control_sym_link+0x168><== 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 <rtems_rfs_buffer_handle_request+0xa0> <== 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 <rtems_rfs_buffer_handle_request+0x174> <== 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 <IMFS_node_control_sym_link+0x130><== 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 <rtems_rfs_buffer_handle_request+0x58> <== NOT EXECUTED
40007420: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
handle->dirty = false;
40007424: 10 bf ff 9b b 40007290 <rtems_rfs_buffer_handle_request+0x70> <== 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 <IMFS_node_control_sym_link+0x200><== 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 <rtems_rfs_buffer_handle_request+0x14c>
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 <rtems_rfs_buffer_handle_request+0x2f8>
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 <rtems_rfs_buffer_handle_request+0x14c>
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 <rtems_rfs_scan_chain>
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 <rtems_rfs_buffer_handle_request+0x148>
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 <rtems_rfs_buffer_handle_request+0xb8>
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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_handle_request+0x134> <== 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 <rtems_rfs_buffer_handle_request+0x31c> <== 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 <IMFS_node_control_sym_link+0x128><== NOT EXECUTED
400074e0: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
400074e4: 40 00 60 4a call 4001f60c <strerror> <== 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 <IMFS_node_control_sym_link+0x1c8><== 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 <rtems_rfs_scan_chain>
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 <rtems_rfs_buffer_handle_request+0xb8>
40007530: 82 10 00 08 mov %o0, %g1
40007534: 10 bf ff d4 b 40007484 <rtems_rfs_buffer_handle_request+0x264>
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 <rtems_rfs_buffer_handle_request+0x2c0> <== NOT EXECUTED
40007540: 94 12 a2 a8 or %o2, 0x2a8, %o2 <== NOT EXECUTED
40007568 <rtems_rfs_buffer_open>:
{
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 <rtems_rfs_trace>
40007574: 92 10 20 20 mov 0x20, %o1
40007578: 80 a2 20 00 cmp %o0, 0
4000757c: 12 80 00 29 bne 40007620 <rtems_rfs_buffer_open+0xb8> <== NEVER TAKEN
40007580: 92 10 20 02 mov 2, %o1
fs->device = open (name, O_RDWR);
40007584: 40 00 2f 0a call 400131ac <open>
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 <rtems_rfs_buffer_open+0xe0> <== NEVER TAKEN
40007594: d0 26 60 0c st %o0, [ %i1 + 0xc ]
if (fstat (fs->device, &st) < 0)
40007598: 40 00 2d fa call 40012d80 <fstat>
4000759c: 92 07 bf 98 add %fp, -104, %o1
400075a0: 80 a2 20 00 cmp %o0, 0
400075a4: 06 80 00 4b bl 400076d0 <rtems_rfs_buffer_open+0x168> <== 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 <rtems_rfs_buffer_open+0x98> <== 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 <ioctl>
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 <rtems_rfs_buffer_open+0x140> <== 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 <rtems_rfs_trace>
400075e8: 92 10 20 20 mov 0x20, %o1
400075ec: 80 a2 20 00 cmp %o0, 0
400075f0: 32 80 00 21 bne,a 40007674 <rtems_rfs_buffer_open+0x10c> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_open+0x128> <== 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 <IMFS_node_control_sym_link+0x240><== 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 <open> <== 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 <rtems_rfs_buffer_open+0x30> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_open+0xb0> <== 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 <IMFS_node_control_sym_link+0x330><== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_open+0xb0> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_open+0xb0> <== 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 <strerror> <== 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 <IMFS_node_control_sym_link+0x298><== NOT EXECUTED
40007710: 81 c7 e0 08 ret <== NOT EXECUTED
40007714: 81 e8 00 00 restore <== NOT EXECUTED
4000781c <rtems_rfs_buffer_setblksize>:
{
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 <rtems_rfs_trace>
4000782c: 92 10 24 00 mov 0x400, %o1
40007830: 80 a2 20 00 cmp %o0, 0
40007834: 12 80 00 37 bne 40007910 <rtems_rfs_buffer_setblksize+0xf4> <== NEVER TAKEN
40007838: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
rc = rtems_rfs_buffers_release (fs);
4000783c: 7f ff ff d5 call 40007790 <rtems_rfs_buffers_release>
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 <rtems_rfs_buffer_setblksize+0xc0> <== NEVER TAKEN
4000784c: 90 10 20 00 clr %o0
rc = rtems_rfs_buffer_sync (fs);
40007850: 7f ff ff b2 call 40007718 <rtems_rfs_buffer_sync>
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 <rtems_rfs_buffer_setblksize+0x88> <== 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 <RAM_END+0x3fc44204>
if (rc < 0)
4000787c: b0 92 20 00 orcc %o0, 0, %i0
40007880: 06 80 00 04 bl 40007890 <rtems_rfs_buffer_setblksize+0x74> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_setblksize+0x4c> <== 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 <strerror> <== 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 <IMFS_node_control_sym_link+0x468><== NOT EXECUTED
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
400078d4: 10 bf ff e5 b 40007868 <rtems_rfs_buffer_setblksize+0x4c> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_setblksize+0x34> <== 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 <strerror> <== 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 <IMFS_node_control_sym_link+0x428><== NOT EXECUTED
4000790c: 30 bf ff d1 b,a 40007850 <rtems_rfs_buffer_setblksize+0x34> <== 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 <IMFS_node_control_sym_link+0x3f8><== NOT EXECUTED
4000791c: 30 bf ff c8 b,a 4000783c <rtems_rfs_buffer_setblksize+0x20> <== NOT EXECUTED
40007718 <rtems_rfs_buffer_sync>:
{
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 <rtems_rfs_trace>
40007724: 92 10 20 20 mov 0x20, %o1
40007728: 80 a2 20 00 cmp %o0, 0
4000772c: 12 80 00 16 bne 40007784 <rtems_rfs_buffer_sync+0x6c> <== 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 <rtems_bdbuf_syncdev>
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 <rtems_rfs_buffer_sync+0x64> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_buffer_sync+0x64> <== 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 <rtems_status_text> <== 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 <IMFS_node_control_sym_link+0x380><== 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 <rtems_rfs_buffer_sync+0x1c> <== NOT EXECUTED
40007790 <rtems_rfs_buffers_release>:
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 <rtems_rfs_trace>
4000779c: 92 10 20 40 mov 0x40, %o1
400077a0: 80 a2 20 00 cmp %o0, 0
400077a4: 32 80 00 17 bne,a 40007800 <rtems_rfs_buffers_release+0x70> <== 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 <rtems_rfs_release_chain>
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 <rtems_rfs_release_chain>
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 <rtems_rfs_buffers_release+0x5c> <== ALWAYS TAKEN
400077d8: 80 a7 60 00 cmp %i5, 0
400077dc: 34 80 00 05 bg,a 400077f0 <rtems_rfs_buffers_release+0x60> <== 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 <IMFS_node_control_sym_link+0x3b0><== NOT EXECUTED
rc = rtems_rfs_release_chain (&fs->release,
40007814: 10 bf ff e7 b 400077b0 <rtems_rfs_buffers_release+0x20> <== NOT EXECUTED
40007818: 92 06 20 60 add %i0, 0x60, %o1 <== NOT EXECUTED
400153a8 <rtems_rfs_dir_add_entry>:
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
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 <rtems_rfs_trace>
400153b8: a6 10 00 18 mov %i0, %l3
400153bc: 80 a2 20 00 cmp %o0, 0
400153c0: 12 80 00 a3 bne 4001564c <rtems_rfs_dir_add_entry+0x2a4> <== 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 <rtems_rfs_block_map_open>
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 <rtems_rfs_dir_add_entry+0x100> <== 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 <rtems_rfs_block_map_find>
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 <rtems_rfs_dir_add_entry+0x2f4>
4001541c: 80 a6 20 06 cmp %i0, 6
if (rc != ENXIO)
40015420: 12 80 00 d1 bne 40015764 <rtems_rfs_dir_add_entry+0x3bc> <== 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 <rtems_rfs_block_map_grow>
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 <rtems_rfs_dir_add_entry+0x374> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_dir_add_entry+0x108> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_add_entry+0x404> <== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_close> <== 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 <memset>
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 <rtems_rfs_dir_add_entry+0x58> <== NEVER TAKEN
400154d0: b0 10 20 00 clr %i0
400154d4: 10 80 00 13 b 40015520 <rtems_rfs_dir_add_entry+0x178>
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 <rtems_rfs_dir_add_entry+0x264> <== 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 <rtems_rfs_dir_add_entry+0x264> <== NEVER TAKEN
400154f4: 80 a4 60 00 cmp %l1, 0
400154f8: 02 80 00 45 be 4001560c <rtems_rfs_dir_add_entry+0x264> <== 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 <rtems_rfs_dir_add_entry+0x264> <== 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 <rtems_rfs_dir_add_entry+0x58> <== 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 <rtems_rfs_dir_add_entry+0x134>
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 <rtems_rfs_dir_add_entry+0x5c> <== 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 <rtems_rfs_dir_hash>
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 <memcpy>
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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close>
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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_add_entry+0x328> <== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_close> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x430><== 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 <rtems_rfs_dir_add_entry+0x2dc> <== 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 <putchar> <== 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 <rtems_rfs_dir_add_entry+0x2c4> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x458><== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
40015694: 10 bf ff 4d b 400153c8 <rtems_rfs_dir_add_entry+0x20> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_dir_add_entry+0xc4> <== NEVER TAKEN
400156c4: c2 07 bf ac ld [ %fp + -84 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
400156c8: 10 bf ff 7f b 400154c4 <rtems_rfs_dir_add_entry+0x11c>
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 <IMFS_LIMITS_AND_OPTIONS+0x540><== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_close> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_add_entry+0xe0> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x4b0><== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001575c: 10 bf ff 4b b 40015488 <rtems_rfs_dir_add_entry+0xe0> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_add_entry+0xe0> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x468><== NOT EXECUTED
400157a4: 10 bf ff 39 b 40015488 <rtems_rfs_dir_add_entry+0xe0> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x4f8><== NOT EXECUTED
400157d0: 10 bf ff 2e b 40015488 <rtems_rfs_dir_add_entry+0xe0> <== NOT EXECUTED
400157d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
400157d8 <rtems_rfs_dir_del_entry>:
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
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 <rtems_rfs_trace>
400157e8: a2 10 00 18 mov %i0, %l1
400157ec: 80 a2 20 00 cmp %o0, 0
400157f0: 32 80 00 77 bne,a 400159cc <rtems_rfs_dir_del_entry+0x1f4> <== 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 <rtems_rfs_block_map_open>
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 <rtems_rfs_dir_del_entry+0x1ec> <== 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 <rtems_rfs_block_map_seek>
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 <rtems_rfs_dir_del_entry+0x258> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_dir_del_entry+0x3e8> <== NEVER TAKEN
40015860: 80 a6 e0 00 cmp %i3, 0
if (search)
40015864: 02 80 00 46 be 4001597c <rtems_rfs_dir_del_entry+0x1a4> <== 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 <rtems_rfs_dir_del_entry+0x128> <== 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 <rtems_rfs_dir_del_entry+0x16c> <== 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 <rtems_rfs_dir_del_entry+0x1b0> <== 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 <rtems_rfs_dir_del_entry+0x1b0> <== NEVER TAKEN
400158c4: 80 a4 20 00 cmp %l0, 0
400158c8: 02 80 00 31 be 4001598c <rtems_rfs_dir_del_entry+0x1b4> <== 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 <rtems_rfs_dir_del_entry+0x1b0> <== 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 <rtems_rfs_dir_del_entry+0x278> <== ALWAYS TAKEN
400158e4: 80 a6 e0 00 cmp %i3, 0
if (!search)
400158e8: 32 80 00 2e bne,a 400159a0 <rtems_rfs_dir_del_entry+0x1c8> <== 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 <rtems_rfs_dir_del_entry+0x168> <== 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 <rtems_rfs_dir_del_entry+0xd4> <== 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 <rtems_rfs_dir_del_entry+0x1cc> <== 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 <rtems_rfs_block_map_next_block> <== 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 <rtems_rfs_dir_del_entry+0x430> <== 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 <rtems_rfs_dir_del_entry+0x70> <== 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 <rtems_rfs_dir_del_entry+0x1cc> <== 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 <rtems_rfs_dir_del_entry+0xb4> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_del_entry+0x210> <== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_close> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x588><== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
400159e0: 10 bf ff 87 b 400157fc <rtems_rfs_dir_del_entry+0x24> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x608><== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_close> <== 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 <rtems_rfs_dir_del_entry+0x264> <== 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 <rtems_rfs_block_map_close> <== 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 <memmove>
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 <memset>
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 <rtems_rfs_trace>
40015a90: ba 17 40 0a or %i5, %o2, %i5
40015a94: 80 a2 20 00 cmp %o0, 0
40015a98: 02 80 00 10 be 40015ad8 <rtems_rfs_dir_del_entry+0x300> <== 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 <rtems_rfs_dir_del_entry+0x3d0> <== 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 <IMFS_node_control_sym_link+0xf70><== 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 <rtems_rfs_dir_del_entry+0x384>
40015ae4: 80 a4 a0 00 cmp %l2, 0
40015ae8: 12 80 00 1d bne 40015b5c <rtems_rfs_dir_del_entry+0x384> <== 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 <rtems_rfs_dir_del_entry+0x3bc> <== 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 <rtems_rfs_block_map_shrink> <== 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 <rtems_rfs_dir_del_entry+0x388> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_del_entry+0x388> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x6b8><== 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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close>
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 <rtems_rfs_dir_del_entry+0x388> <== NOT EXECUTED
40015b9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40015ba0: 10 bf ff d9 b 40015b04 <rtems_rfs_dir_del_entry+0x32c> <== 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 <rtems_rfs_dir_del_entry+0x2dc> <== 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 <rtems_rfs_dir_del_entry+0x2e4> <== NOT EXECUTED
40015bbc: 9a 13 61 00 or %o5, 0x100, %o5 ! 40022d00 <IMFS_node_control_sym_link+0xf78><== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_del_entry+0x1cc> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x5c0><== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40015c00: 10 bf ff 69 b 400159a4 <rtems_rfs_dir_del_entry+0x1cc> <== NOT EXECUTED
40015c04: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rc = ENOENT;
40015c08: 10 bf ff 66 b 400159a0 <rtems_rfs_dir_del_entry+0x1c8> <== NOT EXECUTED
40015c0c: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
40015fdc <rtems_rfs_dir_empty>:
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 <rtems_rfs_trace>
40015fec: a2 10 00 18 mov %i0, %l1
40015ff0: 80 a2 20 00 cmp %o0, 0
40015ff4: 32 80 00 7b bne,a 400161e0 <rtems_rfs_dir_empty+0x204> <== 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 <rtems_rfs_block_map_open>
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 <rtems_rfs_dir_empty+0x1a4> <== 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 <rtems_rfs_block_map_seek>
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 <rtems_rfs_dir_empty+0x218> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_dir_empty+0x180> <== 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 <rtems_rfs_dir_empty+0x1d4> <== NEVER TAKEN
40016084: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
40016088: 10 80 00 10 b 400160c8 <rtems_rfs_dir_empty+0xec>
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 <rtems_rfs_dir_empty+0x178>
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 <rtems_rfs_dir_empty+0x178> <== 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 <rtems_rfs_dir_empty+0x178> <== 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 <rtems_rfs_dir_empty+0x1d4> <== 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 <rtems_rfs_dir_empty+0x1d4>
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 <rtems_rfs_dir_empty+0x1ac> <== 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 <rtems_rfs_dir_empty+0x1ac> <== NEVER TAKEN
40016120: 80 a7 20 00 cmp %i4, 0
40016124: 02 80 00 19 be 40016188 <rtems_rfs_dir_empty+0x1ac> <== 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 <rtems_rfs_dir_empty+0x1ac> <== 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 <rtems_rfs_dir_empty+0xb4>
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 <rtems_rfs_dir_empty+0xdc> <== ALWAYS TAKEN
40016150: 80 a6 20 00 cmp %i0, 0
break;
}
}
}
if ((rc == 0) && !empty)
40016154: 22 80 00 02 be,a 4001615c <rtems_rfs_dir_empty+0x180> <== 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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close>
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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_empty+0x1d4> <== 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 <rtems_rfs_block_map_next_block>
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 <rtems_rfs_dir_empty+0x80> <== 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 <rtems_rfs_dir_empty+0x180>
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 <IMFS_LIMITS_AND_OPTIONS+0x7e8><== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
400161ec: 10 bf ff 85 b 40016000 <rtems_rfs_dir_empty+0x24> <== 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 <rtems_rfs_block_map_close> <== 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_dir_lookup_ino>:
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 <rtems_rfs_trace>
40014e48: a0 10 00 18 mov %i0, %l0
40014e4c: 80 a2 20 00 cmp %o0, 0
40014e50: 32 80 00 e3 bne,a 400151dc <rtems_rfs_dir_lookup_ino+0x3a4> <== 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 <rtems_rfs_block_map_open>
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 <rtems_rfs_dir_lookup_ino+0x384> <== 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 <rtems_rfs_dir_hash>
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 <rtems_rfs_block_map_seek>
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 <rtems_rfs_dir_lookup_ino+0x3f0> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x238>
{
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 <rtems_rfs_dir_lookup_ino+0x284> <== 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 <rtems_rfs_dir_lookup_ino+0x46c> <== 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 <rtems_rfs_trace>
40014f00: 13 01 00 00 sethi %hi(0x4000000), %o1
40014f04: 80 a2 20 00 cmp %o0, 0
40014f08: 12 80 00 9a bne 40015170 <rtems_rfs_dir_lookup_ino+0x338> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_dir_lookup_ino+0x4e0> <== 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 <rtems_rfs_dir_lookup_ino+0x134> <== ALWAYS TAKEN
40014f44: ec 00 60 1c ld [ %g1 + 0x1c ], %l6
if (rc == 0)
40014f48: 10 80 00 90 b 40015188 <rtems_rfs_dir_lookup_ino+0x350> <== 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 <rtems_rfs_dir_lookup_ino+0x34c> <== 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 <rtems_rfs_dir_lookup_ino+0x34c>
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 <rtems_rfs_dir_lookup_ino+0x26c> <== 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 <rtems_rfs_dir_lookup_ino+0x268> <== NEVER TAKEN
40014ff0: 80 a3 e0 00 cmp %o7, 0
40014ff4: 22 80 00 2c be,a 400150a4 <rtems_rfs_dir_lookup_ino+0x26c> <== 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 <rtems_rfs_dir_lookup_ino+0x268> <== NEVER TAKEN
40015008: 80 a4 80 03 cmp %l2, %g3
if (ehash == hash)
4001500c: 12 bf ff d1 bne 40014f50 <rtems_rfs_dir_lookup_ino+0x118>
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 <rtems_rfs_trace>
4001501c: 92 10 00 15 mov %l5, %o1
40015020: 80 a2 20 00 cmp %o0, 0
40015024: 32 80 00 43 bne,a 40015130 <rtems_rfs_dir_lookup_ino+0x2f8> <== 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 <memcmp>
40015038: 92 10 00 1a mov %i2, %o1
4001503c: 80 a2 20 00 cmp %o0, 0
40015040: 12 bf ff c4 bne 40014f50 <rtems_rfs_dir_lookup_ino+0x118> <== 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 <rtems_rfs_block_get_pos>
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 <rtems_rfs_trace>
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 <rtems_rfs_dir_lookup_ino+0x554> <== 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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close>
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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_lookup_ino+0x2b0> <== 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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close>
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 <IMFS_LIMITS_AND_OPTIONS+0x2b0><== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_block_map_close> <== 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 <rtems_rfs_dir_lookup_ino+0x1f8> <== 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 <rtems_rfs_dir_lookup_ino+0xdc> <== 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 <rtems_rfs_dir_lookup_ino+0x288> <== 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 <rtems_rfs_block_map_next_block>
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 <rtems_rfs_dir_lookup_ino+0x45c> <== NEVER TAKEN
400151a8: 80 a6 20 06 cmp %i0, 6
400151ac: 12 80 00 2a bne 40015254 <rtems_rfs_dir_lookup_ino+0x41c> <== NEVER TAKEN
400151b0: 90 10 20 00 clr %o0
rc = ENOENT;
400151b4: 10 bf ff c2 b 400150bc <rtems_rfs_dir_lookup_ino+0x284>
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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_lookup_ino+0x4b4> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x170><== 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 <rtems_rfs_dir_lookup_ino+0x3d8> <== 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 <putchar> <== 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 <rtems_rfs_dir_lookup_ino+0x3c0> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x1a8><== NOT EXECUTED
*ino = RTEMS_RFS_EMPTY_INO;
40015220: 10 bf ff 0f b 40014e5c <rtems_rfs_dir_lookup_ino+0x24> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_lookup_ino+0x530> <== 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 <rtems_rfs_dir_lookup_ino+0x288> <== NOT EXECUTED
40015248: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001524c: 10 bf ff 9d b 400150c0 <rtems_rfs_dir_lookup_ino+0x288> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_lookup_ino+0xb0> <== 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 <strerror> <== 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 <rtems_rfs_dir_lookup_ino+0xb0> <== NOT EXECUTED
40015290: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
if (rc == ENXIO)
40015294: 12 bf ff 15 bne 40014ee8 <rtems_rfs_dir_lookup_ino+0xb0> <== NOT EXECUTED
40015298: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
rc = ENOENT;
4001529c: 10 bf ff 88 b 400150bc <rtems_rfs_dir_lookup_ino+0x284> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_lookup_ino+0x284> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x3f0><== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400152e4: 10 bf ff 77 b 400150c0 <rtems_rfs_dir_lookup_ino+0x288> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x1b8><== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_lookup_ino+0x288> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x270><== NOT EXECUTED
40015360: 10 bf ff 58 b 400150c0 <rtems_rfs_dir_lookup_ino+0x288> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x1f8><== NOT EXECUTED
if (rc == ENXIO)
40015384: 10 bf ff b0 b 40015244 <rtems_rfs_dir_lookup_ino+0x40c> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x358><== NOT EXECUTED
400153a0: 10 bf ff 35 b 40015074 <rtems_rfs_dir_lookup_ino+0x23c> <== NOT EXECUTED
400153a4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
40015c10 <rtems_rfs_dir_read>:
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
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 <rtems_rfs_trace>
40015c20: a4 10 00 1a mov %i2, %l2
40015c24: 80 a2 20 00 cmp %o0, 0
40015c28: 12 80 00 81 bne 40015e2c <rtems_rfs_dir_read+0x21c> <== 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 <rtems_rfs_block_map_open>
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 <rtems_rfs_dir_read+0x198> <== 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 <rtems_rfs_dir_read+0x1a0> <== 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 <rtems_rfs_block_map_seek>
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 <rtems_rfs_dir_read+0x1fc> <== 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 <rtems_rfs_dir_read+0xdc>
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 <rtems_rfs_block_map_next_block>
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 <rtems_rfs_dir_read+0x170> <== 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 <rtems_rfs_dir_read+0x178> <== 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 <rtems_rfs_buffer_handle_request>
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 <rtems_rfs_dir_read+0x174> <== 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 <rtems_rfs_dir_read+0x24c>
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 <rtems_rfs_trace>
40015d54: c2 27 40 00 st %g1, [ %i5 ]
40015d58: 80 a2 20 00 cmp %o0, 0
40015d5c: 22 bf ff db be,a 40015cc8 <rtems_rfs_dir_read+0xb8> <== 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 <rtems_rfs_dir_read+0xb8> <== 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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_block_map_close>
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 <rtems_rfs_dir_read+0x23c> <== 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 <rtems_rfs_block_map_seek> <== 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 <rtems_rfs_dir_read+0x94> <== 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 <rtems_rfs_dir_read+0x204> <== 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 <rtems_rfs_block_map_close> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x700><== NOT EXECUTED
*length = 0;
40015e44: 10 bf ff 7c b 40015c34 <rtems_rfs_dir_read+0x24> <== 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 <rtems_rfs_dir_read+0x70> <== 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 <rtems_rfs_dir_read+0x1ac> <== 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 <rtems_rfs_dir_read+0x38c> <== 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 <rtems_rfs_dir_read+0x38c> <== NEVER TAKEN
40015e94: 80 a6 a0 00 cmp %i2, 0
40015e98: 02 80 00 42 be 40015fa0 <rtems_rfs_dir_read+0x390> <== 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 <rtems_rfs_dir_read+0x394> <== 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 <memset>
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 <rtems_rfs_block_get_pos>
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 <rtems_rfs_dir_read+0x2f8> <== 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 <rtems_rfs_dir_read+0x304> <== 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 <memcpy>
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 <rtems_rfs_trace>
40015f68: 13 20 00 00 sethi %hi(0x80000000), %o1
40015f6c: 80 a2 20 00 cmp %o0, 0
40015f70: 02 bf ff 85 be 40015d84 <rtems_rfs_dir_read+0x174> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x778><== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40015f94: 10 bf ff 7d b 40015d88 <rtems_rfs_dir_read+0x178> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_dir_read+0x178> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x730><== NOT EXECUTED
40015fd4: 10 bf ff 6d b 40015d88 <rtems_rfs_dir_read+0x178> <== NOT EXECUTED
40015fd8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
400167d8 <rtems_rfs_file_close>:
{
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 <rtems_rfs_trace>
400167e4: 92 10 20 00 clr %o1
400167e8: 80 a2 20 00 cmp %o0, 0
400167ec: 32 80 00 79 bne,a 400169d0 <rtems_rfs_file_close+0x1f8> <== 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 <rtems_rfs_file_close+0x3c> <== 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 <rtems_rfs_file_close+0x68> <== 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 <rtems_rfs_buffer_handle_release> <== 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 <free>
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 <rtems_rfs_file_close+0x28c> <== 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 <rtems_rfs_file_close+0x308> <== 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 <rtems_rfs_block_map_close>
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 <rtems_rfs_file_close+0x264> <== 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 <rtems_rfs_inode_close>
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 <rtems_rfs_file_close+0x210> <== 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 <free>
40016964: c4 20 40 00 st %g2, [ %g1 ]
40016968: 92 10 00 1b mov %i3, %o1
4001696c: 7f ff c2 f6 call 40007544 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_file_close+0x54> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_file_close+0x58> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x9d8><== NOT EXECUTED
free (handle);
400169bc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400169c0: 7f ff b1 90 call 40003000 <free> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x938><== NOT EXECUTED
if (handle->shared->references > 0)
400169e0: 10 bf ff 86 b 400167f8 <rtems_rfs_file_close+0x20> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_file_close+0x2d8> <== 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 <rtems_rfs_file_close+0x184> <== 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 <free> <== 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 <rtems_rfs_buffer_handle_release> <== 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 <rtems_rfs_file_close+0x1b0> <== 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 <rtems_rfs_trace> <== 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 <rtems_rfs_file_close+0x2a8> <== 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 <rtems_rfs_file_close+0x15c> <== 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 <rtems_rfs_file_close+0x160> <== 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 <rtems_rfs_inode_load>
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 <rtems_rfs_file_close+0x320> <== 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 <rtems_rfs_file_close+0x144> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x960><== NOT EXECUTED
if (rrc == 0)
40016aa8: 10 bf ff eb b 40016a54 <rtems_rfs_file_close+0x27c> <== 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 <strerror> <== 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 <IMFS_LIMITS_AND_OPTIONS+0x998><== NOT EXECUTED
rtems_chain_extract_unprotected (&handle->shared->link);
40016ad8: 10 bf ff ca b 40016a00 <rtems_rfs_file_close+0x228> <== 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 <rtems_rfs_file_close+0x138> <== NEVER TAKEN
40016aec: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED
40016af0: 10 bf ff 8c b 40016920 <rtems_rfs_file_close+0x148>
40016af4: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_write_u32 (&handle->node->atime, atime);
40016af8: 10 bf ff 56 b 40016850 <rtems_rfs_file_close+0x78>
40016afc: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
400174b8 <rtems_rfs_file_get_shared>:
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 <rtems_rfs_file_get_shared+0x2c>
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 <rtems_rfs_file_get_shared+0x40>
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 <rtems_rfs_file_get_shared+0x40> <== 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 <rtems_rfs_file_get_shared+0x1c> <== 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 <rtems_rfs_file_io_end>:
{
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 <rtems_rfs_trace>
40016d84: b8 10 00 18 mov %i0, %i4
40016d88: 80 a2 20 00 cmp %o0, 0
40016d8c: 22 80 00 0c be,a 40016dbc <rtems_rfs_file_io_end+0x48> <== 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 <rtems_rfs_file_io_end+0x1dc> <== 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 <IMFS_LIMITS_AND_OPTIONS+0xa00><== 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 <rtems_rfs_file_io_end+0x21c> <== 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 <rtems_rfs_file_io_end+0x19c>
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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_file_io_end+0x284> <== 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 <rtems_rfs_file_io_end+0xc0>
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 <rtems_rfs_file_io_end+0xf0>
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 <rtems_rfs_file_io_end+0x1e4>
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 <rtems_rfs_file_io_end+0x1e8> <== 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 <rtems_rfs_trace>
40016e98: a0 1e 60 01 xor %i1, 1, %l0
40016e9c: 80 a2 20 00 cmp %o0, 0
40016ea0: 02 80 00 0f be 40016edc <rtems_rfs_file_io_end+0x168> <== 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 <rtems_rfs_file_io_end+0x244> <== 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 <rtems_rfs_file_io_end+0x2e4>
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 <rtems_rfs_buffer_handle_release>
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 <rtems_rfs_file_io_end+0x2b8> <== 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 <rtems_rfs_file_io_end+0xa0>
40016f44: 88 10 20 00 clr %g4
length = false;
40016f48: 10 bf ff c7 b 40016e64 <rtems_rfs_file_io_end+0xf0>
40016f4c: 84 10 20 00 clr %g2
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
40016f50: 10 bf ff 96 b 40016da8 <rtems_rfs_file_io_end+0x34> <== 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 <rtems_rfs_file_io_end+0xe0>
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 <rtems_rfs_file_io_end+0xf0>
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 <rtems_rfs_file_io_end+0xf4>
40016f84: c2 07 00 00 ld [ %i4 ], %g1
40016f88: 10 bf ff b4 b 40016e58 <rtems_rfs_file_io_end+0xe4>
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 <rtems_rfs_file_io_end+0xb4> <== NOT EXECUTED
40016fac: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->bpos.bno++;
40016fb0: 10 bf ff 9a b 40016e18 <rtems_rfs_file_io_end+0xa4> <== 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 <time>
40016fbc: 90 10 20 00 clr %o0
if (read && atime)
40016fc0: 80 a4 20 00 cmp %l0, 0
40016fc4: 02 80 00 07 be 40016fe0 <rtems_rfs_file_io_end+0x26c> <== NEVER TAKEN
40016fc8: 80 a6 a0 00 cmp %i2, 0
40016fcc: 02 80 00 06 be 40016fe4 <rtems_rfs_file_io_end+0x270>
40016fd0: 80 a6 e0 00 cmp %i3, 0
handle->shared->atime = now;
40016fd4: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40016fd8: 10 bf ff c4 b 40016ee8 <rtems_rfs_file_io_end+0x174>
40016fdc: d2 20 60 8c st %o1, [ %g1 + 0x8c ]
if (!read && mtime)
40016fe0: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
40016fe4: 02 bf ff c2 be 40016eec <rtems_rfs_file_io_end+0x178> <== NEVER TAKEN
40016fe8: 80 a7 60 00 cmp %i5, 0
handle->shared->mtime = now;
40016fec: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40016ff0: 10 bf ff bf b 40016eec <rtems_rfs_file_io_end+0x178>
40016ff4: d2 20 60 90 st %o1, [ %g1 + 0x90 ]
printf (
40016ff8: 92 12 63 40 or %o1, 0x340, %o1 <== NOT EXECUTED
40016ffc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40017000: 40 00 21 83 call 4001f60c <strerror> <== NOT EXECUTED
40017004: d2 27 bf fc st %o1, [ %fp + -4 ] <== NOT EXECUTED
40017008: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
4001700c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
40017010: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
40017014: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40017018: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
4001701c: 7f ff af 37 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017020: 90 12 20 28 or %o0, 0x28, %o0 ! 40024028 <IMFS_LIMITS_AND_OPTIONS+0xae8><== NOT EXECUTED
return rc;
40017024: 81 c7 e0 08 ret <== NOT EXECUTED
40017028: 81 e8 00 00 restore <== NOT EXECUTED
printf (
4001702c: 92 12 62 a8 or %o1, 0x2a8, %o1 <== NOT EXECUTED
40017030: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40017034: 40 00 21 76 call 4001f60c <strerror> <== NOT EXECUTED
40017038: d2 27 bf fc st %o1, [ %fp + -4 ] <== NOT EXECUTED
4001703c: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
40017040: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
40017044: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
40017048: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001704c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017050: 7f ff af 2a call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017054: 90 12 20 28 or %o0, 0x28, %o0 ! 40024028 <IMFS_LIMITS_AND_OPTIONS+0xae8><== NOT EXECUTED
return rc;
40017058: 81 c7 e0 08 ret
4001705c: 81 e8 00 00 restore
40016b00 <rtems_rfs_file_io_start>:
{
40016b00: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016b04: 90 10 20 20 mov 0x20, %o0
40016b08: 92 10 20 00 clr %o1
40016b0c: 7f ff d0 2e call 4000abc4 <rtems_rfs_trace>
40016b10: ba 10 00 18 mov %i0, %i5
40016b14: 80 a2 20 00 cmp %o0, 0
40016b18: 22 80 00 0d be,a 40016b4c <rtems_rfs_file_io_start+0x4c> <== ALWAYS TAKEN
40016b1c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
40016b20: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40016b24: 32 80 00 2d bne,a 40016bd8 <rtems_rfs_file_io_start+0xd8> <== NOT EXECUTED
40016b28: 13 10 00 87 sethi %hi(0x40021c00), %o1 <== NOT EXECUTED
40016b2c: 13 10 00 8f sethi %hi(0x40023c00), %o1 <== NOT EXECUTED
40016b30: 92 12 63 40 or %o1, 0x340, %o1 ! 40023f40 <IMFS_LIMITS_AND_OPTIONS+0xa00><== NOT EXECUTED
40016b34: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
40016b38: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
40016b3c: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
40016b40: 7f ff b0 6e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40016b44: 90 12 23 48 or %o0, 0x348, %o0 ! 40023f48 <IMFS_LIMITS_AND_OPTIONS+0xa08><== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
40016b48: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
40016b4c: 80 a0 60 00 cmp %g1, 0
40016b50: 02 80 00 29 be 40016bf4 <rtems_rfs_file_io_start+0xf4>
40016b54: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
if (read
40016b58: 80 a6 a0 00 cmp %i2, 0
40016b5c: 22 80 00 0c be,a 40016b8c <rtems_rfs_file_io_start+0x8c>
40016b60: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
40016b64: c4 02 60 44 ld [ %o1 + 0x44 ], %g2
40016b68: c2 02 60 3c ld [ %o1 + 0x3c ], %g1
40016b6c: 80 90 80 01 orcc %g2, %g1, %g0
40016b70: 12 80 00 1c bne 40016be0 <rtems_rfs_file_io_start+0xe0> <== ALWAYS TAKEN
40016b74: 82 00 7f ff add %g1, -1, %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
40016b78: f8 02 60 40 ld [ %o1 + 0x40 ], %i4 <== NOT EXECUTED
40016b7c: 80 a7 20 00 cmp %i4, 0
40016b80: 32 80 00 05 bne,a 40016b94 <rtems_rfs_file_io_start+0x94>
40016b84: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40016b88: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
40016b8c: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
40016b90: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40016b94: 82 27 00 01 sub %i4, %g1, %g1
40016b98: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016b9c: 90 10 20 20 mov 0x20, %o0
40016ba0: 92 10 20 00 clr %o1
40016ba4: 7f ff d0 08 call 4000abc4 <rtems_rfs_trace>
40016ba8: b0 10 20 00 clr %i0
40016bac: 80 a2 20 00 cmp %o0, 0
40016bb0: 32 80 00 04 bne,a 40016bc0 <rtems_rfs_file_io_start+0xc0> <== NEVER TAKEN
40016bb4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
}
40016bb8: 81 c7 e0 08 ret
40016bbc: 81 e8 00 00 restore
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
40016bc0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40016bc4: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
40016bc8: 7f ff b0 4c call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40016bcc: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 40023fd0 <IMFS_LIMITS_AND_OPTIONS+0xa90><== NOT EXECUTED
}
40016bd0: 81 c7 e0 08 ret <== NOT EXECUTED
40016bd4: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
40016bd8: 10 bf ff d7 b 40016b34 <rtems_rfs_file_io_start+0x34> <== NOT EXECUTED
40016bdc: 92 12 62 a8 or %o1, 0x2a8, %o1 <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
40016be0: 80 a0 80 01 cmp %g2, %g1
40016be4: 32 bf ff ea bne,a 40016b8c <rtems_rfs_file_io_start+0x8c>
40016be8: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
40016bec: 10 bf ff e4 b 40016b7c <rtems_rfs_file_io_start+0x7c>
40016bf0: f8 02 60 40 ld [ %o1 + 0x40 ], %i4
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40016bf4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
40016bf8: 94 07 60 10 add %i5, 0x10, %o2
40016bfc: 96 07 bf fc add %fp, -4, %o3
40016c00: 7f ff f6 19 call 40014464 <rtems_rfs_block_map_find>
40016c04: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
40016c08: b0 92 20 00 orcc %o0, 0, %i0
40016c0c: 04 80 00 22 ble 40016c94 <rtems_rfs_file_io_start+0x194>
40016c10: 82 1e 20 06 xor %i0, 6, %g1
if (read && (rc == ENXIO))
40016c14: 80 a0 00 01 cmp %g0, %g1
40016c18: 82 60 3f ff subx %g0, -1, %g1
40016c1c: 82 0e 80 01 and %i2, %g1, %g1
40016c20: 80 a0 60 00 cmp %g1, 0
40016c24: 12 80 00 4b bne 40016d50 <rtems_rfs_file_io_start+0x250> <== NEVER TAKEN
40016c28: b8 10 00 01 mov %g1, %i4
if (rc != ENXIO)
40016c2c: 80 a6 20 06 cmp %i0, 6
40016c30: 12 bf ff e2 bne 40016bb8 <rtems_rfs_file_io_start+0xb8> <== NEVER TAKEN
40016c34: 90 10 20 20 mov 0x20, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016c38: 7f ff cf e3 call 4000abc4 <rtems_rfs_trace>
40016c3c: 92 10 20 00 clr %o1
40016c40: 80 a2 20 00 cmp %o0, 0
40016c44: 12 80 00 48 bne 40016d64 <rtems_rfs_file_io_start+0x264> <== NEVER TAKEN
40016c48: 11 10 00 8f sethi %hi(0x40023c00), %o0
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
40016c4c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
40016c50: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
40016c54: 96 07 bf fc add %fp, -4, %o3
40016c58: 94 10 20 01 mov 1, %o2
40016c5c: 7f ff f6 86 call 40014674 <rtems_rfs_block_map_grow>
40016c60: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
40016c64: b0 92 20 00 orcc %o0, 0, %i0
40016c68: 14 bf ff d4 bg 40016bb8 <rtems_rfs_file_io_start+0xb8>
40016c6c: 90 10 20 20 mov 0x20, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016c70: 7f ff cf d5 call 4000abc4 <rtems_rfs_trace>
40016c74: 92 10 20 00 clr %o1
40016c78: 80 a2 20 00 cmp %o0, 0
40016c7c: 22 80 00 16 be,a 40016cd4 <rtems_rfs_file_io_start+0x1d4> <== ALWAYS TAKEN
40016c80: b8 10 20 00 clr %i4
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
40016c84: 15 10 00 8b sethi %hi(0x40022c00), %o2 <== NOT EXECUTED
40016c88: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
40016c8c: 10 80 00 0f b 40016cc8 <rtems_rfs_file_io_start+0x1c8> <== NOT EXECUTED
40016c90: 94 12 a1 00 or %o2, 0x100, %o2 <== NOT EXECUTED
if (!read &&
40016c94: 80 a6 a0 00 cmp %i2, 0
40016c98: 22 80 00 1a be,a 40016d00 <rtems_rfs_file_io_start+0x200>
40016c9c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016ca0: 90 10 20 20 mov 0x20, %o0
40016ca4: 92 10 20 00 clr %o1
40016ca8: 7f ff cf c7 call 4000abc4 <rtems_rfs_trace>
40016cac: 01 00 00 00 nop
40016cb0: 80 a2 20 00 cmp %o0, 0
40016cb4: 02 80 00 2a be 40016d5c <rtems_rfs_file_io_start+0x25c> <== ALWAYS TAKEN
40016cb8: b8 10 00 08 mov %o0, %i4
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
40016cbc: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
40016cc0: 15 10 00 8b sethi %hi(0x40022c00), %o2 <== NOT EXECUTED
40016cc4: 94 12 a0 f8 or %o2, 0xf8, %o2 ! 40022cf8 <IMFS_node_control_sym_link+0xf70><== NOT EXECUTED
40016cc8: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
40016ccc: 7f ff b0 0b call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40016cd0: 90 12 23 98 or %o0, 0x398, %o0 ! 40023f98 <IMFS_LIMITS_AND_OPTIONS+0xa58><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
40016cd4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40016cd8: d4 07 bf fc ld [ %fp + -4 ], %o2
40016cdc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
40016ce0: 96 0f 20 ff and %i4, 0xff, %o3
40016ce4: 7f ff c1 4f call 40007220 <rtems_rfs_buffer_handle_request>
40016ce8: 92 07 60 04 add %i5, 4, %o1
if (rc > 0)
40016cec: b0 92 20 00 orcc %o0, 0, %i0
40016cf0: 14 bf ff b8 bg 40016bd0 <rtems_rfs_file_io_start+0xd0> <== NEVER TAKEN
40016cf4: 01 00 00 00 nop
40016cf8: 10 bf ff 98 b 40016b58 <rtems_rfs_file_io_start+0x58>
40016cfc: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016d00: 90 10 20 20 mov 0x20, %o0
if (!read &&
40016d04: 80 a0 60 00 cmp %g1, 0
40016d08: 12 bf ff e8 bne 40016ca8 <rtems_rfs_file_io_start+0x1a8>
40016d0c: 92 10 20 00 clr %o1
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
40016d10: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40016d14: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
(rtems_rfs_file_block_offset (handle) ||
40016d18: c4 06 40 00 ld [ %i1 ], %g2
40016d1c: c2 00 60 08 ld [ %g1 + 8 ], %g1
40016d20: 80 a0 80 01 cmp %g2, %g1
40016d24: 0a bf ff e1 bcs 40016ca8 <rtems_rfs_file_io_start+0x1a8> <== ALWAYS TAKEN
40016d28: 01 00 00 00 nop
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40016d2c: 7f ff cf a6 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40016d30: 01 00 00 00 nop <== NOT EXECUTED
40016d34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40016d38: 02 bf ff e7 be 40016cd4 <rtems_rfs_file_io_start+0x1d4> <== NOT EXECUTED
40016d3c: b8 10 20 00 clr %i4 <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
40016d40: 15 10 00 8b sethi %hi(0x40022c00), %o2 <== NOT EXECUTED
40016d44: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
40016d48: 10 bf ff e0 b 40016cc8 <rtems_rfs_file_io_start+0x1c8> <== NOT EXECUTED
40016d4c: 94 12 a1 00 or %o2, 0x100, %o2 <== NOT EXECUTED
*available = 0;
40016d50: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
40016d54: 81 c7 e0 08 ret <== NOT EXECUTED
40016d58: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
request_read = true;
40016d5c: 10 bf ff de b 40016cd4 <rtems_rfs_file_io_start+0x1d4>
40016d60: b8 10 20 01 mov 1, %i4
printf ("rtems-rfs: file-io: start: grow\n");
40016d64: 7f ff af f3 call 40002d30 <__wrap_puts> <== NOT EXECUTED
40016d68: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
40016d6c: 10 bf ff b9 b 40016c50 <rtems_rfs_file_io_start+0x150> <== NOT EXECUTED
40016d70: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
400164b4 <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
int oflag,
rtems_rfs_file_handle** file)
{
400164b4: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
400164b8: 90 10 20 08 mov 8, %o0
400164bc: 92 10 20 00 clr %o1
400164c0: 7f ff d1 c1 call 4000abc4 <rtems_rfs_trace>
400164c4: a0 10 00 18 mov %i0, %l0
400164c8: 80 a2 20 00 cmp %o0, 0
400164cc: 12 80 00 2d bne 40016580 <rtems_rfs_file_open+0xcc> <== NEVER TAKEN
400164d0: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
400164d4: c0 26 c0 00 clr [ %i3 ]
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
400164d8: 92 10 20 01 mov 1, %o1
400164dc: 7f ff f1 bd call 40012bd0 <calloc>
400164e0: 90 10 20 20 mov 0x20, %o0
if (!handle)
400164e4: a4 92 20 00 orcc %o0, 0, %l2
400164e8: 02 80 00 b2 be 400167b0 <rtems_rfs_file_open+0x2fc> <== NEVER TAKEN
400164ec: b8 04 20 78 add %l0, 0x78, %i4
return _Chain_Immutable_head( the_chain )->next;
400164f0: fa 04 20 74 ld [ %l0 + 0x74 ], %i5
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
400164f4: 80 a7 40 1c cmp %i5, %i4
400164f8: 32 80 00 08 bne,a 40016518 <rtems_rfs_file_open+0x64> <== NEVER TAKEN
400164fc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
40016500: 10 80 00 25 b 40016594 <rtems_rfs_file_open+0xe0>
40016504: 92 10 20 01 mov 1, %o1
while (!rtems_chain_is_tail (&fs->file_shares, node))
40016508: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4001650c: 02 80 00 22 be 40016594 <rtems_rfs_file_open+0xe0> <== NOT EXECUTED
40016510: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
40016514: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
40016518: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4001651c: 32 bf ff fb bne,a 40016508 <rtems_rfs_file_open+0x54> <== NOT EXECUTED
40016520: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
shared->references++;
40016524: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40016528: 82 00 60 01 inc %g1 <== NOT EXECUTED
4001652c: c2 27 60 08 st %g1, [ %i5 + 8 ] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40016530: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
40016534: 7f ff d1 a4 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40016538: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001653c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40016540: 32 80 00 07 bne,a 4001655c <rtems_rfs_file_open+0xa8> <== NOT EXECUTED
40016544: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
handle->flags = oflag;
40016548: f4 24 80 00 st %i2, [ %l2 ] <== NOT EXECUTED
handle->shared = shared;
4001654c: fa 24 a0 1c st %i5, [ %l2 + 0x1c ]
*file = handle;
40016550: e4 26 c0 00 st %l2, [ %i3 ]
return 0;
40016554: 81 c7 e0 08 ret
40016558: 91 e8 20 00 restore %g0, 0, %o0
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001655c: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
return 0;
40016560: b0 10 20 00 clr %i0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
40016564: 7f ff b1 e5 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40016568: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED
handle->flags = oflag;
4001656c: f4 24 80 00 st %i2, [ %l2 ] <== NOT EXECUTED
handle->shared = shared;
40016570: fa 24 a0 1c st %i5, [ %l2 + 0x1c ] <== NOT EXECUTED
*file = handle;
40016574: e4 26 c0 00 st %l2, [ %i3 ] <== NOT EXECUTED
return 0;
40016578: 81 c7 e0 08 ret <== NOT EXECUTED
4001657c: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
40016580: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
40016584: 7f ff b1 dd call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40016588: 90 12 21 90 or %o0, 0x190, %o0 ! 40023d90 <IMFS_LIMITS_AND_OPTIONS+0x850><== NOT EXECUTED
*file = NULL;
4001658c: 10 bf ff d3 b 400164d8 <rtems_rfs_file_open+0x24> <== NOT EXECUTED
40016590: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
40016594: 90 10 20 9c mov 0x9c, %o0
40016598: 7f ff f1 8e call 40012bd0 <calloc>
4001659c: a6 04 a0 04 add %l2, 4, %l3
if (!shared)
400165a0: ba 92 20 00 orcc %o0, 0, %i5
400165a4: 02 80 00 85 be 400167b8 <rtems_rfs_file_open+0x304> <== NEVER TAKEN
400165a8: a2 07 60 0c add %i5, 0xc, %l1
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
400165ac: 96 10 20 01 mov 1, %o3
400165b0: 94 10 00 11 mov %l1, %o2
400165b4: 92 10 00 19 mov %i1, %o1
400165b8: 7f ff ca d6 call 40009110 <rtems_rfs_inode_open>
400165bc: 90 10 00 10 mov %l0, %o0
if (rc > 0)
400165c0: b0 92 20 00 orcc %o0, 0, %i0
400165c4: 14 80 00 51 bg 40016708 <rtems_rfs_file_open+0x254> <== NEVER TAKEN
400165c8: 94 07 60 34 add %i5, 0x34, %o2
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
400165cc: 92 10 00 11 mov %l1, %o1
400165d0: 7f ff f6 d7 call 4001412c <rtems_rfs_block_map_open>
400165d4: 90 10 00 10 mov %l0, %o0
if (rc > 0)
400165d8: b0 92 20 00 orcc %o0, 0, %i0
400165dc: 14 80 00 5a bg 40016744 <rtems_rfs_file_open+0x290> <== NEVER TAKEN
400165e0: 82 10 20 01 mov 1, %g1
shared->references = 1;
400165e4: c2 27 60 08 st %g1, [ %i5 + 8 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
400165e8: 94 10 20 00 clr %o2
400165ec: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
return rtems_rfs_read_u32 (&handle->node->block_count);
400165f0: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
400165f4: f0 08 60 0c ldub [ %g1 + 0xc ], %i0
400165f8: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
400165fc: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
40016600: b1 2e 20 18 sll %i0, 0x18, %i0
40016604: 87 28 e0 10 sll %g3, 0x10, %g3
40016608: 85 28 a0 08 sll %g2, 8, %g2
4001660c: 86 10 c0 18 or %g3, %i0, %g3
40016610: 84 10 80 03 or %g2, %g3, %g2
40016614: 84 11 00 02 or %g4, %g2, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
40016618: c4 27 60 84 st %g2, [ %i5 + 0x84 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001661c: 92 10 00 11 mov %l1, %o1
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
40016620: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
40016624: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
40016628: 87 28 e0 08 sll %g3, 8, %g3
4001662c: 84 10 80 03 or %g2, %g3, %g2
40016630: c4 27 60 88 st %g2, [ %i5 + 0x88 ]
return rtems_rfs_read_u32 (&handle->node->atime);
40016634: c8 08 60 13 ldub [ %g1 + 0x13 ], %g4
40016638: f0 08 60 10 ldub [ %g1 + 0x10 ], %i0
4001663c: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
40016640: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
40016644: b1 2e 20 18 sll %i0, 0x18, %i0
40016648: 87 28 e0 10 sll %g3, 0x10, %g3
4001664c: 85 28 a0 08 sll %g2, 8, %g2
40016650: 86 10 c0 18 or %g3, %i0, %g3
40016654: 84 10 80 03 or %g2, %g3, %g2
40016658: 84 11 00 02 or %g4, %g2, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001665c: c4 27 60 8c st %g2, [ %i5 + 0x8c ]
return rtems_rfs_read_u32 (&handle->node->mtime);
40016660: c8 08 60 17 ldub [ %g1 + 0x17 ], %g4
40016664: f0 08 60 14 ldub [ %g1 + 0x14 ], %i0
40016668: c6 08 60 15 ldub [ %g1 + 0x15 ], %g3
4001666c: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
40016670: b1 2e 20 18 sll %i0, 0x18, %i0
40016674: 87 28 e0 10 sll %g3, 0x10, %g3
40016678: 85 28 a0 08 sll %g2, 8, %g2
4001667c: 86 10 c0 18 or %g3, %i0, %g3
40016680: 84 10 80 03 or %g2, %g3, %g2
40016684: 84 11 00 02 or %g4, %g2, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
40016688: c4 27 60 90 st %g2, [ %i5 + 0x90 ]
return rtems_rfs_read_u32 (&handle->node->ctime);
4001668c: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
40016690: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
40016694: c8 08 60 1b ldub [ %g1 + 0x1b ], %g4
40016698: f0 08 60 18 ldub [ %g1 + 0x18 ], %i0
4001669c: 83 28 e0 10 sll %g3, 0x10, %g1
old_last = tail->previous;
400166a0: de 04 20 7c ld [ %l0 + 0x7c ], %o7
shared->fs = fs;
400166a4: e0 27 60 98 st %l0, [ %i5 + 0x98 ]
400166a8: b1 2e 20 18 sll %i0, 0x18, %i0
the_node->next = tail;
400166ac: f8 27 40 00 st %i4, [ %i5 ]
400166b0: 86 10 40 18 or %g1, %i0, %g3
tail->previous = the_node;
400166b4: fa 24 20 7c st %i5, [ %l0 + 0x7c ]
400166b8: 83 28 a0 08 sll %g2, 8, %g1
400166bc: 82 10 40 03 or %g1, %g3, %g1
400166c0: 82 11 00 01 or %g4, %g1, %g1
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
400166c4: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
old_last->next = the_node;
400166c8: fa 23 c0 00 st %i5, [ %o7 ]
the_node->previous = old_last;
400166cc: de 27 60 04 st %o7, [ %i5 + 4 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
400166d0: 7f ff ca cb call 400091fc <rtems_rfs_inode_unload>
400166d4: 90 10 00 10 mov %l0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
400166d8: 90 10 20 08 mov 8, %o0
400166dc: 7f ff d1 3a call 4000abc4 <rtems_rfs_trace>
400166e0: 92 10 20 00 clr %o1
400166e4: 80 a2 20 00 cmp %o0, 0
400166e8: 22 bf ff 99 be,a 4001654c <rtems_rfs_file_open+0x98> <== ALWAYS TAKEN
400166ec: f4 24 80 00 st %i2, [ %l2 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
400166f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400166f4: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
400166f8: 7f ff b1 80 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400166fc: 90 12 22 48 or %o0, 0x248, %o0 ! 40023e48 <IMFS_LIMITS_AND_OPTIONS+0x908><== NOT EXECUTED
handle->flags = oflag;
40016700: 10 bf ff 93 b 4001654c <rtems_rfs_file_open+0x98> <== NOT EXECUTED
40016704: f4 24 80 00 st %i2, [ %l2 ] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40016708: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
4001670c: 7f ff d1 2e call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40016710: 92 10 20 00 clr %o1 <== NOT EXECUTED
40016714: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40016718: 12 80 00 1e bne 40016790 <rtems_rfs_file_open+0x2dc> <== NOT EXECUTED
4001671c: 01 00 00 00 nop <== NOT EXECUTED
free (shared);
40016720: 7f ff b2 38 call 40003000 <free> <== NOT EXECUTED
40016724: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40016728: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001672c: 7f ff c3 86 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40016730: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
free (handle);
40016734: 7f ff b2 33 call 40003000 <free> <== NOT EXECUTED
40016738: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
return rc;
4001673c: 81 c7 e0 08 ret <== NOT EXECUTED
40016740: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40016744: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
40016748: 7f ff d1 1f call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
4001674c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40016750: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40016754: 12 80 00 06 bne 4001676c <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
40016758: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
4001675c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
40016760: 7f ff ca e5 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40016764: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40016768: 30 bf ff ee b,a 40016720 <rtems_rfs_file_open+0x26c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001676c: 40 00 23 a8 call 4001f60c <strerror> <== NOT EXECUTED
40016770: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40016774: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40016778: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001677c: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
40016780: 7f ff b1 5e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40016784: 90 12 22 10 or %o0, 0x210, %o0 ! 40023e10 <IMFS_LIMITS_AND_OPTIONS+0x8d0><== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
40016788: 10 bf ff f6 b 40016760 <rtems_rfs_file_open+0x2ac> <== NOT EXECUTED
4001678c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
40016790: 40 00 23 9f call 4001f60c <strerror> <== NOT EXECUTED
40016794: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40016798: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001679c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400167a0: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED
400167a4: 7f ff b1 55 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400167a8: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 40023dd8 <IMFS_LIMITS_AND_OPTIONS+0x898><== NOT EXECUTED
free (shared);
400167ac: 30 bf ff dd b,a 40016720 <rtems_rfs_file_open+0x26c> <== NOT EXECUTED
}
400167b0: 81 c7 e0 08 ret <== NOT EXECUTED
400167b4: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED
400167b8: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
400167bc: 7f ff c3 62 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
400167c0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return ENOMEM;
400167c4: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
free (handle);
400167c8: 7f ff b2 0e call 40003000 <free> <== NOT EXECUTED
400167cc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
return ENOMEM;
400167d0: 81 c7 e0 08 ret <== NOT EXECUTED
400167d4: 81 e8 00 00 restore <== NOT EXECUTED
40017060 <rtems_rfs_file_seek>:
{
40017060: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40017064: 90 10 20 20 mov 0x20, %o0
40017068: 92 10 20 00 clr %o1
4001706c: 7f ff ce d6 call 4000abc4 <rtems_rfs_trace>
40017070: ba 10 00 18 mov %i0, %i5
40017074: 80 a2 20 00 cmp %o0, 0
40017078: 32 80 00 3c bne,a 40017168 <rtems_rfs_file_seek+0x108> <== NEVER TAKEN
4001707c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
40017080: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
40017084: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
40017088: 7f ff f4 16 call 400140e0 <rtems_rfs_block_get_size>
4001708c: 92 02 60 84 add %o1, 0x84, %o1
40017090: 80 a6 40 08 cmp %i1, %o0
40017094: 08 80 00 11 bleu 400170d8 <rtems_rfs_file_seek+0x78> <== ALWAYS TAKEN
40017098: 01 00 00 00 nop
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001709c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
400170a0: 80 a0 60 00 cmp %g1, 0
400170a4: 22 80 00 0a be,a 400170cc <rtems_rfs_file_seek+0x6c> <== ALWAYS TAKEN
400170a8: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
400170ac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
400170b0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
400170b4: 7f ff c1 24 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
400170b8: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
if (rc > 0)
400170bc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
400170c0: 14 80 00 28 bg 40017160 <rtems_rfs_file_seek+0x100> <== NOT EXECUTED
400170c4: 01 00 00 00 nop <== NOT EXECUTED
*new_pos = pos;
400170c8: f2 26 c0 00 st %i1, [ %i3 ]
400170cc: f4 26 e0 04 st %i2, [ %i3 + 4 ]
}
400170d0: 81 c7 e0 08 ret
400170d4: 91 e8 20 00 restore %g0, 0, %o0
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
400170d8: 12 80 00 04 bne 400170e8 <rtems_rfs_file_seek+0x88> <== NEVER TAKEN
400170dc: 80 a6 80 09 cmp %i2, %o1
400170e0: 38 bf ff f0 bgu,a 400170a0 <rtems_rfs_file_seek+0x40>
400170e4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
rtems_rfs_file_set_bpos (handle, pos);
400170e8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400170ec: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
400170f0: b8 07 60 10 add %i5, 0x10, %i4
400170f4: 92 10 00 19 mov %i1, %o1
400170f8: 96 10 00 1c mov %i4, %o3
400170fc: 7f ff f3 e2 call 40014084 <rtems_rfs_block_get_bpos>
40017100: 94 10 00 1a mov %i2, %o2
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
40017104: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40017108: 80 a0 60 00 cmp %g1, 0
4001710c: 02 bf ff ef be 400170c8 <rtems_rfs_file_seek+0x68>
40017110: 96 07 bf fc add %fp, -4, %o3
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40017114: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
40017118: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001711c: 94 10 00 1c mov %i4, %o2
40017120: 7f ff f4 d1 call 40014464 <rtems_rfs_block_map_find>
40017124: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
40017128: b0 92 20 00 orcc %o0, 0, %i0
4001712c: 14 80 00 0d bg 40017160 <rtems_rfs_file_seek+0x100> <== NEVER TAKEN
40017130: c2 07 bf fc ld [ %fp + -4 ], %g1
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
40017134: c4 07 60 08 ld [ %i5 + 8 ], %g2
40017138: 80 a0 80 01 cmp %g2, %g1
4001713c: 22 bf ff e4 be,a 400170cc <rtems_rfs_file_seek+0x6c> <== ALWAYS TAKEN
40017140: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40017144: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
40017148: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001714c: 7f ff c0 fe call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40017150: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
if (rc > 0)
40017154: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40017158: 24 bf ff dd ble,a 400170cc <rtems_rfs_file_seek+0x6c> <== NOT EXECUTED
4001715c: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED
40017160: 81 c7 e0 08 ret <== NOT EXECUTED
40017164: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
40017168: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001716c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017170: 7f ff ae e2 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017174: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400240a0 <IMFS_LIMITS_AND_OPTIONS+0xb60><== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
40017178: 10 bf ff c3 b 40017084 <rtems_rfs_file_seek+0x24> <== NOT EXECUTED
4001717c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
40017180 <rtems_rfs_file_set_size>:
{
40017180: 9d e3 bf 90 save %sp, -112, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40017184: 90 10 20 20 mov 0x20, %o0
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
40017188: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001718c: 92 10 20 00 clr %o1
40017190: 7f ff ce 8d call 4000abc4 <rtems_rfs_trace>
40017194: ba 10 00 18 mov %i0, %i5
{
40017198: a0 10 00 19 mov %i1, %l0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001719c: 80 a2 20 00 cmp %o0, 0
400171a0: 12 80 00 58 bne 40017300 <rtems_rfs_file_set_size+0x180> <== NEVER TAKEN
400171a4: a2 10 00 1a mov %i2, %l1
size = rtems_rfs_file_size (handle);
400171a8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
400171ac: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
400171b0: 7f ff f3 cc call 400140e0 <rtems_rfs_block_get_size>
400171b4: 92 02 60 84 add %o1, 0x84, %o1
400171b8: 84 10 00 08 mov %o0, %g2
if (size != new_size)
400171bc: 80 a4 00 02 cmp %l0, %g2
400171c0: 02 80 00 43 be 400172cc <rtems_rfs_file_set_size+0x14c> <== ALWAYS TAKEN
400171c4: 86 10 00 09 mov %o1, %g3
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
400171c8: f6 07 60 1c ld [ %i5 + 0x1c ], %i3 <== NOT EXECUTED
400171cc: e8 06 e0 98 ld [ %i3 + 0x98 ], %l4
if (new_size == 0)
400171d0: 80 94 00 11 orcc %l0, %l1, %g0
400171d4: 02 80 00 32 be 4001729c <rtems_rfs_file_set_size+0x11c>
400171d8: a4 07 20 34 add %i4, 0x34, %l2
rtems_rfs_block_map_count (map) -
400171dc: f0 07 20 3c ld [ %i4 + 0x3c ], %i0
if (size < new_size)
400171e0: 80 a4 00 02 cmp %l0, %g2
400171e4: 18 80 00 50 bgu 40017324 <rtems_rfs_file_set_size+0x1a4> <== NEVER TAKEN
400171e8: f2 05 20 08 ld [ %l4 + 8 ], %i1
400171ec: 02 80 00 4c be 4001731c <rtems_rfs_file_set_size+0x19c> <== ALWAYS TAKEN
400171f0: 80 a4 40 03 cmp %l1, %g3
(((new_size - 1) /
400171f4: 92 84 7f ff addcc %l1, -1, %o1 <== NOT EXECUTED
400171f8: 96 10 00 19 mov %i1, %o3
400171fc: 90 44 3f ff addx %l0, -1, %o0
40017200: 40 00 1a fa call 4001dde8 <__udivdi3>
40017204: 94 10 20 00 clr %o2
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40017208: 96 10 00 19 mov %i1, %o3
blocks =
4001720c: b4 06 3f ff add %i0, -1, %i2
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40017210: 94 10 20 00 clr %o2
blocks =
40017214: b4 26 80 09 sub %i2, %o1, %i2
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40017218: 90 10 00 10 mov %l0, %o0
4001721c: 40 00 1b 67 call 4001dfb8 <__umoddi3>
40017220: 92 10 00 11 mov %l1, %o1
if (blocks)
40017224: 80 a6 a0 00 cmp %i2, 0
40017228: 12 80 00 8c bne 40017458 <rtems_rfs_file_set_size+0x2d8>
4001722c: b2 10 00 09 mov %o1, %i1
40017230: 82 10 20 01 mov 1, %g1
map->size.offset = offset;
40017234: f2 27 20 40 st %i1, [ %i4 + 0x40 ]
map->dirty = true;
40017238: c2 2f 20 34 stb %g1, [ %i4 + 0x34 ]
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001723c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40017240: 80 a0 60 00 cmp %g1, 0
40017244: 02 80 00 8f be 40017480 <rtems_rfs_file_set_size+0x300>
40017248: 80 a0 40 18 cmp %g1, %i0
4001724c: 80 a6 20 00 cmp %i0, 0
40017250: 12 80 00 8c bne 40017480 <rtems_rfs_file_set_size+0x300> <== ALWAYS TAKEN
40017254: 80 a0 40 18 cmp %g1, %i0
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
40017258: f0 27 60 10 st %i0, [ %i5 + 0x10 ] <== NOT EXECUTED
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001725c: 84 10 00 1b mov %i3, %g2 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
40017260: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
40017264: 80 a6 60 00 cmp %i1, 0
40017268: 02 80 00 04 be 40017278 <rtems_rfs_file_set_size+0xf8> <== NEVER TAKEN
4001726c: c0 27 60 18 clr [ %i5 + 0x18 ]
40017270: 82 06 3f ff add %i0, -1, %g1
40017274: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
40017278: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
4001727c: c2 20 a0 88 st %g1, [ %g2 + 0x88 ]
handle->shared->size.count = rtems_rfs_block_map_count (map);
40017280: f0 20 a0 84 st %i0, [ %g2 + 0x84 ]
if (rtems_rfs_file_update_mtime (handle))
40017284: d0 07 40 00 ld [ %i5 ], %o0
40017288: b0 8a 20 02 andcc %o0, 2, %i0
4001728c: 02 80 00 17 be 400172e8 <rtems_rfs_file_set_size+0x168> <== ALWAYS TAKEN
40017290: 01 00 00 00 nop
}
40017294: 81 c7 e0 08 ret <== NOT EXECUTED
40017298: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001729c: 92 10 00 12 mov %l2, %o1
400172a0: 7f ff f6 ab call 40014d4c <rtems_rfs_block_map_free_all>
400172a4: 90 10 00 14 mov %l4, %o0
if (rc > 0)
400172a8: b0 92 20 00 orcc %o0, 0, %i0
400172ac: 14 80 00 81 bg 400174b0 <rtems_rfs_file_set_size+0x330> <== NEVER TAKEN
400172b0: 01 00 00 00 nop
handle->shared->size.count = rtems_rfs_block_map_count (map);
400172b4: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
400172b8: f0 07 20 3c ld [ %i4 + 0x3c ], %i0
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
400172bc: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
400172c0: c2 20 a0 88 st %g1, [ %g2 + 0x88 ]
handle->shared->size.count = rtems_rfs_block_map_count (map);
400172c4: 10 bf ff f0 b 40017284 <rtems_rfs_file_set_size+0x104>
400172c8: f0 20 a0 84 st %i0, [ %g2 + 0x84 ]
if (size != new_size)
400172cc: 80 a4 40 09 cmp %l1, %o1
400172d0: 32 bf ff bf bne,a 400171cc <rtems_rfs_file_set_size+0x4c>
400172d4: f6 07 60 1c ld [ %i5 + 0x1c ], %i3
if (rtems_rfs_file_update_mtime (handle))
400172d8: d0 07 40 00 ld [ %i5 ], %o0
400172dc: b0 8a 20 02 andcc %o0, 2, %i0
400172e0: 32 80 00 06 bne,a 400172f8 <rtems_rfs_file_set_size+0x178> <== NEVER TAKEN
400172e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->shared->mtime = time (NULL);
400172e8: 40 00 21 c7 call 4001fa04 <time>
400172ec: 90 10 20 00 clr %o0
400172f0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400172f4: d2 20 60 90 st %o1, [ %g1 + 0x90 ]
400172f8: 81 c7 e0 08 ret
400172fc: 81 e8 00 00 restore
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
40017300: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40017304: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40017308: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
4001730c: 7f ff ae 7b call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017310: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400240c0 <IMFS_LIMITS_AND_OPTIONS+0xb80><== NOT EXECUTED
size = rtems_rfs_file_size (handle);
40017314: 10 bf ff a6 b 400171ac <rtems_rfs_file_set_size+0x2c> <== NOT EXECUTED
40017318: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
if (size < new_size)
4001731c: 08 bf ff b7 bleu 400171f8 <rtems_rfs_file_set_size+0x78>
40017320: 92 84 7f ff addcc %l1, -1, %o1
count = new_size - size;
40017324: b6 a4 40 03 subcc %l1, %g3, %i3
read_block = false;
40017328: a6 10 20 00 clr %l3
count = new_size - size;
4001732c: b4 64 00 02 subx %l0, %g2, %i2
40017330: a2 10 20 01 mov 1, %l1
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
40017334: 10 80 00 28 b 400173d4 <rtems_rfs_file_set_size+0x254>
40017338: a0 07 60 04 add %i5, 4, %l0
if (count < (length - bpos.boff))
4001733c: 80 a0 80 1b cmp %g2, %i3
40017340: 28 80 00 44 bleu,a 40017450 <rtems_rfs_file_set_size+0x2d0>
40017344: c0 27 20 40 clr [ %i4 + 0x40 ]
length = count + bpos.boff;
40017348: b2 00 40 1b add %g1, %i3, %i1
4001734c: e2 2f 20 34 stb %l1, [ %i4 + 0x34 ]
read_block = true;
40017350: a6 10 20 01 mov 1, %l3
map->size.offset = offset;
40017354: f2 27 20 40 st %i1, [ %i4 + 0x40 ]
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
40017358: 96 0c e0 01 and %l3, 1, %o3
4001735c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40017360: d4 07 bf f0 ld [ %fp + -16 ], %o2
40017364: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
40017368: 7f ff bf ae call 40007220 <rtems_rfs_buffer_handle_request>
4001736c: 92 10 00 10 mov %l0, %o1
if (rc > 0)
40017370: b0 92 20 00 orcc %o0, 0, %i0
40017374: 14 bf ff e1 bg 400172f8 <rtems_rfs_file_set_size+0x178> <== NEVER TAKEN
40017378: c2 07 bf f8 ld [ %fp + -8 ], %g1
dst = rtems_rfs_buffer_data (&handle->buffer);
4001737c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
memset (dst + bpos.boff, 0, length - bpos.boff);
40017380: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
40017384: 94 26 40 01 sub %i1, %g1, %o2
40017388: 92 10 20 00 clr %o1
4001738c: 40 00 1d 44 call 4001e89c <memset>
40017390: 90 02 00 01 add %o0, %g1, %o0
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40017394: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
40017398: e2 2f 60 04 stb %l1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001739c: 92 10 00 10 mov %l0, %o1
400173a0: 7f ff c0 69 call 40007544 <rtems_rfs_buffer_handle_release>
400173a4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (rc > 0)
400173a8: b0 92 20 00 orcc %o0, 0, %i0
400173ac: 14 bf ff d3 bg 400172f8 <rtems_rfs_file_set_size+0x178> <== NEVER TAKEN
400173b0: c2 07 bf f8 ld [ %fp + -8 ], %g1
count -= length - bpos.boff;
400173b4: 82 26 40 01 sub %i1, %g1, %g1
handle->shared->size.count = rtems_rfs_block_map_count (map);
400173b8: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
count -= length - bpos.boff;
400173bc: b6 a6 c0 01 subcc %i3, %g1, %i3
400173c0: b4 66 a0 00 subx %i2, 0, %i2
while (count)
400173c4: 80 96 80 1b orcc %i2, %i3, %g0
400173c8: 02 bf ff ac be 40017278 <rtems_rfs_file_set_size+0xf8>
400173cc: f0 07 20 3c ld [ %i4 + 0x3c ], %i0
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
400173d0: e8 00 a0 98 ld [ %g2 + 0x98 ], %l4
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
400173d4: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
400173d8: f0 27 bf f4 st %i0, [ %fp + -12 ]
400173dc: 80 a0 60 00 cmp %g1, 0
400173e0: c2 27 bf f8 st %g1, [ %fp + -8 ]
400173e4: 02 80 00 04 be 400173f4 <rtems_rfs_file_set_size+0x274>
400173e8: c0 27 bf fc clr [ %fp + -4 ]
400173ec: b0 06 3f ff add %i0, -1, %i0
400173f0: f0 27 bf f4 st %i0, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
400173f4: 96 07 bf f0 add %fp, -16, %o3
400173f8: 94 07 bf f4 add %fp, -12, %o2
400173fc: 92 10 00 12 mov %l2, %o1
40017400: 7f ff f4 19 call 40014464 <rtems_rfs_block_map_find>
40017404: 90 10 00 14 mov %l4, %o0
if (rc > 0)
40017408: b0 92 20 00 orcc %o0, 0, %i0
4001740c: 04 80 00 0c ble 4001743c <rtems_rfs_file_set_size+0x2bc>
40017410: 80 a6 20 06 cmp %i0, 6
if (rc != ENXIO)
40017414: 12 bf ff b9 bne 400172f8 <rtems_rfs_file_set_size+0x178> <== NEVER TAKEN
40017418: 96 07 bf f0 add %fp, -16, %o3
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001741c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40017420: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
40017424: 94 10 20 01 mov 1, %o2
40017428: 7f ff f4 93 call 40014674 <rtems_rfs_block_map_grow>
4001742c: 92 10 00 12 mov %l2, %o1
if (rc > 0)
40017430: b0 92 20 00 orcc %o0, 0, %i0
40017434: 14 80 00 1f bg 400174b0 <rtems_rfs_file_set_size+0x330> <== NEVER TAKEN
40017438: 01 00 00 00 nop
if (count < (length - bpos.boff))
4001743c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40017440: 80 a6 a0 00 cmp %i2, 0
40017444: 02 bf ff be be 4001733c <rtems_rfs_file_set_size+0x1bc> <== ALWAYS TAKEN
40017448: 84 26 40 01 sub %i1, %g1, %g2
4001744c: c0 27 20 40 clr [ %i4 + 0x40 ] <== NOT EXECUTED
}
40017450: 10 bf ff c2 b 40017358 <rtems_rfs_file_set_size+0x1d8>
40017454: e2 2f 20 34 stb %l1, [ %i4 + 0x34 ]
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
40017458: 94 10 00 1a mov %i2, %o2
4001745c: 92 06 e0 34 add %i3, 0x34, %o1
40017460: 7f ff f5 79 call 40014a44 <rtems_rfs_block_map_shrink>
40017464: 90 10 00 14 mov %l4, %o0
if (rc > 0)
40017468: b0 92 20 00 orcc %o0, 0, %i0
4001746c: 14 80 00 11 bg 400174b0 <rtems_rfs_file_set_size+0x330> <== NEVER TAKEN
40017470: 01 00 00 00 nop
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
40017474: f0 07 20 3c ld [ %i4 + 0x3c ], %i0
40017478: 10 bf ff 6e b 40017230 <rtems_rfs_file_set_size+0xb0>
4001747c: f6 07 60 1c ld [ %i5 + 0x1c ], %i3
40017480: 3a bf ff 77 bcc,a 4001725c <rtems_rfs_file_set_size+0xdc> <== NEVER TAKEN
40017484: f0 27 60 10 st %i0, [ %i5 + 0x10 ] <== NOT EXECUTED
40017488: 84 06 3f ff add %i0, -1, %g2
4001748c: 80 a0 40 02 cmp %g1, %g2
40017490: 12 bf ff 7a bne 40017278 <rtems_rfs_file_set_size+0xf8> <== NEVER TAKEN
40017494: 84 10 00 1b mov %i3, %g2
40017498: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001749c: 80 a0 40 19 cmp %g1, %i1
400174a0: 38 bf ff 70 bgu,a 40017260 <rtems_rfs_file_set_size+0xe0>
400174a4: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
400174a8: 10 bf ff 75 b 4001727c <rtems_rfs_file_set_size+0xfc>
400174ac: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
400174b0: 81 c7 e0 08 ret <== NOT EXECUTED
400174b4: 81 e8 00 00 restore <== NOT EXECUTED
40007a08 <rtems_rfs_format>:
return 0;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
40007a08: 9d e3 be d8 save %sp, -296, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
40007a0c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40007a10: 80 a0 60 00 cmp %g1, 0
40007a14: 12 80 02 d9 bne 40008578 <rtems_rfs_format+0xb70> <== NEVER TAKEN
40007a18: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40007a1c: 94 10 20 80 mov 0x80, %o2
40007a20: 92 10 20 00 clr %o1
40007a24: 40 00 5b 9e call 4001e89c <memset>
40007a28: 90 07 bf 80 add %fp, -128, %o0
head->next = tail;
40007a2c: 82 07 bf c4 add %fp, -60, %g1
40007a30: c2 27 bf c0 st %g1, [ %fp + -64 ]
tail->previous = head;
40007a34: 82 07 bf c0 add %fp, -64, %g1
40007a38: c2 27 bf c8 st %g1, [ %fp + -56 ]
head->next = tail;
40007a3c: 82 07 bf d4 add %fp, -44, %g1
40007a40: c2 27 bf d0 st %g1, [ %fp + -48 ]
tail->previous = head;
40007a44: 82 07 bf d0 add %fp, -48, %g1
40007a48: c2 27 bf d8 st %g1, [ %fp + -40 ]
head->next = tail;
40007a4c: 82 07 bf e4 add %fp, -28, %g1
40007a50: c2 27 bf e0 st %g1, [ %fp + -32 ]
tail->previous = head;
40007a54: 82 07 bf e0 add %fp, -32, %g1
40007a58: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->next = tail;
40007a5c: 82 07 bf f4 add %fp, -12, %g1
40007a60: c2 27 bf f0 st %g1, [ %fp + -16 ]
tail->previous = head;
40007a64: 82 07 bf f0 add %fp, -16, %g1
40007a68: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
40007a6c: 82 10 20 05 mov 5, %g1
40007a70: c2 27 bf bc st %g1, [ %fp + -68 ]
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
40007a74: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40007a78: 92 07 bf 7c add %fp, -132, %o1
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
40007a7c: c2 27 bf 7c st %g1, [ %fp + -132 ]
rc = rtems_rfs_buffer_open (name, &fs);
40007a80: 7f ff fe ba call 40007568 <rtems_rfs_buffer_open>
40007a84: 90 10 00 18 mov %i0, %o0
if (rc != 0)
40007a88: ba 92 20 00 orcc %o0, 0, %i5
40007a8c: 12 80 03 ac bne 4000893c <rtems_rfs_format+0xf34> <== NEVER TAKEN
40007a90: c2 07 bf 8c ld [ %fp + -116 ], %g1
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40007a94: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
40007a98: 80 a2 a0 00 cmp %o2, 0
40007a9c: 02 80 03 87 be 400088b8 <rtems_rfs_format+0xeb0> <== NEVER TAKEN
40007aa0: 92 10 20 00 clr %o1
fs->block_size = config->block_size;
40007aa4: d2 06 40 00 ld [ %i1 ], %o1
if (!fs->block_size)
40007aa8: 80 a2 60 00 cmp %o1, 0
40007aac: 02 80 02 b8 be 4000858c <rtems_rfs_format+0xb84>
40007ab0: d2 27 bf 84 st %o1, [ %fp + -124 ]
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40007ab4: 81 80 20 00 wr %g0, %y
40007ab8: 01 00 00 00 nop
40007abc: 01 00 00 00 nop
40007ac0: 01 00 00 00 nop
40007ac4: 82 72 40 0a udiv %o1, %o2, %g1
40007ac8: 82 58 40 0a smul %g1, %o2, %g1
40007acc: 80 a2 40 01 cmp %o1, %g1
40007ad0: 32 80 02 d7 bne,a 4000862c <rtems_rfs_format+0xc24> <== NEVER TAKEN
40007ad4: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
fs->group_blocks = config->group_blocks;
40007ad8: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007adc: c2 27 bf a4 st %g1, [ %fp + -92 ]
if (!fs->group_blocks)
40007ae0: 80 a0 60 00 cmp %g1, 0
40007ae4: 12 80 01 4a bne 4000800c <rtems_rfs_format+0x604> <== NEVER TAKEN
40007ae8: 93 2a 60 03 sll %o1, 3, %o1
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
40007aec: d2 27 bf a4 st %o1, [ %fp + -92 ]
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
40007af0: 40 00 3e 8a call 40017518 <rtems_rfs_fs_media_size>
40007af4: 90 07 bf 7c add %fp, -132, %o0
40007af8: fa 07 bf 84 ld [ %fp + -124 ], %i5
40007afc: 94 10 20 00 clr %o2
40007b00: 40 00 58 ba call 4001dde8 <__udivdi3>
40007b04: 96 10 00 1d mov %i5, %o3
40007b08: d2 27 bf 80 st %o1, [ %fp + -128 ]
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40007b0c: b9 2f 60 03 sll %i5, 3, %i4
if (dividend == 0)
40007b10: 80 a2 60 00 cmp %o1, 0
40007b14: 02 80 00 09 be 40007b38 <rtems_rfs_format+0x130> <== NEVER TAKEN
40007b18: 88 10 20 01 mov 1, %g4
return ((dividend - 1) / divisor) + 1;
40007b1c: 82 02 7f ff add %o1, -1, %g1
40007b20: 81 80 20 00 wr %g0, %y
40007b24: 01 00 00 00 nop
40007b28: 01 00 00 00 nop
40007b2c: 01 00 00 00 nop
40007b30: 82 70 40 1c udiv %g1, %i4, %g1
40007b34: 88 00 60 01 add %g1, 1, %g4
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
40007b38: c8 27 bf a0 st %g4, [ %fp + -96 ]
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40007b3c: 85 37 60 03 srl %i5, 3, %g2
fs->group_inodes = config->group_inodes;
40007b40: c6 06 60 08 ld [ %i1 + 8 ], %g3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40007b44: 03 09 24 92 sethi %hi(0x24924800), %g1
if (!fs->group_inodes)
40007b48: 80 a0 e0 00 cmp %g3, 0
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40007b4c: 82 10 61 25 or %g1, 0x125, %g1
40007b50: 80 50 80 01 umul %g2, %g1, %g0
40007b54: 85 40 00 00 rd %y, %g2
if (!fs->group_inodes)
40007b58: 32 80 01 38 bne,a 40008038 <rtems_rfs_format+0x630> <== NEVER TAKEN
40007b5c: c4 27 bf ac st %g2, [ %fp + -84 ] <== NOT EXECUTED
if (config->inode_overhead)
40007b60: f6 06 60 0c ld [ %i1 + 0xc ], %i3
40007b64: 80 a6 e0 00 cmp %i3, 0
40007b68: 22 80 02 d5 be,a 400086bc <rtems_rfs_format+0xcb4> <== ALWAYS TAKEN
40007b6c: b6 10 20 01 mov 1, %i3
blocks = ((rtems_rfs_fs_blocks (fs) -
40007b70: 82 02 7f ff add %o1, -1, %g1 <== NOT EXECUTED
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
40007b74: 82 58 40 1b smul %g1, %i3, %g1 <== NOT EXECUTED
if (dividend == 0)
40007b78: 80 a0 60 63 cmp %g1, 0x63 <== NOT EXECUTED
40007b7c: 08 80 00 0f bleu 40007bb8 <rtems_rfs_format+0x1b0> <== NOT EXECUTED
40007b80: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
40007b84: 07 14 7a e1 sethi %hi(0x51eb8400), %g3
40007b88: 86 10 e1 1f or %g3, 0x11f, %g3 ! 51eb851f <RAM_END+0x11ab851f>
40007b8c: 80 50 40 03 umul %g1, %g3, %g0
40007b90: 83 40 00 00 rd %y, %g1
40007b94: 83 30 60 05 srl %g1, 5, %g1
return ((dividend - 1) / divisor) + 1;
40007b98: 82 00 7f ff add %g1, -1, %g1
40007b9c: 81 80 20 00 wr %g0, %y
40007ba0: 01 00 00 00 nop
40007ba4: 01 00 00 00 nop
40007ba8: 01 00 00 00 nop
40007bac: 82 70 40 04 udiv %g1, %g4, %g1
40007bb0: 82 00 60 01 inc %g1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40007bb4: 86 58 40 02 smul %g1, %g2, %g3
if (dividend == 0)
40007bb8: 80 a0 e0 00 cmp %g3, 0
40007bbc: 12 80 01 1f bne 40008038 <rtems_rfs_format+0x630> <== ALWAYS TAKEN
40007bc0: c4 27 bf ac st %g2, [ %fp + -84 ]
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40007bc4: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED
40007bc8: 2a 80 01 28 bcs,a 40008068 <rtems_rfs_format+0x660> <== NOT EXECUTED
40007bcc: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
fs->group_inodes =
40007bd0: c4 27 bf a8 st %g2, [ %fp + -88 ] <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40007bd4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
40007bd8: 80 a0 60 00 cmp %g1, 0
40007bdc: 32 80 01 28 bne,a 4000807c <rtems_rfs_format+0x674> <== NEVER TAKEN
40007be0: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
fs->max_name_length = 512;
40007be4: 82 10 22 00 mov 0x200, %g1
40007be8: c2 27 bf 98 st %g1, [ %fp + -104 ]
{
errno = EINVAL;
return -1;
}
if (config->verbose)
40007bec: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40007bf0: 80 a0 60 00 cmp %g1, 0
40007bf4: 12 80 01 26 bne 4000808c <rtems_rfs_format+0x684> <== NEVER TAKEN
40007bf8: 01 00 00 00 nop
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
40007bfc: 92 10 00 1d mov %i5, %o1
40007c00: 7f ff ff 07 call 4000781c <rtems_rfs_buffer_setblksize>
40007c04: 90 07 bf 7c add %fp, -132, %o0
if (rc != 0)
40007c08: b8 92 20 00 orcc %o0, 0, %i4
40007c0c: 12 80 03 34 bne 400088dc <rtems_rfs_format+0xed4> <== NEVER TAKEN
40007c10: 96 10 20 00 clr %o3
handle->dirty = false;
40007c14: c0 2f bf 54 clrb [ %fp + -172 ]
handle->bnum = 0;
40007c18: c0 27 bf 58 clr [ %fp + -168 ]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
40007c1c: 94 10 20 00 clr %o2
handle->buffer = NULL;
40007c20: c0 27 bf 5c clr [ %fp + -164 ]
40007c24: 92 07 bf 54 add %fp, -172, %o1
40007c28: 7f ff fd 7e call 40007220 <rtems_rfs_buffer_handle_request>
40007c2c: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
40007c30: ba 92 20 00 orcc %o0, 0, %i5
40007c34: 14 80 02 29 bg 400084d8 <rtems_rfs_format+0xad0> <== NEVER TAKEN
40007c38: c2 07 bf 5c ld [ %fp + -164 ], %g1
sb = rtems_rfs_buffer_data (&handle);
40007c3c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
40007c40: d4 07 bf 84 ld [ %fp + -124 ], %o2
40007c44: 92 10 20 ff mov 0xff, %o1
40007c48: 40 00 5b 15 call 4001e89c <memset>
40007c4c: 90 10 00 01 mov %g1, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
40007c50: 84 10 20 28 mov 0x28, %g2
40007c54: c4 2a 00 00 stb %g2, [ %o0 ]
40007c58: 84 10 20 09 mov 9, %g2
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40007c5c: c0 2a 20 04 clrb [ %o0 + 4 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
40007c60: 86 10 20 01 mov 1, %g3
40007c64: c4 2a 20 01 stb %g2, [ %o0 + 1 ]
40007c68: 84 10 20 20 mov 0x20, %g2
40007c6c: c6 2a 20 03 stb %g3, [ %o0 + 3 ]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
40007c70: 82 10 00 08 mov %o0, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40007c74: c0 2a 20 05 clrb [ %o0 + 5 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40007c78: 92 07 bf 54 add %fp, -172, %o1
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
40007c7c: c4 2a 20 02 stb %g2, [ %o0 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40007c80: c0 2a 20 06 clrb [ %o0 + 6 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40007c84: 90 07 bf 7c add %fp, -132, %o0
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40007c88: c0 28 60 07 clrb [ %g1 + 7 ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40007c8c: c4 0f bf 84 ldub [ %fp + -124 ], %g2
40007c90: c4 28 60 08 stb %g2, [ %g1 + 8 ]
40007c94: c4 17 bf 84 lduh [ %fp + -124 ], %g2
40007c98: c4 28 60 09 stb %g2, [ %g1 + 9 ]
40007c9c: c4 07 bf 84 ld [ %fp + -124 ], %g2
40007ca0: 85 30 a0 08 srl %g2, 8, %g2
40007ca4: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40007ca8: c4 07 bf 80 ld [ %fp + -128 ], %g2
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40007cac: c8 07 bf 84 ld [ %fp + -124 ], %g4
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40007cb0: c4 28 60 0f stb %g2, [ %g1 + 0xf ]
40007cb4: bb 30 a0 18 srl %g2, 0x18, %i5
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40007cb8: c8 28 60 0b stb %g4, [ %g1 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40007cbc: 89 30 a0 10 srl %g2, 0x10, %g4
40007cc0: fa 28 60 0c stb %i5, [ %g1 + 0xc ]
40007cc4: 85 30 a0 08 srl %g2, 8, %g2
40007cc8: c8 28 60 0d stb %g4, [ %g1 + 0xd ]
40007ccc: c4 28 60 0e stb %g2, [ %g1 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40007cd0: c4 0f bf 94 ldub [ %fp + -108 ], %g2
40007cd4: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
40007cd8: c4 17 bf 94 lduh [ %fp + -108 ], %g2
40007cdc: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
40007ce0: c4 07 bf 94 ld [ %fp + -108 ], %g2
40007ce4: 85 30 a0 08 srl %g2, 8, %g2
40007ce8: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
40007cec: c4 07 bf 94 ld [ %fp + -108 ], %g2
40007cf0: c4 28 60 13 stb %g2, [ %g1 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40007cf4: c4 0f bf 98 ldub [ %fp + -104 ], %g2
40007cf8: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
40007cfc: c4 17 bf 98 lduh [ %fp + -104 ], %g2
40007d00: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40007d04: c4 07 bf 98 ld [ %fp + -104 ], %g2
40007d08: 85 30 a0 08 srl %g2, 8, %g2
40007d0c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40007d10: c4 07 bf 98 ld [ %fp + -104 ], %g2
40007d14: c4 28 60 17 stb %g2, [ %g1 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
40007d18: c4 0f bf a0 ldub [ %fp + -96 ], %g2
40007d1c: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
40007d20: c4 17 bf a0 lduh [ %fp + -96 ], %g2
40007d24: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
40007d28: c4 07 bf a0 ld [ %fp + -96 ], %g2
40007d2c: 85 30 a0 08 srl %g2, 8, %g2
40007d30: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
40007d34: c4 07 bf a0 ld [ %fp + -96 ], %g2
40007d38: c4 28 60 1b stb %g2, [ %g1 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
40007d3c: c4 0f bf a4 ldub [ %fp + -92 ], %g2
40007d40: c4 28 60 1c stb %g2, [ %g1 + 0x1c ]
40007d44: c4 17 bf a4 lduh [ %fp + -92 ], %g2
40007d48: c4 28 60 1d stb %g2, [ %g1 + 0x1d ]
40007d4c: c4 07 bf a4 ld [ %fp + -92 ], %g2
40007d50: 85 30 a0 08 srl %g2, 8, %g2
40007d54: c4 28 60 1e stb %g2, [ %g1 + 0x1e ]
40007d58: c4 07 bf a4 ld [ %fp + -92 ], %g2
40007d5c: c4 28 60 1f stb %g2, [ %g1 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
40007d60: c4 0f bf a8 ldub [ %fp + -88 ], %g2
40007d64: c4 28 60 20 stb %g2, [ %g1 + 0x20 ]
40007d68: c4 17 bf a8 lduh [ %fp + -88 ], %g2
40007d6c: c4 28 60 21 stb %g2, [ %g1 + 0x21 ]
40007d70: c4 07 bf a8 ld [ %fp + -88 ], %g2
40007d74: 85 30 a0 08 srl %g2, 8, %g2
40007d78: c4 28 60 22 stb %g2, [ %g1 + 0x22 ]
40007d7c: c4 07 bf a8 ld [ %fp + -88 ], %g2
40007d80: c4 28 60 23 stb %g2, [ %g1 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
40007d84: 84 10 20 38 mov 0x38, %g2
40007d88: c0 28 60 24 clrb [ %g1 + 0x24 ]
40007d8c: c4 28 60 27 stb %g2, [ %g1 + 0x27 ]
40007d90: c0 28 60 25 clrb [ %g1 + 0x25 ]
40007d94: c0 28 60 26 clrb [ %g1 + 0x26 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40007d98: 7f ff fd eb call 40007544 <rtems_rfs_buffer_handle_release>
40007d9c: c6 2f bf 54 stb %g3, [ %fp + -172 ]
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40007da0: 92 07 bf 54 add %fp, -172, %o1
40007da4: ba 10 00 08 mov %o0, %i5
if (rc > 0)
40007da8: 80 a7 60 00 cmp %i5, 0
40007dac: 14 80 02 28 bg 4000864c <rtems_rfs_format+0xc44> <== NEVER TAKEN
40007db0: 90 07 bf 7c add %fp, -132, %o0
40007db4: 7f ff fd e4 call 40007544 <rtems_rfs_buffer_handle_release>
40007db8: 01 00 00 00 nop
errno = EIO;
return -1;
}
for (group = 0; group < fs.group_count; group++)
40007dbc: c2 07 bf a0 ld [ %fp + -96 ], %g1
40007dc0: 80 a0 60 00 cmp %g1, 0
40007dc4: 24 80 01 1e ble,a 4000823c <rtems_rfs_format+0x834> <== NEVER TAKEN
40007dc8: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1 <== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40007dcc: 29 10 00 89 sethi %hi(0x40022400), %l4
printf (", blocks");
40007dd0: 27 10 00 89 sethi %hi(0x40022400), %l3
printf (", inodes");
40007dd4: 2b 10 00 89 sethi %hi(0x40022400), %l5
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40007dd8: a8 15 22 b0 or %l4, 0x2b0, %l4
printf (", blocks");
40007ddc: a6 14 e2 e8 or %l3, 0x2e8, %l3
rtems_rfs_buffer_mark_dirty (&handle);
40007de0: a4 10 20 01 mov 1, %l2
printf (", inodes");
40007de4: aa 15 63 d8 or %l5, 0x3d8, %l5
group_base = rtems_rfs_fs_block (fs, group, 0);
40007de8: f6 07 bf a4 ld [ %fp + -92 ], %i3
if (group_base > rtems_rfs_fs_blocks (fs))
40007dec: c2 07 bf 80 ld [ %fp + -128 ], %g1
group_base = rtems_rfs_fs_block (fs, group, 0);
40007df0: b4 5f 00 1b smul %i4, %i3, %i2
40007df4: 98 06 a0 01 add %i2, 1, %o4
if (group_base > rtems_rfs_fs_blocks (fs))
40007df8: 80 a3 00 01 cmp %o4, %g1
40007dfc: 18 80 01 71 bgu 400083c0 <rtems_rfs_format+0x9b8> <== NEVER TAKEN
40007e00: 84 06 c0 0c add %i3, %o4, %g2
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
40007e04: 80 a0 40 02 cmp %g1, %g2
40007e08: 2a 80 00 02 bcs,a 40007e10 <rtems_rfs_format+0x408> <== ALWAYS TAKEN
40007e0c: b6 20 40 0c sub %g1, %o4, %i3
if (verbose)
40007e10: e0 0e 60 15 ldub [ %i1 + 0x15 ], %l0
40007e14: 80 a4 20 00 cmp %l0, 0
40007e18: 12 80 01 5d bne 4000838c <rtems_rfs_format+0x984> <== NEVER TAKEN
40007e1c: e2 0e 60 14 ldub [ %i1 + 0x14 ], %l1
handle->dirty = false;
40007e20: c0 2f bf 48 clrb [ %fp + -184 ]
handle->bnum = 0;
40007e24: c0 27 bf 4c clr [ %fp + -180 ]
handle->buffer = NULL;
40007e28: c0 27 bf 50 clr [ %fp + -176 ]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40007e2c: 96 10 00 1b mov %i3, %o3
40007e30: 94 07 bf 48 add %fp, -184, %o2
40007e34: 92 07 bf 7c add %fp, -132, %o1
40007e38: 7f ff fb e1 call 40006dbc <rtems_rfs_bitmap_open>
40007e3c: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40007e40: ba 92 20 00 orcc %o0, 0, %i5
40007e44: 14 80 01 3e bg 4000833c <rtems_rfs_format+0x934> <== NEVER TAKEN
40007e48: c2 07 bf 50 ld [ %fp + -176 ], %g1
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40007e4c: d4 07 bf 84 ld [ %fp + -124 ], %o2
40007e50: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40007e54: 40 00 5a 92 call 4001e89c <memset>
40007e58: 92 10 20 ff mov 0xff, %o1
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40007e5c: 7f ff fb 1a call 40006ac4 <rtems_rfs_bitmap_map_clear_all>
40007e60: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40007e64: ba 92 20 00 orcc %o0, 0, %i5
40007e68: 14 80 01 60 bg 400083e8 <rtems_rfs_format+0x9e0> <== NEVER TAKEN
40007e6c: 92 10 20 00 clr %o1
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
40007e70: 7f ff fa 5f call 400067ec <rtems_rfs_bitmap_map_set>
40007e74: 90 07 bf 54 add %fp, -172, %o0
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
40007e78: 92 10 20 01 mov 1, %o1
40007e7c: 7f ff fa 5c call 400067ec <rtems_rfs_bitmap_map_set>
40007e80: 90 07 bf 54 add %fp, -172, %o0
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40007e84: c2 07 bf a8 ld [ %fp + -88 ], %g1
if (dividend == 0)
40007e88: 80 a0 60 00 cmp %g1, 0
40007e8c: 02 80 01 68 be 4000842c <rtems_rfs_format+0xa24> <== NEVER TAKEN
40007e90: 82 00 7f ff add %g1, -1, %g1
return ((dividend - 1) / divisor) + 1;
40007e94: 81 80 20 00 wr %g0, %y
40007e98: ee 07 bf ac ld [ %fp + -84 ], %l7
40007e9c: 01 00 00 00 nop
40007ea0: 01 00 00 00 nop
40007ea4: ae 70 40 17 udiv %g1, %l7, %l7
40007ea8: ac 05 e0 01 add %l7, 1, %l6
for (b = 0; b < blocks; b++)
40007eac: 80 a5 a0 00 cmp %l6, 0
40007eb0: 04 80 00 0a ble 40007ed8 <rtems_rfs_format+0x4d0> <== NEVER TAKEN
40007eb4: ba 10 20 02 mov 2, %i5
40007eb8: ae 05 e0 03 add %l7, 3, %l7
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40007ebc: 92 10 00 1d mov %i5, %o1
40007ec0: 7f ff fa 4b call 400067ec <rtems_rfs_bitmap_map_set>
40007ec4: 90 07 bf 54 add %fp, -172, %o0
for (b = 0; b < blocks; b++)
40007ec8: ba 07 60 01 inc %i5
40007ecc: 80 a7 40 17 cmp %i5, %l7
40007ed0: 12 bf ff fc bne 40007ec0 <rtems_rfs_format+0x4b8>
40007ed4: 92 10 00 1d mov %i5, %o1
rc = rtems_rfs_bitmap_close (&bitmap);
40007ed8: 7f ff fb ca call 40006e00 <rtems_rfs_bitmap_close>
40007edc: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40007ee0: ba 92 20 00 orcc %o0, 0, %i5
40007ee4: 14 80 01 5c bg 40008454 <rtems_rfs_format+0xa4c> <== NEVER TAKEN
40007ee8: 92 07 bf 48 add %fp, -184, %o1
if (verbose)
40007eec: 80 a4 20 00 cmp %l0, 0
40007ef0: 12 80 01 76 bne 400084c8 <rtems_rfs_format+0xac0> <== NEVER TAKEN
40007ef4: e4 2f bf 48 stb %l2, [ %fp + -184 ]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40007ef8: 98 06 a0 02 add %i2, 2, %o4
40007efc: 96 10 00 1b mov %i3, %o3
40007f00: 94 07 bf 48 add %fp, -184, %o2
40007f04: 92 07 bf 7c add %fp, -132, %o1
40007f08: 7f ff fb ad call 40006dbc <rtems_rfs_bitmap_open>
40007f0c: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40007f10: ba 92 20 00 orcc %o0, 0, %i5
40007f14: 14 80 01 5e bg 4000848c <rtems_rfs_format+0xa84> <== NEVER TAKEN
40007f18: c2 07 bf 50 ld [ %fp + -176 ], %g1
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
40007f1c: d4 07 bf 84 ld [ %fp + -124 ], %o2
40007f20: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40007f24: 40 00 5a 5e call 4001e89c <memset>
40007f28: 92 10 20 00 clr %o1
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40007f2c: 7f ff fa e6 call 40006ac4 <rtems_rfs_bitmap_map_clear_all>
40007f30: 90 07 bf 54 add %fp, -172, %o0
40007f34: ba 10 00 08 mov %o0, %i5
if (rc > 0)
40007f38: 80 a7 60 00 cmp %i5, 0
40007f3c: 14 80 01 7e bg 40008534 <rtems_rfs_format+0xb2c> <== NEVER TAKEN
40007f40: 90 07 bf 54 add %fp, -172, %o0
rc = rtems_rfs_bitmap_close (&bitmap);
40007f44: 7f ff fb af call 40006e00 <rtems_rfs_bitmap_close>
40007f48: 01 00 00 00 nop
if (rc > 0)
40007f4c: ba 92 20 00 orcc %o0, 0, %i5
40007f50: 14 80 02 0d bg 40008784 <rtems_rfs_format+0xd7c> <== NEVER TAKEN
40007f54: 80 8c 60 ff btst 0xff, %l1
if (initialise_inodes)
40007f58: 02 80 00 b0 be 40008218 <rtems_rfs_format+0x810> <== ALWAYS TAKEN
40007f5c: e4 2f bf 48 stb %l2, [ %fp + -184 ]
for (b = 0; b < blocks; b++)
40007f60: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
40007f64: 04 80 00 ad ble 40008218 <rtems_rfs_format+0x810> <== NOT EXECUTED
40007f68: b4 06 a0 03 add %i2, 3, %i2 <== NOT EXECUTED
40007f6c: 10 80 00 0a b 40007f94 <rtems_rfs_format+0x58c> <== NOT EXECUTED
40007f70: ac 05 80 1a add %l6, %i2, %l6 <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40007f74: c2 07 bf 50 ld [ %fp + -176 ], %g1 <== NOT EXECUTED
40007f78: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
40007f7c: 40 00 5a 48 call 4001e89c <memset> <== NOT EXECUTED
40007f80: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
for (b = 0; b < blocks; b++)
40007f84: b4 06 a0 01 inc %i2 <== NOT EXECUTED
40007f88: 80 a5 80 1a cmp %l6, %i2 <== NOT EXECUTED
40007f8c: 02 80 00 a3 be 40008218 <rtems_rfs_format+0x810> <== NOT EXECUTED
40007f90: e4 2f bf 48 stb %l2, [ %fp + -184 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40007f94: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40007f98: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40007f9c: 96 10 20 00 clr %o3 <== NOT EXECUTED
40007fa0: 7f ff fc a0 call 40007220 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
40007fa4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
if (rc > 0)
40007fa8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40007fac: 04 bf ff f2 ble 40007f74 <rtems_rfs_format+0x56c> <== NOT EXECUTED
40007fb0: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40007fb4: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40007fb8: 7f ff fd 63 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40007fbc: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40007fc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40007fc4: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
{
errno = EIO;
return -1;
40007fc8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
handle->bnum = 0;
40007fcc: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40007fd0: 40 00 5d 8f call 4001f60c <strerror> <== NOT EXECUTED
40007fd4: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
40007fd8: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
40007fdc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
40007fe0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40007fe4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40007fe8: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40007fec: 7f ff eb 43 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40007ff0: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400228c8 <IMFS_node_control_sym_link+0xb40><== NOT EXECUTED
errno = EIO;
40007ff4: 40 00 58 ca call 4001e31c <__errno> <== NOT EXECUTED
40007ff8: 01 00 00 00 nop <== NOT EXECUTED
40007ffc: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED
40008000: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40008004: 81 c7 e0 08 ret <== NOT EXECUTED
40008008: 81 e8 00 00 restore <== NOT EXECUTED
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
4000800c: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
40008010: 08 bf fe b8 bleu 40007af0 <rtems_rfs_format+0xe8> <== NOT EXECUTED
40008014: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
printf ("group block count is higher than bits in block\n");
40008018: 7f ff eb 46 call 40002d30 <__wrap_puts> <== NOT EXECUTED
4000801c: 90 12 23 80 or %o0, 0x380, %o0 ! 40022380 <IMFS_node_control_sym_link+0x5f8><== NOT EXECUTED
errno = EINVAL;
40008020: 40 00 58 bf call 4001e31c <__errno> <== NOT EXECUTED
40008024: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40008028: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000802c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40008030: 81 c7 e0 08 ret <== NOT EXECUTED
40008034: 81 e8 00 00 restore <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40008038: 82 00 ff ff add %g3, -1, %g1
4000803c: 81 80 20 00 wr %g0, %y
40008040: 01 00 00 00 nop
40008044: 01 00 00 00 nop
40008048: 01 00 00 00 nop
4000804c: 82 70 40 02 udiv %g1, %g2, %g1
40008050: 82 00 60 01 inc %g1
fs->inodes_per_block) * fs->inodes_per_block;
40008054: 84 58 80 01 smul %g2, %g1, %g2
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40008058: 80 a7 00 02 cmp %i4, %g2
4000805c: 3a bf fe de bcc,a 40007bd4 <rtems_rfs_format+0x1cc> <== ALWAYS TAKEN
40008060: c4 27 bf a8 st %g2, [ %fp + -88 ]
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
40008064: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40008068: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED
if (!fs->max_name_length)
4000806c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40008070: 22 bf fe de be,a 40007be8 <rtems_rfs_format+0x1e0> <== NOT EXECUTED
40008074: 82 10 22 00 mov 0x200, %g1 <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40008078: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
if (config->verbose)
4000807c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1 <== NOT EXECUTED
40008080: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40008084: 02 bf fe df be 40007c00 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
40008088: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4000808c: 40 00 3d 23 call 40017518 <rtems_rfs_fs_media_size> <== NOT EXECUTED
40008090: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40008094: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
40008098: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4000809c: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
400080a0: 7f ff eb 16 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400080a4: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 400223b0 <IMFS_node_control_sym_link+0x628><== NOT EXECUTED
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
400080a8: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
400080ac: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
400080b0: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
400080b4: 7f ff eb 11 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400080b8: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 400223d8 <IMFS_node_control_sym_link+0x650><== NOT EXECUTED
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
400080bc: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
400080c0: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
400080c4: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400080c8: 7f ff eb 0c call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400080cc: 90 12 20 00 mov %o0, %o0 ! 40022400 <IMFS_node_control_sym_link+0x678> <== NOT EXECUTED
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
400080d0: 40 00 3d 0c call 40017500 <rtems_rfs_fs_size> <== NOT EXECUTED
400080d4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
400080d8: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
400080dc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400080e0: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400080e4: 7f ff eb 05 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400080e8: 90 12 20 30 or %o0, 0x30, %o0 ! 40022430 <IMFS_node_control_sym_link+0x6a8><== NOT EXECUTED
printf ("rtems-rfs: format: blocks = %zu\n",
400080ec: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
400080f0: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400080f4: 7f ff eb 01 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400080f8: 90 12 20 50 or %o0, 0x50, %o0 ! 40022450 <IMFS_node_control_sym_link+0x6c8><== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
400080fc: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
40008100: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008104: 7f ff ea fd call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008108: 90 12 20 78 or %o0, 0x78, %o0 ! 40022478 <IMFS_node_control_sym_link+0x6f0><== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4000810c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
40008110: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
40008114: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008118: 7f ff ea f8 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000811c: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400224a0 <IMFS_node_control_sym_link+0x718><== NOT EXECUTED
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
40008120: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
40008124: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008128: 7f ff ea f4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000812c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400224c8 <IMFS_node_control_sym_link+0x740><== NOT EXECUTED
fs.group_inodes * fs.group_count,
40008130: c4 07 bf a8 ld [ %fp + -88 ], %g2 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40008134: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40008138: 83 28 a0 03 sll %g2, 3, %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4000813c: 92 58 80 09 smul %g2, %o1, %o1 <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40008140: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40008144: c6 07 bf 84 ld [ %fp + -124 ], %g3 <== NOT EXECUTED
40008148: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED
if (dividend == 0)
4000814c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40008150: 02 80 00 0a be 40008178 <rtems_rfs_format+0x770> <== NOT EXECUTED
40008154: 84 10 27 d0 mov 0x7d0, %g2 <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40008158: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000815c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
40008160: 01 00 00 00 nop <== NOT EXECUTED
40008164: 01 00 00 00 nop <== NOT EXECUTED
40008168: 01 00 00 00 nop <== NOT EXECUTED
4000816c: 82 70 40 03 udiv %g1, %g3, %g1 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40008170: 82 00 60 02 add %g1, 2, %g1 <== NOT EXECUTED
40008174: 84 58 63 e8 smul %g1, 0x3e8, %g2 <== NOT EXECUTED
40008178: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4000817c: 87 28 e0 03 sll %g3, 3, %g3 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40008180: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40008184: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
40008188: 38 80 00 02 bgu,a 40008190 <rtems_rfs_format+0x788> <== NOT EXECUTED
4000818c: 82 10 00 03 mov %g3, %g1 <== NOT EXECUTED
40008190: 87 38 a0 1f sra %g2, 0x1f, %g3 <== NOT EXECUTED
40008194: 81 80 e0 00 wr %g3, %y <== NOT EXECUTED
40008198: 01 00 00 00 nop <== NOT EXECUTED
4000819c: 01 00 00 00 nop <== NOT EXECUTED
400081a0: 01 00 00 00 nop <== NOT EXECUTED
400081a4: 82 78 80 01 sdiv %g2, %g1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400081a8: 85 38 60 1f sra %g1, 0x1f, %g2 <== NOT EXECUTED
400081ac: 15 19 99 99 sethi %hi(0x66666400), %o2 <== NOT EXECUTED
400081b0: 94 12 a2 67 or %o2, 0x267, %o2 ! 66666667 <RAM_END+0x26266667> <== NOT EXECUTED
400081b4: 80 58 40 0a smul %g1, %o2, %g0 <== NOT EXECUTED
400081b8: 95 40 00 00 rd %y, %o2 <== NOT EXECUTED
400081bc: 95 3a a0 02 sra %o2, 2, %o2 <== NOT EXECUTED
400081c0: 94 22 80 02 sub %o2, %g2, %o2 <== NOT EXECUTED
400081c4: 85 2a a0 02 sll %o2, 2, %g2 <== NOT EXECUTED
400081c8: 84 00 80 0a add %g2, %o2, %g2 <== NOT EXECUTED
400081cc: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400081d0: 97 28 a0 01 sll %g2, 1, %o3 <== NOT EXECUTED
400081d4: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
400081d8: 7f ff ea c8 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400081dc: 96 20 40 0b sub %g1, %o3, %o3 <== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
400081e0: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
400081e4: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400081e8: 7f ff ea c4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400081ec: 90 12 21 20 or %o0, 0x120, %o0 ! 40022520 <IMFS_node_control_sym_link+0x798><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
400081f0: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
400081f4: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400081f8: 7f ff ea c0 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400081fc: 90 12 21 40 or %o0, 0x140, %o0 ! 40022540 <IMFS_node_control_sym_link+0x7b8><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
40008200: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
40008204: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008208: 7f ff ea bc call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000820c: 90 12 21 68 or %o0, 0x168, %o0 ! 40022568 <IMFS_node_control_sym_link+0x7e0><== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
40008210: 10 bf fe 7b b 40007bfc <rtems_rfs_format+0x1f4> <== NOT EXECUTED
40008214: fa 07 bf 84 ld [ %fp + -124 ], %i5 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40008218: 92 07 bf 48 add %fp, -184, %o1
4000821c: 7f ff fc ca call 40007544 <rtems_rfs_buffer_handle_release>
40008220: 90 07 bf 7c add %fp, -132, %o0
for (group = 0; group < fs.group_count; group++)
40008224: c2 07 bf a0 ld [ %fp + -96 ], %g1
40008228: b8 07 20 01 inc %i4
4000822c: 80 a0 40 1c cmp %g1, %i4
40008230: 14 bf fe ef bg 40007dec <rtems_rfs_format+0x3e4> <== NEVER TAKEN
40008234: f6 07 bf a4 ld [ %fp + -92 ], %i3
}
if (config->verbose)
40008238: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
4000823c: 80 a0 60 00 cmp %g1, 0
40008240: 12 80 01 47 bne 4000875c <rtems_rfs_format+0xd54> <== NEVER TAKEN
40008244: 01 00 00 00 nop
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
40008248: 7f ff fd b6 call 40007920 <rtems_rfs_buffer_close>
4000824c: 90 07 bf 7c add %fp, -132, %o0
if (rc != 0)
40008250: ba 92 20 00 orcc %o0, 0, %i5
40008254: 12 80 01 ae bne 4000890c <rtems_rfs_format+0xf04> <== NEVER TAKEN
40008258: 98 07 bf 44 add %fp, -188, %o4
rc = rtems_rfs_fs_open (name, NULL,
4000825c: 96 10 20 00 clr %o3
40008260: 94 10 20 06 mov 6, %o2
40008264: 92 10 20 00 clr %o1
40008268: 40 00 3c b3 call 40017534 <rtems_rfs_fs_open>
4000826c: 90 10 00 18 mov %i0, %o0
if (rc != 0)
40008270: 80 a2 20 00 cmp %o0, 0
40008274: 12 80 01 2b bne 40008720 <rtems_rfs_format+0xd18> <== NEVER TAKEN
40008278: 94 07 bf 48 add %fp, -184, %o2
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
4000827c: d0 07 bf 44 ld [ %fp + -188 ], %o0
40008280: 40 00 03 6d call 40009034 <rtems_rfs_inode_alloc>
40008284: 92 10 20 01 mov 1, %o1
if (rc != 0)
40008288: b0 92 20 00 orcc %o0, 0, %i0
4000828c: 12 80 01 4d bne 400087c0 <rtems_rfs_format+0xdb8> <== NEVER TAKEN
40008290: d2 07 bf 48 ld [ %fp + -184 ], %o1
if (ino != RTEMS_RFS_ROOT_INO)
40008294: 80 a2 60 01 cmp %o1, 1
40008298: 12 80 01 10 bne 400086d8 <rtems_rfs_format+0xcd0> <== NEVER TAKEN
4000829c: 96 10 20 01 mov 1, %o3
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400082a0: d0 07 bf 44 ld [ %fp + -188 ], %o0
400082a4: 94 07 bf 54 add %fp, -172, %o2
400082a8: 40 00 03 9a call 40009110 <rtems_rfs_inode_open>
400082ac: 92 10 20 01 mov 1, %o1
if (rc != 0)
400082b0: b0 92 20 00 orcc %o0, 0, %i0
400082b4: 12 80 01 4d bne 400087e8 <rtems_rfs_format+0xde0> <== NEVER TAKEN
400082b8: 98 10 20 00 clr %o4
rc = rtems_rfs_inode_initialise (&inode, 0,
400082bc: 96 10 20 00 clr %o3
400082c0: 92 10 20 00 clr %o1
400082c4: 15 00 00 10 sethi %hi(0x4000), %o2
400082c8: 90 07 bf 54 add %fp, -172, %o0
400082cc: 40 00 04 a6 call 40009564 <rtems_rfs_inode_initialise>
400082d0: 94 12 a1 c9 or %o2, 0x1c9, %o2
if (rc != 0)
400082d4: ba 92 20 00 orcc %o0, 0, %i5
400082d8: 12 80 01 6f bne 40008894 <rtems_rfs_format+0xe8c> <== NEVER TAKEN
400082dc: 01 00 00 00 nop
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
400082e0: d8 07 bf 48 ld [ %fp + -184 ], %o4
400082e4: d0 07 bf 44 ld [ %fp + -188 ], %o0
400082e8: 96 10 20 01 mov 1, %o3
400082ec: 92 07 bf 54 add %fp, -172, %o1
400082f0: 15 10 00 86 sethi %hi(0x40021800), %o2
400082f4: 40 00 34 2d call 400153a8 <rtems_rfs_dir_add_entry>
400082f8: 94 12 a1 08 or %o2, 0x108, %o2 ! 40021908 <_Thread_Idle_stack_size+0x68>
if (rc != 0)
400082fc: ba 92 20 00 orcc %o0, 0, %i5
40008300: 12 80 01 5c bne 40008870 <rtems_rfs_format+0xe68> <== NEVER TAKEN
40008304: 01 00 00 00 nop
rc = rtems_rfs_inode_close (fs, &inode);
40008308: d0 07 bf 44 ld [ %fp + -188 ], %o0
4000830c: 40 00 03 fa call 400092f4 <rtems_rfs_inode_close>
40008310: 92 07 bf 54 add %fp, -172, %o1
if (rc != 0)
40008314: ba 92 20 00 orcc %o0, 0, %i5
40008318: 12 80 01 4e bne 40008850 <rtems_rfs_format+0xe48> <== NEVER TAKEN
4000831c: 01 00 00 00 nop
rc = rtems_rfs_fs_close (fs);
40008320: 40 00 3e 97 call 40017d7c <rtems_rfs_fs_close>
40008324: d0 07 bf 44 ld [ %fp + -188 ], %o0
if (rc != 0)
40008328: b0 92 20 00 orcc %o0, 0, %i0
4000832c: 12 80 01 3d bne 40008820 <rtems_rfs_format+0xe18> <== NEVER TAKEN
40008330: 01 00 00 00 nop
errno = rc;
return -1;
}
return 0;
}
40008334: 81 c7 e0 08 ret
40008338: 81 e8 00 00 restore
4000833c: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40008340: 7f ff fc 81 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008344: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40008348: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4000834c: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
40008350: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
40008354: 40 00 5c ae call 4001f60c <strerror> <== NOT EXECUTED
40008358: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
4000835c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40008360: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40008364: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40008368: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
4000836c: 7f ff ea 63 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008370: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 400226f8 <IMFS_node_control_sym_link+0x970><== NOT EXECUTED
errno = EIO;
40008374: 40 00 57 ea call 4001e31c <__errno> <== NOT EXECUTED
40008378: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000837c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40008380: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40008384: 81 c7 e0 08 ret <== NOT EXECUTED
40008388: 81 e8 00 00 restore <== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
4000838c: d8 27 bf 3c st %o4, [ %fp + -196 ] <== NOT EXECUTED
40008390: 94 10 00 0c mov %o4, %o2 <== NOT EXECUTED
40008394: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40008398: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4000839c: 7f ff ea 57 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400083a0: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
printf (", blocks");
400083a4: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
handle->dirty = false;
400083a8: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
400083ac: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
400083b0: 7f ff ea 52 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400083b4: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
400083b8: 10 bf fe 9d b 40007e2c <rtems_rfs_format+0x424> <== NOT EXECUTED
400083bc: d8 07 bf 3c ld [ %fp + -196 ], %o4 <== NOT EXECUTED
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
400083c0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400083c4: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400083c8: 7f ff ea 4c call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400083cc: 90 12 22 70 or %o0, 0x270, %o0 ! 40022670 <IMFS_node_control_sym_link+0x8e8><== NOT EXECUTED
errno = EIO;
400083d0: 40 00 57 d3 call 4001e31c <__errno> <== NOT EXECUTED
400083d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400083d8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400083dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
400083e0: 81 c7 e0 08 ret <== NOT EXECUTED
400083e4: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
400083e8: 7f ff fa 86 call 40006e00 <rtems_rfs_bitmap_close> <== NOT EXECUTED
400083ec: 90 07 bf 54 add %fp, -172, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400083f0: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
400083f4: 7f ff fc 54 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
400083f8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
400083fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40008400: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
40008404: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
40008408: 40 00 5c 81 call 4001f60c <strerror> <== NOT EXECUTED
4000840c: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
40008410: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40008414: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40008418: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4000841c: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008420: 7f ff ea 36 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008424: 90 12 23 40 or %o0, 0x340, %o0 ! 40022740 <IMFS_node_control_sym_link+0x9b8><== NOT EXECUTED
return false;
40008428: 30 bf ff d3 b,a 40008374 <rtems_rfs_format+0x96c> <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
4000842c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
40008430: 7f ff f8 ef call 400067ec <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
40008434: 90 07 bf 54 add %fp, -172, %o0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
40008438: 90 07 bf 54 add %fp, -172, %o0 <== NOT EXECUTED
4000843c: 7f ff fa 71 call 40006e00 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40008440: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
if (rc > 0)
40008444: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40008448: 04 bf fe aa ble 40007ef0 <rtems_rfs_format+0x4e8> <== NOT EXECUTED
4000844c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40008450: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40008454: 7f ff fc 3c call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008458: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
4000845c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40008460: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
40008464: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
40008468: 40 00 5c 69 call 4001f60c <strerror> <== NOT EXECUTED
4000846c: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
40008470: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40008474: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40008478: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4000847c: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008480: 7f ff ea 1e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008484: 90 12 23 90 or %o0, 0x390, %o0 ! 40022790 <IMFS_node_control_sym_link+0xa08><== NOT EXECUTED
return false;
40008488: 30 bf ff bb b,a 40008374 <rtems_rfs_format+0x96c> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4000848c: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40008490: 7f ff fc 2d call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008494: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
40008498: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4000849c: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
400084a0: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
400084a4: 40 00 5c 5a call 4001f60c <strerror> <== NOT EXECUTED
400084a8: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
400084ac: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400084b0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400084b4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400084b8: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400084bc: 7f ff ea 0f call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400084c0: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 400227e8 <IMFS_node_control_sym_link+0xa60><== NOT EXECUTED
return false;
400084c4: 30 bf ff ac b,a 40008374 <rtems_rfs_format+0x96c> <== NOT EXECUTED
printf (", inodes");
400084c8: 7f ff ea 0c call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400084cc: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
400084d0: 10 bf fe 8b b 40007efc <rtems_rfs_format+0x4f4> <== NOT EXECUTED
400084d4: 98 06 a0 02 add %i2, 2, %o4 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400084d8: 92 07 bf 54 add %fp, -172, %o1 <== NOT EXECUTED
400084dc: 7f ff fc 1a call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
400084e0: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
400084e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400084e8: c0 2f bf 54 clrb [ %fp + -172 ] <== NOT EXECUTED
return -1;
400084ec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
handle->bnum = 0;
400084f0: c0 27 bf 58 clr [ %fp + -168 ] <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
400084f4: 40 00 5c 46 call 4001f60c <strerror> <== NOT EXECUTED
400084f8: c0 27 bf 5c clr [ %fp + -164 ] <== NOT EXECUTED
400084fc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40008500: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008504: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008508: 7f ff e9 fc call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000850c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 400225c8 <IMFS_node_control_sym_link+0x840><== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
40008510: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008514: 7f ff ea 07 call 40002d30 <__wrap_puts> <== NOT EXECUTED
40008518: 90 12 22 40 or %o0, 0x240, %o0 ! 40022640 <IMFS_node_control_sym_link+0x8b8><== NOT EXECUTED
errno = EIO;
4000851c: 40 00 57 80 call 4001e31c <__errno> <== NOT EXECUTED
40008520: 01 00 00 00 nop <== NOT EXECUTED
40008524: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED
40008528: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
4000852c: 81 c7 e0 08 ret <== NOT EXECUTED
40008530: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
40008534: 7f ff fa 33 call 40006e00 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40008538: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4000853c: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40008540: 7f ff fc 01 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008544: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
40008548: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4000854c: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
40008550: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
40008554: 40 00 5c 2e call 4001f60c <strerror> <== NOT EXECUTED
40008558: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
4000855c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40008560: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40008564: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40008568: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
4000856c: 7f ff e9 e3 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008570: 90 12 20 30 or %o0, 0x30, %o0 ! 40022830 <IMFS_node_control_sym_link+0xaa8><== NOT EXECUTED
return false;
40008574: 30 bf ff 80 b,a 40008374 <rtems_rfs_format+0x96c> <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
40008578: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
4000857c: 7f ff e9 df call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008580: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 400222d0 <IMFS_node_control_sym_link+0x548><== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40008584: 10 bf fd 27 b 40007a20 <rtems_rfs_format+0x18> <== NOT EXECUTED
40008588: 94 10 20 80 mov 0x80, %o2 <== NOT EXECUTED
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4000858c: 40 00 3b e3 call 40017518 <rtems_rfs_fs_media_size>
40008590: 90 07 bf 7c add %fp, -132, %o0
40008594: 84 10 00 08 mov %o0, %g2
if (total_size >= GIGS (1))
40008598: 80 a0 a0 00 cmp %g2, 0
4000859c: 02 80 00 41 be 400086a0 <rtems_rfs_format+0xc98> <== ALWAYS TAKEN
400085a0: 86 10 00 09 mov %o1, %g3
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
400085a4: b4 10 20 00 clr %i2 <== NOT EXECUTED
400085a8: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
for (b = 31; b > 0; b--)
400085ac: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
400085b0: ba 80 c0 1b addcc %g3, %i3, %i5 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
400085b4: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
400085b8: b8 40 80 1a addx %g2, %i2, %i4 <== NOT EXECUTED
400085bc: 89 37 60 14 srl %i5, 0x14, %g4 <== NOT EXECUTED
400085c0: 85 2f 20 0c sll %i4, 0xc, %g2 <== NOT EXECUTED
400085c4: 10 80 00 04 b 400085d4 <rtems_rfs_format+0xbcc> <== NOT EXECUTED
400085c8: 84 10 80 04 or %g2, %g4, %g2 <== NOT EXECUTED
for (b = 31; b > 0; b--)
400085cc: 02 80 00 06 be 400085e4 <rtems_rfs_format+0xbdc> <== NOT EXECUTED
400085d0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
400085d4: 93 28 c0 01 sll %g3, %g1, %o1 <== NOT EXECUTED
400085d8: 80 88 80 09 btst %g2, %o1 <== NOT EXECUTED
400085dc: 02 bf ff fc be 400085cc <rtems_rfs_format+0xbc4> <== NOT EXECUTED
400085e0: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
fs->block_size = 1 << b;
400085e4: d2 27 bf 84 st %o1, [ %fp + -124 ] <== NOT EXECUTED
if (fs->block_size < 512)
400085e8: 80 a2 61 ff cmp %o1, 0x1ff
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
400085ec: c2 07 bf 8c ld [ %fp + -116 ], %g1
if (fs->block_size < 512)
400085f0: 18 80 00 5e bgu 40008768 <rtems_rfs_format+0xd60> <== NEVER TAKEN
400085f4: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
fs->block_size = 512;
400085f8: 82 10 22 00 mov 0x200, %g1
400085fc: c2 27 bf 84 st %g1, [ %fp + -124 ]
40008600: 92 10 22 00 mov 0x200, %o1
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40008604: 81 80 20 00 wr %g0, %y
40008608: 01 00 00 00 nop
4000860c: 01 00 00 00 nop
40008610: 01 00 00 00 nop
40008614: 82 72 40 0a udiv %o1, %o2, %g1
40008618: 82 58 40 0a smul %g1, %o2, %g1
4000861c: 80 a2 40 01 cmp %o1, %g1
40008620: 22 bf fd 2f be,a 40007adc <rtems_rfs_format+0xd4> <== ALWAYS TAKEN
40008624: c2 06 60 04 ld [ %i1 + 4 ], %g1
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
40008628: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
4000862c: 7f ff e9 b3 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008630: 90 12 23 40 or %o0, 0x340, %o0 ! 40022340 <IMFS_node_control_sym_link+0x5b8><== NOT EXECUTED
errno = EINVAL;
40008634: 40 00 57 3a call 4001e31c <__errno> <== NOT EXECUTED
40008638: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000863c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40008640: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40008644: 81 c7 e0 08 ret <== NOT EXECUTED
40008648: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4000864c: 7f ff fb be call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008650: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
40008654: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40008658: c0 2f bf 54 clrb [ %fp + -172 ] <== NOT EXECUTED
handle->bnum = 0;
4000865c: c0 27 bf 58 clr [ %fp + -168 ] <== NOT EXECUTED
40008660: 40 00 5b eb call 4001f60c <strerror> <== NOT EXECUTED
40008664: c0 27 bf 5c clr [ %fp + -164 ] <== NOT EXECUTED
40008668: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000866c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008670: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008674: 7f ff e9 a1 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008678: 90 12 22 00 or %o0, 0x200, %o0 ! 40022600 <IMFS_node_control_sym_link+0x878><== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
4000867c: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
40008680: 7f ff e9 ac call 40002d30 <__wrap_puts> <== NOT EXECUTED
40008684: 90 12 22 40 or %o0, 0x240, %o0 ! 40022640 <IMFS_node_control_sym_link+0x8b8><== NOT EXECUTED
errno = EIO;
40008688: 40 00 57 25 call 4001e31c <__errno> <== NOT EXECUTED
4000868c: 01 00 00 00 nop <== NOT EXECUTED
40008690: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED
40008694: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40008698: 81 c7 e0 08 ret <== NOT EXECUTED
4000869c: 81 e8 00 00 restore <== NOT EXECUTED
if (total_size >= GIGS (1))
400086a0: 03 00 03 ff sethi %hi(0xffc00), %g1
400086a4: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <_ISR_Stack_size+0xfefff>
400086a8: 80 a0 c0 01 cmp %g3, %g1
400086ac: 08 bf ff cf bleu 400085e8 <rtems_rfs_format+0xbe0> <== ALWAYS TAKEN
400086b0: d2 07 bf 84 ld [ %fp + -124 ], %o1
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
400086b4: 10 bf ff bd b 400085a8 <rtems_rfs_format+0xba0> <== NOT EXECUTED
400086b8: b4 10 20 00 clr %i2 <== NOT EXECUTED
blocks = ((rtems_rfs_fs_blocks (fs) -
400086bc: 82 02 7f ff add %o1, -1, %g1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
400086c0: 82 58 40 1b smul %g1, %i3, %g1
if (dividend == 0)
400086c4: 80 a0 60 63 cmp %g1, 0x63
400086c8: 18 bf fd 2f bgu 40007b84 <rtems_rfs_format+0x17c>
400086cc: 86 10 00 02 mov %g2, %g3
400086d0: 10 bf fd 3b b 40007bbc <rtems_rfs_format+0x1b4>
400086d4: 80 a0 e0 00 cmp %g3, 0
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
400086d8: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
400086dc: 7f ff e9 87 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400086e0: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400229b0 <IMFS_node_control_sym_link+0xc28><== NOT EXECUTED
rtems_rfs_fs_close (fs);
400086e4: 40 00 3d a6 call 40017d7c <rtems_rfs_fs_close> <== NOT EXECUTED
400086e8: d0 07 bf 44 ld [ %fp + -188 ], %o0 <== NOT EXECUTED
return EINVAL;
400086ec: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
400086f0: 40 00 5b c7 call 4001f60c <strerror> <== NOT EXECUTED
400086f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400086f8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400086fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008700: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008704: 7f ff e9 7d call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008708: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40022af0 <IMFS_node_control_sym_link+0xd68><== NOT EXECUTED
errno = rc;
4000870c: 40 00 57 04 call 4001e31c <__errno> <== NOT EXECUTED
40008710: 01 00 00 00 nop <== NOT EXECUTED
40008714: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
return -1;
40008718: 81 c7 e0 08 ret <== NOT EXECUTED
4000871c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
rc = errno;
40008720: 40 00 56 ff call 4001e31c <__errno> <== NOT EXECUTED
40008724: 01 00 00 00 nop <== NOT EXECUTED
40008728: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
4000872c: 40 00 5b b8 call 4001f60c <strerror> <== NOT EXECUTED
40008730: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40008734: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40008738: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000873c: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008740: 7f ff e9 6e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008744: 90 12 21 40 or %o0, 0x140, %o0 ! 40022940 <IMFS_node_control_sym_link+0xbb8><== NOT EXECUTED
if (rc != 0)
40008748: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000874c: 12 bf ff e9 bne 400086f0 <rtems_rfs_format+0xce8> <== NOT EXECUTED
40008750: 01 00 00 00 nop <== NOT EXECUTED
}
40008754: 81 c7 e0 08 ret <== NOT EXECUTED
40008758: 81 e8 00 00 restore <== NOT EXECUTED
printf ("\n");
4000875c: 40 00 58 95 call 4001e9b0 <putchar> <== NOT EXECUTED
40008760: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
40008764: 30 bf fe b9 b,a 40008248 <rtems_rfs_format+0x840> <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
40008768: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
4000876c: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
40008770: 08 bf fc d1 bleu 40007ab4 <rtems_rfs_format+0xac> <== NOT EXECUTED
40008774: 01 00 00 00 nop <== NOT EXECUTED
fs->block_size = (4 * 1024);
40008778: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
4000877c: 10 bf fc ce b 40007ab4 <rtems_rfs_format+0xac> <== NOT EXECUTED
40008780: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40008784: 92 07 bf 48 add %fp, -184, %o1 <== NOT EXECUTED
40008788: 7f ff fb 6f call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
4000878c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
40008790: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40008794: c0 2f bf 48 clrb [ %fp + -184 ] <== NOT EXECUTED
handle->bnum = 0;
40008798: c0 27 bf 4c clr [ %fp + -180 ] <== NOT EXECUTED
4000879c: 40 00 5b 9c call 4001f60c <strerror> <== NOT EXECUTED
400087a0: c0 27 bf 50 clr [ %fp + -176 ] <== NOT EXECUTED
400087a4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400087a8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400087ac: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400087b0: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
400087b4: 7f ff e9 51 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400087b8: 90 12 20 80 or %o0, 0x80, %o0 ! 40022880 <IMFS_node_control_sym_link+0xaf8><== NOT EXECUTED
return false;
400087bc: 30 bf fe ee b,a 40008374 <rtems_rfs_format+0x96c> <== NOT EXECUTED
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
400087c0: 40 00 5b 93 call 4001f60c <strerror> <== NOT EXECUTED
400087c4: 01 00 00 00 nop <== NOT EXECUTED
400087c8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400087cc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400087d0: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
400087d4: 7f ff e9 49 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400087d8: 90 12 21 78 or %o0, 0x178, %o0 ! 40022978 <IMFS_node_control_sym_link+0xbf0><== NOT EXECUTED
rtems_rfs_fs_close (fs);
400087dc: 40 00 3d 68 call 40017d7c <rtems_rfs_fs_close> <== NOT EXECUTED
400087e0: d0 07 bf 44 ld [ %fp + -188 ], %o0 <== NOT EXECUTED
return rc;
400087e4: 30 bf ff c3 b,a 400086f0 <rtems_rfs_format+0xce8> <== NOT EXECUTED
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
400087e8: 40 00 5b 89 call 4001f60c <strerror> <== NOT EXECUTED
400087ec: 01 00 00 00 nop <== NOT EXECUTED
400087f0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400087f4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400087f8: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
400087fc: 7f ff e9 3f call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008800: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 400229e8 <IMFS_node_control_sym_link+0xc60><== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
40008804: d4 07 bf 48 ld [ %fp + -184 ], %o2 <== NOT EXECUTED
40008808: d0 07 bf 44 ld [ %fp + -188 ], %o0 <== NOT EXECUTED
4000880c: 40 00 01 a3 call 40008e98 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
40008810: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
rtems_rfs_fs_close (fs);
40008814: 40 00 3d 5a call 40017d7c <rtems_rfs_fs_close> <== NOT EXECUTED
40008818: d0 07 bf 44 ld [ %fp + -188 ], %o0 <== NOT EXECUTED
return rc;
4000881c: 30 bf ff b5 b,a 400086f0 <rtems_rfs_format+0xce8> <== NOT EXECUTED
rc = errno;
40008820: 40 00 56 bf call 4001e31c <__errno> <== NOT EXECUTED
40008824: 01 00 00 00 nop <== NOT EXECUTED
40008828: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
4000882c: 40 00 5b 78 call 4001f60c <strerror> <== NOT EXECUTED
40008830: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40008834: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40008838: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000883c: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008840: 7f ff e9 2e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008844: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40022ab8 <IMFS_node_control_sym_link+0xd30><== NOT EXECUTED
return rc;
40008848: 10 bf ff c1 b 4000874c <rtems_rfs_format+0xd44> <== NOT EXECUTED
4000884c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40008850: 40 00 5b 6f call 4001f60c <strerror> <== NOT EXECUTED
40008854: 01 00 00 00 nop <== NOT EXECUTED
40008858: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000885c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008860: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008864: 7f ff e9 25 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008868: 90 12 22 88 or %o0, 0x288, %o0 ! 40022a88 <IMFS_node_control_sym_link+0xd00><== NOT EXECUTED
4000886c: 30 bf fe ad b,a 40008320 <rtems_rfs_format+0x918> <== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40008870: 40 00 5b 67 call 4001f60c <strerror> <== NOT EXECUTED
40008874: 01 00 00 00 nop <== NOT EXECUTED
40008878: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000887c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008880: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008884: 7f ff e9 1d call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008888: 90 12 22 50 or %o0, 0x250, %o0 ! 40022a50 <IMFS_node_control_sym_link+0xcc8><== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4000888c: 10 bf fe a0 b 4000830c <rtems_rfs_format+0x904> <== NOT EXECUTED
40008890: d0 07 bf 44 ld [ %fp + -188 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
40008894: 40 00 5b 5e call 4001f60c <strerror> <== NOT EXECUTED
40008898: 01 00 00 00 nop <== NOT EXECUTED
4000889c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400088a0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400088a4: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
400088a8: 7f ff e9 14 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400088ac: 90 12 22 18 or %o0, 0x218, %o0 ! 40022a18 <IMFS_node_control_sym_link+0xc90><== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
400088b0: 10 bf fe 8d b 400082e4 <rtems_rfs_format+0x8dc> <== NOT EXECUTED
400088b4: d8 07 bf 48 ld [ %fp + -184 ], %o4 <== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
400088b8: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
400088bc: 7f ff e9 0f call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400088c0: 90 12 23 18 or %o0, 0x318, %o0 ! 40022318 <IMFS_node_control_sym_link+0x590><== NOT EXECUTED
errno = EINVAL;
400088c4: 40 00 56 96 call 4001e31c <__errno> <== NOT EXECUTED
400088c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400088cc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
400088d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
400088d4: 81 c7 e0 08 ret <== NOT EXECUTED
400088d8: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
400088dc: 40 00 5b 4c call 4001f60c <strerror> <== NOT EXECUTED
400088e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400088e4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400088e8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400088ec: 11 10 00 89 sethi %hi(0x40022400), %o0 <== NOT EXECUTED
400088f0: 7f ff e9 02 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400088f4: 90 12 21 90 or %o0, 0x190, %o0 ! 40022590 <IMFS_node_control_sym_link+0x808><== NOT EXECUTED
errno = rc;
400088f8: 40 00 56 89 call 4001e31c <__errno> <== NOT EXECUTED
400088fc: 01 00 00 00 nop <== NOT EXECUTED
40008900: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
return -1;
40008904: 81 c7 e0 08 ret <== NOT EXECUTED
40008908: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
4000890c: 40 00 5b 40 call 4001f60c <strerror> <== NOT EXECUTED
40008910: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40008914: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40008918: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000891c: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008920: 7f ff e8 f6 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008924: 90 12 21 10 or %o0, 0x110, %o0 ! 40022910 <IMFS_node_control_sym_link+0xb88><== NOT EXECUTED
errno = rc;
40008928: 40 00 56 7d call 4001e31c <__errno> <== NOT EXECUTED
4000892c: 01 00 00 00 nop <== NOT EXECUTED
40008930: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
40008934: 81 c7 e0 08 ret <== NOT EXECUTED
40008938: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
4000893c: 40 00 5b 34 call 4001f60c <strerror> <== NOT EXECUTED
40008940: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40008944: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40008948: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000894c: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED
40008950: 7f ff e8 ea call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008954: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 400222e8 <IMFS_node_control_sym_link+0x560><== NOT EXECUTED
errno = rc;
40008958: 40 00 56 71 call 4001e31c <__errno> <== NOT EXECUTED
4000895c: 01 00 00 00 nop <== NOT EXECUTED
40008960: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
40008964: 81 c7 e0 08 ret <== NOT EXECUTED
40008968: 81 e8 00 00 restore <== NOT EXECUTED
40017d7c <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
40017d7c: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
40017d80: 90 10 20 00 clr %o0
40017d84: 92 10 20 02 mov 2, %o1
40017d88: 7f ff cb 8f call 4000abc4 <rtems_rfs_trace>
40017d8c: ba 10 00 18 mov %i0, %i5
40017d90: 80 a2 20 00 cmp %o0, 0
40017d94: 12 80 00 18 bne 40017df4 <rtems_rfs_fs_close+0x78> <== NEVER TAKEN
40017d98: 11 10 00 91 sethi %hi(0x40024400), %o0
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
40017d9c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40017da0: 80 a0 60 00 cmp %g1, 0
40017da4: 04 80 00 0d ble 40017dd8 <rtems_rfs_fs_close+0x5c> <== NEVER TAKEN
40017da8: 01 00 00 00 nop
40017dac: b6 10 20 00 clr %i3 ! 0 <PROM_START>
40017db0: b8 10 20 00 clr %i4
rtems_rfs_group_close (fs, &fs->groups[group]);
40017db4: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
40017db8: 92 02 40 1b add %o1, %i3, %o1
40017dbc: 7f ff c3 78 call 40008b9c <rtems_rfs_group_close>
40017dc0: 90 10 00 1d mov %i5, %o0
for (group = 0; group < fs->group_count; group++)
40017dc4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40017dc8: b8 07 20 01 inc %i4
40017dcc: 80 a0 40 1c cmp %g1, %i4
40017dd0: 14 bf ff f9 bg 40017db4 <rtems_rfs_fs_close+0x38> <== NEVER TAKEN
40017dd4: b6 06 e0 50 add %i3, 0x50, %i3
rtems_rfs_buffer_close (fs);
40017dd8: 7f ff be d2 call 40007920 <rtems_rfs_buffer_close>
40017ddc: 90 10 00 1d mov %i5, %o0
free (fs);
return 0;
}
40017de0: b0 10 20 00 clr %i0
free (fs);
40017de4: 7f ff ac 87 call 40003000 <free>
40017de8: 90 10 00 1d mov %i5, %o0
}
40017dec: 81 c7 e0 08 ret
40017df0: 81 e8 00 00 restore
printf ("rtems-rfs: close\n");
40017df4: 7f ff ab cf call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017df8: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
40017dfc: 10 bf ff e9 b 40017da0 <rtems_rfs_fs_close+0x24> <== NOT EXECUTED
40017e00: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40017534 <rtems_rfs_fs_open>:
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
uint32_t max_held_buffers,
rtems_rfs_file_system** fs)
{
40017534: 9d e3 bf 78 save %sp, -136, %sp
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017538: 90 10 20 00 clr %o0
4001753c: 7f ff cd a2 call 4000abc4 <rtems_rfs_trace>
40017540: 92 10 20 01 mov 1, %o1
40017544: 80 a2 20 00 cmp %o0, 0
40017548: 12 80 01 02 bne 40017950 <rtems_rfs_fs_open+0x41c> <== NEVER TAKEN
4001754c: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
40017550: 7f ff ae f2 call 40003118 <malloc>
40017554: 90 10 20 84 mov 0x84, %o0
40017558: d0 27 00 00 st %o0, [ %i4 ]
if (!*fs)
4001755c: 80 a2 20 00 cmp %o0, 0
40017560: 02 80 01 e8 be 40017d00 <rtems_rfs_fs_open+0x7cc> <== NEVER TAKEN
40017564: ba 10 00 08 mov %o0, %i5
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
40017568: 94 10 20 80 mov 0x80, %o2
4001756c: 92 10 20 00 clr %o1
40017570: 40 00 1c cb call 4001e89c <memset>
40017574: 90 02 20 04 add %o0, 4, %o0
return &the_chain->Tail.Node;
40017578: 84 07 60 44 add %i5, 0x44, %g2
4001757c: 82 07 60 48 add %i5, 0x48, %g1
tail->previous = head;
40017580: c4 27 60 4c st %g2, [ %i5 + 0x4c ]
return &the_chain->Tail.Node;
40017584: 84 07 60 54 add %i5, 0x54, %g2
head->next = tail;
40017588: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
return &the_chain->Tail.Node;
4001758c: 82 07 60 58 add %i5, 0x58, %g1
tail->previous = head;
40017590: c4 27 60 5c st %g2, [ %i5 + 0x5c ]
return &the_chain->Tail.Node;
40017594: 84 07 60 64 add %i5, 0x64, %g2
head->next = tail;
40017598: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
return &the_chain->Tail.Node;
4001759c: 82 07 60 68 add %i5, 0x68, %g1
tail->previous = head;
400175a0: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
return &the_chain->Tail.Node;
400175a4: 84 07 60 74 add %i5, 0x74, %g2
head->next = tail;
400175a8: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
return &the_chain->Tail.Node;
400175ac: 82 07 60 78 add %i5, 0x78, %g1
(*fs)->user = user;
400175b0: f2 27 60 80 st %i1, [ %i5 + 0x80 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
400175b4: 92 10 00 1d mov %i5, %o1
(*fs)->max_held_buffers = max_held_buffers;
400175b8: f6 27 60 40 st %i3, [ %i5 + 0x40 ]
rc = rtems_rfs_buffer_open (name, *fs);
400175bc: 90 10 00 18 mov %i0, %o0
tail->previous = head;
400175c0: c4 27 60 7c st %g2, [ %i5 + 0x7c ]
head->next = tail;
400175c4: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
400175c8: 7f ff bf e8 call 40007568 <rtems_rfs_buffer_open>
400175cc: f4 27 40 00 st %i2, [ %i5 ]
if (rc > 0)
400175d0: ba 92 20 00 orcc %o0, 0, %i5
400175d4: 14 80 01 7d bg 40017bc8 <rtems_rfs_fs_open+0x694> <== NEVER TAKEN
400175d8: 96 10 20 01 mov 1, %o3
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
400175dc: fa 07 00 00 ld [ %i4 ], %i5
handle->dirty = false;
400175e0: c0 2f bf d8 clrb [ %fp + -40 ]
handle->bnum = 0;
400175e4: c0 27 bf dc clr [ %fp + -36 ]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
400175e8: 94 10 20 00 clr %o2
handle->buffer = NULL;
400175ec: c0 27 bf e0 clr [ %fp + -32 ]
400175f0: 92 07 bf d8 add %fp, -40, %o1
400175f4: 7f ff bf 0b call 40007220 <rtems_rfs_buffer_handle_request>
400175f8: 90 10 00 1d mov %i5, %o0
if (rc > 0)
400175fc: b6 92 20 00 orcc %o0, 0, %i3
40017600: 14 80 00 d8 bg 40017960 <rtems_rfs_fs_open+0x42c> <== NEVER TAKEN
40017604: c2 07 bf e0 ld [ %fp + -32 ], %g1
sb = rtems_rfs_buffer_data (&handle);
40017608: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
4001760c: c8 0e c0 00 ldub [ %i3 ], %g4
40017610: c4 0e e0 01 ldub [ %i3 + 1 ], %g2
40017614: c2 0e e0 02 ldub [ %i3 + 2 ], %g1
40017618: c6 0e e0 03 ldub [ %i3 + 3 ], %g3
4001761c: 89 29 20 18 sll %g4, 0x18, %g4
40017620: 85 28 a0 10 sll %g2, 0x10, %g2
40017624: 84 10 80 04 or %g2, %g4, %g2
40017628: 83 28 60 08 sll %g1, 8, %g1
4001762c: 82 10 40 02 or %g1, %g2, %g1
40017630: 05 0a 02 48 sethi %hi(0x28092000), %g2
40017634: 82 10 c0 01 or %g3, %g1, %g1
40017638: 84 10 a0 01 or %g2, 1, %g2
4001763c: 80 a0 40 02 cmp %g1, %g2
40017640: 32 80 01 2b bne,a 40017aec <rtems_rfs_fs_open+0x5b8> <== NEVER TAKEN
40017644: 90 10 20 00 clr %o0 <== NOT EXECUTED
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
40017648: c8 0e e0 0c ldub [ %i3 + 0xc ], %g4
4001764c: c6 0e e0 0d ldub [ %i3 + 0xd ], %g3
40017650: c2 0e e0 0e ldub [ %i3 + 0xe ], %g1
40017654: c4 0e e0 0f ldub [ %i3 + 0xf ], %g2
40017658: 89 29 20 18 sll %g4, 0x18, %g4
4001765c: 87 28 e0 10 sll %g3, 0x10, %g3
40017660: 83 28 60 08 sll %g1, 8, %g1
40017664: 86 10 c0 04 or %g3, %g4, %g3
40017668: 82 10 40 03 or %g1, %g3, %g1
4001766c: 84 10 80 01 or %g2, %g1, %g2
40017670: c4 27 60 04 st %g2, [ %i5 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
40017674: f2 0e e0 0b ldub [ %i3 + 0xb ], %i1
40017678: c8 0e e0 08 ldub [ %i3 + 8 ], %g4
4001767c: c6 0e e0 09 ldub [ %i3 + 9 ], %g3
40017680: c2 0e e0 0a ldub [ %i3 + 0xa ], %g1
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
40017684: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
40017688: 89 29 20 18 sll %g4, 0x18, %g4
4001768c: 87 28 e0 10 sll %g3, 0x10, %g3
40017690: 83 28 60 08 sll %g1, 8, %g1
40017694: 86 10 c0 04 or %g3, %g4, %g3
40017698: 82 10 40 03 or %g1, %g3, %g1
4001769c: 82 16 40 01 or %i1, %g1, %g1
400176a0: c2 27 60 08 st %g1, [ %i5 + 8 ]
return blocks * block_size;
400176a4: 86 50 80 01 umul %g2, %g1, %g3
400176a8: 85 40 00 00 rd %y, %g2
return media_blocks * media_block_size;
400176ac: f0 06 a0 1c ld [ %i2 + 0x1c ], %i0
400176b0: c8 06 a0 20 ld [ %i2 + 0x20 ], %g4
400176b4: b2 56 00 04 umul %i0, %g4, %i1
400176b8: b1 40 00 00 rd %y, %i0
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
400176bc: 80 a0 80 18 cmp %g2, %i0
400176c0: 38 80 00 df bgu,a 40017a3c <rtems_rfs_fs_open+0x508> <== NEVER TAKEN
400176c4: 90 10 20 00 clr %o0 <== NOT EXECUTED
400176c8: 02 80 00 da be 40017a30 <rtems_rfs_fs_open+0x4fc> <== ALWAYS TAKEN
400176cc: 80 a0 c0 19 cmp %g3, %i1
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
400176d0: f4 0e e0 24 ldub [ %i3 + 0x24 ], %i2 <== NOT EXECUTED
400176d4: c6 0e e0 25 ldub [ %i3 + 0x25 ], %g3
400176d8: c4 0e e0 26 ldub [ %i3 + 0x26 ], %g2
400176dc: c8 0e e0 27 ldub [ %i3 + 0x27 ], %g4
400176e0: b5 2e a0 18 sll %i2, 0x18, %i2
400176e4: 87 28 e0 10 sll %g3, 0x10, %g3
400176e8: 85 28 a0 08 sll %g2, 8, %g2
400176ec: 86 10 c0 1a or %g3, %i2, %g3
400176f0: 84 10 80 03 or %g2, %g3, %g2
400176f4: 84 11 00 02 or %g4, %g2, %g2
400176f8: 80 a0 a0 38 cmp %g2, 0x38
400176fc: 12 80 00 c2 bne 40017a04 <rtems_rfs_fs_open+0x4d0> <== NEVER TAKEN
40017700: 90 10 00 1d mov %i5, %o0
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
40017704: c8 0e e0 13 ldub [ %i3 + 0x13 ], %g4
40017708: f4 0e e0 10 ldub [ %i3 + 0x10 ], %i2
4001770c: c6 0e e0 11 ldub [ %i3 + 0x11 ], %g3
40017710: c4 0e e0 12 ldub [ %i3 + 0x12 ], %g2
40017714: b5 2e a0 18 sll %i2, 0x18, %i2
40017718: 87 28 e0 10 sll %g3, 0x10, %g3
4001771c: 85 28 a0 08 sll %g2, 8, %g2
40017720: 86 10 c0 1a or %g3, %i2, %g3
40017724: 84 10 80 03 or %g2, %g3, %g2
40017728: 84 11 00 02 or %g4, %g2, %g2
4001772c: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
40017730: 85 30 60 02 srl %g1, 2, %g2
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
40017734: f4 0e e0 17 ldub [ %i3 + 0x17 ], %i2
40017738: f2 0e e0 14 ldub [ %i3 + 0x14 ], %i1
4001773c: c8 0e e0 15 ldub [ %i3 + 0x15 ], %g4
40017740: c6 0e e0 16 ldub [ %i3 + 0x16 ], %g3
40017744: b3 2e 60 18 sll %i1, 0x18, %i1
40017748: 89 29 20 10 sll %g4, 0x10, %g4
4001774c: 87 28 e0 08 sll %g3, 8, %g3
40017750: 88 11 00 19 or %g4, %i1, %g4
40017754: 86 10 c0 04 or %g3, %g4, %g3
40017758: 86 16 80 03 or %i2, %g3, %g3
4001775c: c6 27 60 1c st %g3, [ %i5 + 0x1c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40017760: b4 58 80 02 smul %g2, %g2, %i2
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
40017764: f0 0e e0 18 ldub [ %i3 + 0x18 ], %i0
40017768: c8 0e e0 19 ldub [ %i3 + 0x19 ], %g4
4001776c: c6 0e e0 1a ldub [ %i3 + 0x1a ], %g3
40017770: f2 0e e0 1b ldub [ %i3 + 0x1b ], %i1
40017774: b1 2e 20 18 sll %i0, 0x18, %i0
40017778: 89 29 20 10 sll %g4, 0x10, %g4
4001777c: 87 28 e0 08 sll %g3, 8, %g3
40017780: 88 11 00 18 or %g4, %i0, %g4
40017784: 86 10 c0 04 or %g3, %g4, %g3
40017788: b2 16 40 03 or %i1, %g3, %i1
4001778c: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40017790: 9b 28 a0 02 sll %g2, 2, %o5
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
40017794: de 0e e0 1c ldub [ %i3 + 0x1c ], %o7
40017798: c8 0e e0 1d ldub [ %i3 + 0x1d ], %g4
4001779c: c6 0e e0 1e ldub [ %i3 + 0x1e ], %g3
400177a0: f0 0e e0 1f ldub [ %i3 + 0x1f ], %i0
400177a4: 9f 2b e0 18 sll %o7, 0x18, %o7
400177a8: 89 29 20 10 sll %g4, 0x10, %g4
400177ac: 87 28 e0 08 sll %g3, 8, %g3
400177b0: 88 11 00 0f or %g4, %o7, %g4
400177b4: 86 10 c0 04 or %g3, %g4, %g3
400177b8: b0 16 00 03 or %i0, %g3, %i0
400177bc: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
400177c0: 9a 03 40 02 add %o5, %g2, %o5
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
400177c4: de 0e e0 20 ldub [ %i3 + 0x20 ], %o7
400177c8: c8 0e e0 21 ldub [ %i3 + 0x21 ], %g4
400177cc: c6 0e e0 22 ldub [ %i3 + 0x22 ], %g3
400177d0: 9f 2b e0 18 sll %o7, 0x18, %o7
400177d4: f6 0e e0 23 ldub [ %i3 + 0x23 ], %i3
400177d8: 89 29 20 10 sll %g4, 0x10, %g4
400177dc: 88 11 00 0f or %g4, %o7, %g4
fs->blocks_per_block =
400177e0: c4 27 60 34 st %g2, [ %i5 + 0x34 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
400177e4: 87 28 e0 08 sll %g3, 8, %g3
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
400177e8: 9f 2e a0 02 sll %i2, 2, %o7
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
400177ec: 86 10 c0 04 or %g3, %g4, %g3
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
400177f0: b4 03 c0 1a add %o7, %i2, %i2
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
400177f4: 86 16 c0 03 or %i3, %g3, %g3
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
400177f8: 05 09 24 92 sethi %hi(0x24924800), %g2
400177fc: b7 30 60 03 srl %g1, 3, %i3
fs->inodes = fs->group_count * fs->group_inodes;
40017800: 88 5e 40 03 smul %i1, %g3, %g4
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
40017804: 84 10 a1 25 or %g2, 0x125, %g2
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
40017808: c6 27 60 2c st %g3, [ %i5 + 0x2c ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001780c: 80 56 c0 02 umul %i3, %g2, %g0
40017810: 85 40 00 00 rd %y, %g2
fs->block_map_singly_blocks =
40017814: da 27 60 38 st %o5, [ %i5 + 0x38 ]
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
40017818: 83 28 60 03 sll %g1, 3, %g1
fs->block_map_doubly_blocks =
4001781c: f4 27 60 3c st %i2, [ %i5 + 0x3c ]
rtems_rfs_buffer_handle_release (fs, handle);
40017820: 92 07 bf d8 add %fp, -40, %o1
fs->inodes = fs->group_count * fs->group_inodes;
40017824: c8 27 60 14 st %g4, [ %i5 + 0x14 ]
if (fs->group_blocks >
40017828: 80 a6 00 01 cmp %i0, %g1
4001782c: 18 80 00 ba bgu 40017b14 <rtems_rfs_fs_open+0x5e0> <== NEVER TAKEN
40017830: c4 27 60 30 st %g2, [ %i5 + 0x30 ]
40017834: 7f ff bf 44 call 40007544 <rtems_rfs_buffer_handle_release>
40017838: 01 00 00 00 nop
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
4001783c: d2 07 60 08 ld [ %i5 + 8 ], %o1
40017840: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
40017844: c0 2f bf d8 clrb [ %fp + -40 ]
handle->bnum = 0;
40017848: c0 27 bf dc clr [ %fp + -36 ]
4001784c: 7f ff bf f4 call 4000781c <rtems_rfs_buffer_setblksize>
40017850: c0 27 bf e0 clr [ %fp + -32 ]
if (rc > 0)
40017854: b6 92 20 00 orcc %o0, 0, %i3
40017858: 14 80 00 50 bg 40017998 <rtems_rfs_fs_open+0x464> <== NEVER TAKEN
4001785c: 92 10 20 50 mov 0x50, %o1
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
40017860: f6 07 60 24 ld [ %i5 + 0x24 ], %i3
40017864: 7f ff ec db call 40012bd0 <calloc>
40017868: 90 10 00 1b mov %i3, %o0
4001786c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
if (!fs->groups)
40017870: 80 a2 20 00 cmp %o0, 0
40017874: 02 80 01 32 be 40017d3c <rtems_rfs_fs_open+0x808> <== NEVER TAKEN
40017878: 98 10 00 08 mov %o0, %o4
for (group = 0; group < fs->group_count; group++)
4001787c: b2 10 20 00 clr %i1
40017880: 80 a6 e0 00 cmp %i3, 0
40017884: 14 80 00 09 bg 400178a8 <rtems_rfs_fs_open+0x374> <== ALWAYS TAKEN
40017888: b4 10 20 00 clr %i2
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001788c: 10 80 00 77 b 40017a68 <rtems_rfs_fs_open+0x534> <== NOT EXECUTED
40017890: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
40017894: b4 06 a0 01 inc %i2
40017898: 80 a6 80 01 cmp %i2, %g1
4001789c: 16 80 00 72 bge 40017a64 <rtems_rfs_fs_open+0x530> <== ALWAYS TAKEN
400178a0: b2 06 60 50 add %i1, 0x50, %i1
&fs->groups[group]);
400178a4: d8 07 60 20 ld [ %i5 + 0x20 ], %o4 <== NOT EXECUTED
rtems_rfs_fs_block (fs, group, 0),
400178a8: d4 07 60 28 ld [ %i5 + 0x28 ], %o2
rc = rtems_rfs_group_open (fs,
400178ac: d6 07 60 2c ld [ %i5 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
400178b0: 92 5e 80 0a smul %i2, %o2, %o1
rc = rtems_rfs_group_open (fs,
400178b4: 98 03 00 19 add %o4, %i1, %o4
400178b8: 92 02 60 01 inc %o1
400178bc: 7f ff c4 2c call 4000896c <rtems_rfs_group_open>
400178c0: 90 10 00 1d mov %i5, %o0
if (rc > 0)
400178c4: b6 92 20 00 orcc %o0, 0, %i3
400178c8: 24 bf ff f3 ble,a 40017894 <rtems_rfs_fs_open+0x360> <== ALWAYS TAKEN
400178cc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
for (g = 0; g < group; g++)
400178d0: b0 10 20 00 clr %i0 <== NOT EXECUTED
400178d4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400178d8: 02 80 00 0a be 40017900 <rtems_rfs_fs_open+0x3cc> <== NOT EXECUTED
400178dc: b2 10 20 00 clr %i1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
400178e0: d2 07 60 20 ld [ %i5 + 0x20 ], %o1 <== NOT EXECUTED
400178e4: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
400178e8: 7f ff c4 ad call 40008b9c <rtems_rfs_group_close> <== NOT EXECUTED
400178ec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
for (g = 0; g < group; g++)
400178f0: b2 06 60 01 inc %i1 <== NOT EXECUTED
400178f4: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
400178f8: 12 bf ff fa bne 400178e0 <rtems_rfs_fs_open+0x3ac> <== NOT EXECUTED
400178fc: b0 06 20 50 add %i0, 0x50, %i0 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40017900: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40017904: 7f ff bf 10 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40017908: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001790c: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40017910: c0 2f bf d8 clrb [ %fp + -40 ] <== NOT EXECUTED
40017914: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->bnum = 0;
40017918: c0 27 bf dc clr [ %fp + -36 ] <== NOT EXECUTED
4001791c: 7f ff cc aa call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017920: c0 27 bf e0 clr [ %fp + -32 ] <== NOT EXECUTED
40017924: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017928: 02 80 00 28 be 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
4001792c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
40017930: 40 00 1f 37 call 4001f60c <strerror> <== NOT EXECUTED
40017934: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40017938: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001793c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017940: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017944: 7f ff ac ed call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017948: 90 12 23 28 or %o0, 0x328, %o0 ! 40024328 <IMFS_LIMITS_AND_OPTIONS+0xde8><== NOT EXECUTED
4001794c: 30 80 00 1f b,a 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
40017950: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017954: 7f ff ac e9 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017958: 90 12 20 e8 or %o0, 0xe8, %o0 ! 400240e8 <IMFS_LIMITS_AND_OPTIONS+0xba8><== NOT EXECUTED
4001795c: 30 bf fe fd b,a 40017550 <rtems_rfs_fs_open+0x1c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017960: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017964: 7f ff cc 98 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017968: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001796c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017970: 02 80 00 16 be 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
40017974: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
40017978: 40 00 1f 25 call 4001f60c <strerror> <== NOT EXECUTED
4001797c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40017980: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40017984: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017988: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
4001798c: 7f ff ac db call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017990: 90 12 21 60 or %o0, 0x160, %o0 ! 40024160 <IMFS_LIMITS_AND_OPTIONS+0xc20><== NOT EXECUTED
40017994: 30 80 00 0d b,a 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40017998: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001799c: 7f ff be ea call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
400179a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400179a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
400179a8: c0 2f bf d8 clrb [ %fp + -40 ] <== NOT EXECUTED
400179ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->bnum = 0;
400179b0: c0 27 bf dc clr [ %fp + -36 ] <== NOT EXECUTED
400179b4: 7f ff cc 84 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400179b8: c0 27 bf e0 clr [ %fp + -32 ] <== NOT EXECUTED
400179bc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400179c0: 12 80 00 6b bne 40017b6c <rtems_rfs_fs_open+0x638> <== NOT EXECUTED
400179c4: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
400179c8: 7f ff bf d6 call 40007920 <rtems_rfs_buffer_close> <== NOT EXECUTED
400179cc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
400179d0: 7f ff ad 8c call 40003000 <free> <== NOT EXECUTED
400179d4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400179d8: 90 10 20 00 clr %o0 <== NOT EXECUTED
400179dc: 7f ff cc 7a call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400179e0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
400179e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400179e8: 12 80 00 59 bne 40017b4c <rtems_rfs_fs_open+0x618> <== NOT EXECUTED
400179ec: 01 00 00 00 nop <== NOT EXECUTED
errno = rc;
400179f0: 40 00 1a 4b call 4001e31c <__errno> <== NOT EXECUTED
400179f4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff> <== NOT EXECUTED
400179f8: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
return -1;
400179fc: 81 c7 e0 08 ret <== NOT EXECUTED
40017a00: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017a04: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017a08: 7f ff cc 6f call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017a0c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017a10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017a14: 32 80 00 5e bne,a 40017b8c <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
40017a18: c6 0e e0 04 ldub [ %i3 + 4 ], %g3 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40017a1c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40017a20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40017a24: 7f ff be c8 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40017a28: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED
if (rc > 0)
40017a2c: 30 bf ff e7 b,a 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
40017a30: 28 bf ff 29 bleu,a 400176d4 <rtems_rfs_fs_open+0x1a0> <== ALWAYS TAKEN
40017a34: f4 0e e0 24 ldub [ %i3 + 0x24 ], %i2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017a38: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017a3c: 7f ff cc 62 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017a40: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017a44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017a48: 22 bf ff f6 be,a 40017a20 <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
40017a4c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
40017a50: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017a54: 7f ff ac b7 call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017a58: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400241d8 <IMFS_LIMITS_AND_OPTIONS+0xc98><== NOT EXECUTED
40017a5c: 10 bf ff f1 b 40017a20 <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
40017a60: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
40017a64: d0 07 00 00 ld [ %i4 ], %o0
40017a68: 96 10 20 01 mov 1, %o3
40017a6c: 94 07 bf d8 add %fp, -40, %o2
40017a70: 7f ff c5 a8 call 40009110 <rtems_rfs_inode_open>
40017a74: 92 10 20 01 mov 1, %o1
if (rc > 0)
40017a78: ba 92 20 00 orcc %o0, 0, %i5
40017a7c: 14 80 00 72 bg 40017c44 <rtems_rfs_fs_open+0x710> <== NEVER TAKEN
40017a80: 01 00 00 00 nop
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
40017a84: d0 07 00 00 ld [ %i4 ], %o0
40017a88: c2 02 00 00 ld [ %o0 ], %g1
40017a8c: 80 88 60 04 btst 4, %g1
40017a90: 12 80 00 0f bne 40017acc <rtems_rfs_fs_open+0x598>
40017a94: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_read_u16 (&handle->node->mode);
40017a98: c4 08 60 02 ldub [ %g1 + 2 ], %g2
40017a9c: 85 28 a0 08 sll %g2, 8, %g2
40017aa0: c2 08 60 03 ldub [ %g1 + 3 ], %g1
40017aa4: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
40017aa8: 05 00 00 3f sethi %hi(0xfc00), %g2
40017aac: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_ISR_Stack_size+0xefff>
40017ab0: 80 a0 40 02 cmp %g1, %g2
40017ab4: 02 80 00 52 be 40017bfc <rtems_rfs_fs_open+0x6c8> <== NEVER TAKEN
40017ab8: 82 08 70 00 and %g1, -4096, %g1
40017abc: 05 00 00 10 sethi %hi(0x4000), %g2
40017ac0: 80 a0 40 02 cmp %g1, %g2
40017ac4: 12 80 00 4e bne 40017bfc <rtems_rfs_fs_open+0x6c8> <== NEVER TAKEN
40017ac8: 01 00 00 00 nop
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
40017acc: 92 07 bf d8 add %fp, -40, %o1
40017ad0: 7f ff c6 09 call 400092f4 <rtems_rfs_inode_close>
40017ad4: b0 10 20 00 clr %i0
if (rc > 0)
40017ad8: ba 92 20 00 orcc %o0, 0, %i5
40017adc: 14 80 00 6c bg 40017c8c <rtems_rfs_fs_open+0x758> <== NEVER TAKEN
40017ae0: 01 00 00 00 nop
errno = rc;
return -1;
}
return 0;
}
40017ae4: 81 c7 e0 08 ret
40017ae8: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017aec: 7f ff cc 36 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017af0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017af4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017af8: 22 bf ff ca be,a 40017a20 <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
40017afc: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
40017b00: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017b04: 7f ff ac 8b call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017b08: 90 12 21 98 or %o0, 0x198, %o0 ! 40024198 <IMFS_LIMITS_AND_OPTIONS+0xc58><== NOT EXECUTED
40017b0c: 10 bf ff c5 b 40017a20 <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
40017b10: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40017b14: 7f ff be 8c call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40017b18: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017b1c: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40017b20: c0 2f bf d8 clrb [ %fp + -40 ] <== NOT EXECUTED
40017b24: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->bnum = 0;
40017b28: c0 27 bf dc clr [ %fp + -36 ] <== NOT EXECUTED
40017b2c: 7f ff cc 26 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017b30: c0 27 bf e0 clr [ %fp + -32 ] <== NOT EXECUTED
40017b34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017b38: 02 bf ff a4 be 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
40017b3c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
40017b40: 7f ff ac 7c call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017b44: 90 12 22 60 or %o0, 0x260, %o0 ! 40024260 <IMFS_LIMITS_AND_OPTIONS+0xd20><== NOT EXECUTED
if (rc > 0)
40017b48: 30 bf ff a0 b,a 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
40017b4c: 40 00 1e b0 call 4001f60c <strerror> <== NOT EXECUTED
40017b50: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40017b54: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40017b58: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017b5c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017b60: 7f ff ac 66 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017b64: 90 12 23 68 or %o0, 0x368, %o0 ! 40024368 <IMFS_LIMITS_AND_OPTIONS+0xe28><== NOT EXECUTED
40017b68: 30 bf ff a2 b,a 400179f0 <rtems_rfs_fs_open+0x4bc> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
40017b6c: 40 00 1e a8 call 4001f60c <strerror> <== NOT EXECUTED
40017b70: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40017b74: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40017b78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017b7c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017b80: 7f ff ac 5e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017b84: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 400242a8 <IMFS_LIMITS_AND_OPTIONS+0xd68><== NOT EXECUTED
40017b88: 30 bf ff 90 b,a 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
40017b8c: c4 0e e0 05 ldub [ %i3 + 5 ], %g2 <== NOT EXECUTED
40017b90: c2 0e e0 06 ldub [ %i3 + 6 ], %g1 <== NOT EXECUTED
40017b94: d2 0e e0 07 ldub [ %i3 + 7 ], %o1 <== NOT EXECUTED
40017b98: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
40017b9c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
40017ba0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
40017ba4: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
40017ba8: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
40017bac: 94 10 20 00 clr %o2 <== NOT EXECUTED
40017bb0: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
40017bb4: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017bb8: 7f ff ac 50 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017bbc: 90 12 22 18 or %o0, 0x218, %o0 ! 40024218 <IMFS_LIMITS_AND_OPTIONS+0xcd8><== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40017bc0: 10 bf ff 98 b 40017a20 <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
40017bc4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
free (*fs);
40017bc8: 7f ff ad 0e call 40003000 <free> <== NOT EXECUTED
40017bcc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017bd0: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017bd4: 7f ff cb fc call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017bd8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017bdc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017be0: 12 80 00 3d bne 40017cd4 <rtems_rfs_fs_open+0x7a0> <== NOT EXECUTED
40017be4: 01 00 00 00 nop <== NOT EXECUTED
errno = rc;
40017be8: 40 00 19 cd call 4001e31c <__errno> <== NOT EXECUTED
40017bec: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff> <== NOT EXECUTED
40017bf0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
40017bf4: 81 c7 e0 08 ret <== NOT EXECUTED
40017bf8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
40017bfc: 7f ff c5 be call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40017c00: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
40017c04: 7f ff bf 47 call 40007920 <rtems_rfs_buffer_close> <== NOT EXECUTED
40017c08: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40017c0c: 7f ff ac fd call 40003000 <free> <== NOT EXECUTED
40017c10: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017c14: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017c18: 7f ff cb eb call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017c1c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017c20: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017c24: 12 80 00 34 bne 40017cf4 <rtems_rfs_fs_open+0x7c0> <== NOT EXECUTED
40017c28: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
errno = EIO;
40017c2c: 40 00 19 bc call 4001e31c <__errno> <== NOT EXECUTED
40017c30: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017c34: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40017c38: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40017c3c: 81 c7 e0 08 ret <== NOT EXECUTED
40017c40: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
40017c44: 7f ff bf 37 call 40007920 <rtems_rfs_buffer_close> <== NOT EXECUTED
40017c48: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40017c4c: 7f ff ac ed call 40003000 <free> <== NOT EXECUTED
40017c50: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017c54: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017c58: 7f ff cb db call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017c5c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017c60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017c64: 02 bf ff e1 be 40017be8 <rtems_rfs_fs_open+0x6b4> <== NOT EXECUTED
40017c68: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
40017c6c: 40 00 1e 68 call 4001f60c <strerror> <== NOT EXECUTED
40017c70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40017c74: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40017c78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017c7c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017c80: 7f ff ac 1e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017c84: 90 12 23 98 or %o0, 0x398, %o0 ! 40024398 <IMFS_LIMITS_AND_OPTIONS+0xe58><== NOT EXECUTED
40017c88: 30 bf ff d8 b,a 40017be8 <rtems_rfs_fs_open+0x6b4> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
40017c8c: 7f ff bf 25 call 40007920 <rtems_rfs_buffer_close> <== NOT EXECUTED
40017c90: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40017c94: 7f ff ac db call 40003000 <free> <== NOT EXECUTED
40017c98: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017c9c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017ca0: 7f ff cb c9 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017ca4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017ca8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017cac: 02 bf ff cf be 40017be8 <rtems_rfs_fs_open+0x6b4> <== NOT EXECUTED
40017cb0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
40017cb4: 40 00 1e 56 call 4001f60c <strerror> <== NOT EXECUTED
40017cb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40017cbc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40017cc0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017cc4: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017cc8: 7f ff ac 0c call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017ccc: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 400243f8 <IMFS_LIMITS_AND_OPTIONS+0xeb8><== NOT EXECUTED
40017cd0: 30 bf ff c6 b,a 40017be8 <rtems_rfs_fs_open+0x6b4> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
40017cd4: 40 00 1e 4e call 4001f60c <strerror> <== NOT EXECUTED
40017cd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40017cdc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40017ce0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40017ce4: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
40017ce8: 7f ff ac 04 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017cec: 90 12 21 30 or %o0, 0x130, %o0 ! 40024130 <IMFS_LIMITS_AND_OPTIONS+0xbf0><== NOT EXECUTED
40017cf0: 30 bf ff be b,a 40017be8 <rtems_rfs_fs_open+0x6b4> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
40017cf4: 7f ff ac 0f call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017cf8: 90 12 23 c8 or %o0, 0x3c8, %o0 <== NOT EXECUTED
40017cfc: 30 bf ff cc b,a 40017c2c <rtems_rfs_fs_open+0x6f8> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017d00: 90 10 20 00 clr %o0 <== NOT EXECUTED
40017d04: 7f ff cb b0 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017d08: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40017d0c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017d10: 12 80 00 08 bne 40017d30 <rtems_rfs_fs_open+0x7fc> <== NOT EXECUTED
40017d14: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
errno = ENOMEM;
40017d18: 40 00 19 81 call 4001e31c <__errno> <== NOT EXECUTED
40017d1c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017d20: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40017d24: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40017d28: 81 c7 e0 08 ret <== NOT EXECUTED
40017d2c: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
40017d30: 7f ff ac 00 call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017d34: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
40017d38: 30 bf ff f8 b,a 40017d18 <rtems_rfs_fs_open+0x7e4> <== NOT EXECUTED
40017d3c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40017d40: 7f ff be 01 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40017d44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017d48: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
40017d4c: c0 2f bf d8 clrb [ %fp + -40 ] <== NOT EXECUTED
40017d50: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->bnum = 0;
40017d54: c0 27 bf dc clr [ %fp + -36 ] <== NOT EXECUTED
return ENOMEM;
40017d58: b6 10 20 0c mov 0xc, %i3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40017d5c: 7f ff cb 9a call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40017d60: c0 27 bf e0 clr [ %fp + -32 ] <== NOT EXECUTED
40017d64: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40017d68: 02 bf ff 18 be 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
40017d6c: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
40017d70: 7f ff ab f0 call 40002d30 <__wrap_puts> <== NOT EXECUTED
40017d74: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 400242f0 <IMFS_LIMITS_AND_OPTIONS+0xdb0><== NOT EXECUTED
if (rc > 0)
40017d78: 30 bf ff 14 b,a 400179c8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
40017500 <rtems_rfs_fs_size>:
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
40017500: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
40017504: d0 02 20 08 ld [ %o0 + 8 ], %o0 <== NOT EXECUTED
}
40017508: 92 50 80 08 umul %g2, %o0, %o1 <== NOT EXECUTED
4001750c: 91 40 00 00 rd %y, %o0 <== NOT EXECUTED
40017510: 81 c3 e0 08 retl <== NOT EXECUTED
40017514: 01 00 00 00 nop <== NOT EXECUTED
40008c2c <rtems_rfs_group_bitmap_alloc>:
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
40008c2c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40008c30: 80 a6 a0 00 cmp %i2, 0
40008c34: 02 80 00 52 be 40008d7c <rtems_rfs_group_bitmap_alloc+0x150>
40008c38: 80 a6 60 00 cmp %i1, 0
{
size = fs->group_inodes;
40008c3c: e4 06 20 2c ld [ %i0 + 0x2c ], %l2
goal -= RTEMS_RFS_ROOT_INO;
40008c40: b2 06 7f ff add %i1, -1, %i1
*/
if (goal >= RTEMS_RFS_ROOT_INO)
goal -= RTEMS_RFS_ROOT_INO;
}
group_start = goal / size;
40008c44: 81 80 20 00 wr %g0, %y
40008c48: 01 00 00 00 nop
40008c4c: 01 00 00 00 nop
40008c50: 01 00 00 00 nop
40008c54: a0 76 40 12 udiv %i1, %l2, %l0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40008c58: c0 2f bf fb clrb [ %fp + -5 ]
bit = (rtems_rfs_bitmap_bit) (goal % size);
40008c5c: 82 5c 00 12 smul %l0, %l2, %g1
40008c60: b2 26 40 01 sub %i1, %g1, %i1
40008c64: f2 27 bf fc st %i1, [ %fp + -4 ]
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
40008c68: ba 10 00 10 mov %l0, %i5
direction = 1;
40008c6c: a6 10 20 01 mov 1, %l3
updown = true;
40008c70: a2 10 20 01 mov 1, %l1
bool allocated = false;
40008c74: b8 10 20 00 clr %i4
if (offset)
bit = direction > 0 ? 0 : size - 1;
40008c78: a4 04 bf ff add %l2, -1, %l2
* group_start, then alternate the direction and
* increment the offset on every other iteration.
* Otherwise we are marching through the groups, so just
* increment the offset.
*/
if (updown)
40008c7c: a8 0c 60 ff and %l1, 0xff, %l4
group = group_start + (direction * offset);
40008c80: aa 04 00 1c add %l0, %i4, %l5
if ((group < 0) || (group >= fs->group_count))
40008c84: 80 a7 60 00 cmp %i5, 0
40008c88: 06 80 00 29 bl 40008d2c <rtems_rfs_group_bitmap_alloc+0x100>
40008c8c: 80 8c 60 ff btst 0xff, %l1
40008c90: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40008c94: 80 a0 40 1d cmp %g1, %i5
40008c98: 04 80 00 25 ble 40008d2c <rtems_rfs_group_bitmap_alloc+0x100>
40008c9c: 80 8c 60 ff btst 0xff, %l1
bitmap = &fs->groups[group].inode_bitmap;
40008ca0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40008ca4: b3 2f 60 02 sll %i5, 2, %i1
if (inode)
40008ca8: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
40008cac: b2 06 40 1d add %i1, %i5, %i1
40008cb0: b3 2e 60 04 sll %i1, 4, %i1
40008cb4: 82 00 40 19 add %g1, %i1, %g1
if (inode)
40008cb8: 12 80 00 35 bne 40008d8c <rtems_rfs_group_bitmap_alloc+0x160>
40008cbc: ac 00 60 08 add %g1, 8, %l6
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
40008cc0: d2 07 bf fc ld [ %fp + -4 ], %o1
40008cc4: 96 07 bf fc add %fp, -4, %o3
40008cc8: 94 07 bf fb add %fp, -5, %o2
40008ccc: 7f ff f7 b2 call 40006b94 <rtems_rfs_bitmap_map_alloc>
40008cd0: 90 10 00 16 mov %l6, %o0
if (rc > 0)
40008cd4: 80 a2 20 00 cmp %o0, 0
40008cd8: 14 80 00 27 bg 40008d74 <rtems_rfs_group_bitmap_alloc+0x148> <== NEVER TAKEN
40008cdc: 01 00 00 00 nop
if (rtems_rfs_fs_release_bitmaps (fs))
40008ce0: c2 06 00 00 ld [ %i0 ], %g1
40008ce4: 80 88 60 01 btst 1, %g1
40008ce8: 22 80 00 3f be,a 40008de4 <rtems_rfs_group_bitmap_alloc+0x1b8> <== ALWAYS TAKEN
40008cec: d2 05 80 00 ld [ %l6 ], %o1
if (allocated)
40008cf0: c2 0f bf fb ldub [ %fp + -5 ], %g1 <== NOT EXECUTED
40008cf4: 80 a0 60 00 cmp %g1, 0
40008cf8: 12 80 00 45 bne 40008e0c <rtems_rfs_group_bitmap_alloc+0x1e0>
40008cfc: 80 a5 20 00 cmp %l4, 0
if (updown)
40008d00: 02 80 00 25 be 40008d94 <rtems_rfs_group_bitmap_alloc+0x168> <== NEVER TAKEN
40008d04: c0 2f bf fb clrb [ %fp + -5 ]
{
direction = direction > 0 ? -1 : 1;
40008d08: 80 a4 e0 01 cmp %l3, 1
40008d0c: 12 80 00 3a bne 40008df4 <rtems_rfs_group_bitmap_alloc+0x1c8> <== NEVER TAKEN
40008d10: 01 00 00 00 nop
if ( direction == -1 )
offset++;
40008d14: b8 07 20 01 inc %i4
direction = direction > 0 ? -1 : 1;
40008d18: a6 10 3f ff mov -1, %l3
40008d1c: ba 24 00 1c sub %l0, %i4, %i5
bit = direction > 0 ? 0 : size - 1;
40008d20: 82 10 00 12 mov %l2, %g1
40008d24: 10 bf ff d6 b 40008c7c <rtems_rfs_group_bitmap_alloc+0x50>
40008d28: c2 27 bf fc st %g1, [ %fp + -4 ]
if (!updown)
40008d2c: 02 80 00 0c be 40008d5c <rtems_rfs_group_bitmap_alloc+0x130>
40008d30: 90 10 20 00 clr %o0
direction = direction > 0 ? -1 : 1;
40008d34: 80 a4 e0 01 cmp %l3, 1
40008d38: 12 80 00 23 bne 40008dc4 <rtems_rfs_group_bitmap_alloc+0x198> <== ALWAYS TAKEN
40008d3c: c0 2f bf fb clrb [ %fp + -5 ]
group = group_start + (direction * offset);
40008d40: ba 24 00 1c sub %l0, %i4, %i5 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40008d44: a6 10 3f ff mov -1, %l3 <== NOT EXECUTED
if (offset)
40008d48: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40008d4c: 02 bf ff cc be 40008c7c <rtems_rfs_group_bitmap_alloc+0x50> <== NOT EXECUTED
40008d50: a2 10 20 00 clr %l1 <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40008d54: 10 bf ff f4 b 40008d24 <rtems_rfs_group_bitmap_alloc+0xf8> <== NOT EXECUTED
40008d58: 82 10 00 12 mov %l2, %g1 <== NOT EXECUTED
offset++;
}
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40008d5c: 40 00 07 9a call 4000abc4 <rtems_rfs_trace>
40008d60: 13 00 00 80 sethi %hi(0x20000), %o1
40008d64: 80 a2 20 00 cmp %o0, 0
40008d68: 12 80 00 13 bne 40008db4 <rtems_rfs_group_bitmap_alloc+0x188> <== NEVER TAKEN
40008d6c: 11 10 00 8b sethi %hi(0x40022c00), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
40008d70: 90 10 20 1c mov 0x1c, %o0
}
40008d74: 81 c7 e0 08 ret
40008d78: 91 e8 00 08 restore %g0, %o0, %o0
if (goal >= RTEMS_RFS_ROOT_INO)
40008d7c: 04 bf ff b2 ble 40008c44 <rtems_rfs_group_bitmap_alloc+0x18>
40008d80: e4 06 20 28 ld [ %i0 + 0x28 ], %l2
goal -= RTEMS_RFS_ROOT_INO;
40008d84: 10 bf ff b0 b 40008c44 <rtems_rfs_group_bitmap_alloc+0x18>
40008d88: b2 06 7f ff add %i1, -1, %i1
bitmap = &fs->groups[group].inode_bitmap;
40008d8c: 10 bf ff cd b 40008cc0 <rtems_rfs_group_bitmap_alloc+0x94>
40008d90: ac 00 60 2c add %g1, 0x2c, %l6
offset++;
40008d94: b8 07 20 01 inc %i4 <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40008d98: 80 a4 e0 01 cmp %l3, 1 <== NOT EXECUTED
group = group_start + (direction * offset);
40008d9c: ba 5f 00 13 smul %i4, %l3, %i5 <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40008da0: 12 bf ff e0 bne 40008d20 <rtems_rfs_group_bitmap_alloc+0xf4> <== NOT EXECUTED
40008da4: ba 07 40 10 add %i5, %l0, %i5 <== NOT EXECUTED
40008da8: 82 10 20 00 clr %g1 <== NOT EXECUTED
40008dac: 10 bf ff b4 b 40008c7c <rtems_rfs_group_bitmap_alloc+0x50> <== NOT EXECUTED
40008db0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
40008db4: 7f ff e7 df call 40002d30 <__wrap_puts> <== NOT EXECUTED
40008db8: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
return ENOSPC;
40008dbc: 10 bf ff ee b 40008d74 <rtems_rfs_group_bitmap_alloc+0x148> <== NOT EXECUTED
40008dc0: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
group = group_start + (direction * offset);
40008dc4: ba 04 00 1c add %l0, %i4, %i5
if (offset)
40008dc8: a6 10 20 01 mov 1, %l3
40008dcc: a2 10 20 00 clr %l1
40008dd0: 80 a7 20 00 cmp %i4, 0
40008dd4: 02 bf ff aa be 40008c7c <rtems_rfs_group_bitmap_alloc+0x50> <== NEVER TAKEN
40008dd8: 82 10 20 00 clr %g1
bit = direction > 0 ? 0 : size - 1;
40008ddc: 10 bf ff a8 b 40008c7c <rtems_rfs_group_bitmap_alloc+0x50>
40008de0: c2 27 bf fc st %g1, [ %fp + -4 ]
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40008de4: 7f ff f9 d8 call 40007544 <rtems_rfs_buffer_handle_release>
40008de8: 90 10 00 18 mov %i0, %o0
if (allocated)
40008dec: 10 bf ff c2 b 40008cf4 <rtems_rfs_group_bitmap_alloc+0xc8>
40008df0: c2 0f bf fb ldub [ %fp + -5 ], %g1
group = group_start + (direction * offset);
40008df4: ba 10 00 15 mov %l5, %i5 <== NOT EXECUTED
if (offset)
40008df8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40008dfc: 02 bf ff a2 be 40008c84 <rtems_rfs_group_bitmap_alloc+0x58> <== NOT EXECUTED
40008e00: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40008e04: 10 bf ff ea b 40008dac <rtems_rfs_group_bitmap_alloc+0x180> <== NOT EXECUTED
40008e08: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (inode)
40008e0c: 80 a6 a0 00 cmp %i2, 0
40008e10: 02 80 00 15 be 40008e64 <rtems_rfs_group_bitmap_alloc+0x238>
40008e14: c4 07 bf fc ld [ %fp + -4 ], %g2
*result = rtems_rfs_group_inode (fs, group, bit);
40008e18: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
40008e1c: 84 00 a0 01 inc %g2
40008e20: 82 5f 40 01 smul %i5, %g1, %g1
40008e24: 82 00 40 02 add %g1, %g2, %g1
40008e28: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40008e2c: 90 10 20 00 clr %o0
40008e30: 40 00 07 65 call 4000abc4 <rtems_rfs_trace>
40008e34: 13 00 00 80 sethi %hi(0x20000), %o1
40008e38: 80 a2 20 00 cmp %o0, 0
40008e3c: 22 bf ff ce be,a 40008d74 <rtems_rfs_group_bitmap_alloc+0x148> <== ALWAYS TAKEN
40008e40: 90 10 20 00 clr %o0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40008e44: 13 10 00 8b sethi %hi(0x40022c00), %o1 <== NOT EXECUTED
40008e48: 92 12 60 48 or %o1, 0x48, %o1 ! 40022c48 <IMFS_node_control_sym_link+0xec0><== NOT EXECUTED
40008e4c: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
40008e50: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40008e54: 7f ff e7 a9 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008e58: 90 12 20 58 or %o0, 0x58, %o0 ! 40022c58 <IMFS_node_control_sym_link+0xed0><== NOT EXECUTED
return 0;
40008e5c: 10 bf ff c6 b 40008d74 <rtems_rfs_group_bitmap_alloc+0x148> <== NOT EXECUTED
40008e60: 90 10 20 00 clr %o0 <== NOT EXECUTED
*result = rtems_rfs_group_block (&fs->groups[group], bit);
40008e64: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40008e68: c2 00 40 19 ld [ %g1 + %i1 ], %g1
40008e6c: 84 00 40 02 add %g1, %g2, %g2
40008e70: c4 26 c0 00 st %g2, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40008e74: 90 10 20 00 clr %o0
40008e78: 40 00 07 53 call 4000abc4 <rtems_rfs_trace>
40008e7c: 13 00 00 80 sethi %hi(0x20000), %o1
40008e80: 80 a2 20 00 cmp %o0, 0
40008e84: 22 bf ff bc be,a 40008d74 <rtems_rfs_group_bitmap_alloc+0x148> <== ALWAYS TAKEN
40008e88: 90 10 20 00 clr %o0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40008e8c: 13 10 00 8b sethi %hi(0x40022c00), %o1 <== NOT EXECUTED
40008e90: 10 bf ff ef b 40008e4c <rtems_rfs_group_bitmap_alloc+0x220> <== NOT EXECUTED
40008e94: 92 12 60 50 or %o1, 0x50, %o1 ! 40022c50 <IMFS_node_control_sym_link+0xec8><== NOT EXECUTED
40008e98 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
40008e98: 9d e3 bf a0 save %sp, -96, %sp
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40008e9c: 90 10 20 00 clr %o0
40008ea0: 13 00 00 80 sethi %hi(0x20000), %o1
40008ea4: 40 00 07 48 call 4000abc4 <rtems_rfs_trace>
40008ea8: b8 10 00 18 mov %i0, %i4
40008eac: 80 a2 20 00 cmp %o0, 0
40008eb0: 22 80 00 0c be,a 40008ee0 <rtems_rfs_group_bitmap_free+0x48> <== ALWAYS TAKEN
40008eb4: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40008eb8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40008ebc: 12 80 00 36 bne 40008f94 <rtems_rfs_group_bitmap_free+0xfc> <== NOT EXECUTED
40008ec0: 13 10 00 8b sethi %hi(0x40022c00), %o1 <== NOT EXECUTED
40008ec4: 13 10 00 8b sethi %hi(0x40022c00), %o1 <== NOT EXECUTED
40008ec8: 92 12 60 50 or %o1, 0x50, %o1 ! 40022c50 <IMFS_node_control_sym_link+0xec8><== NOT EXECUTED
40008ecc: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40008ed0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40008ed4: 7f ff e7 89 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008ed8: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
40008edc: fa 07 20 20 ld [ %i4 + 0x20 ], %i5 <== NOT EXECUTED
if (inode)
40008ee0: 80 a6 60 00 cmp %i1, 0
40008ee4: 02 80 00 17 be 40008f40 <rtems_rfs_group_bitmap_free+0xa8>
40008ee8: b4 06 bf ff add %i2, -1, %i2
size = fs->group_inodes;
40008eec: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
40008ef0: 81 80 20 00 wr %g0, %y
40008ef4: 01 00 00 00 nop
40008ef8: 01 00 00 00 nop
40008efc: 01 00 00 00 nop
40008f00: 84 76 80 09 udiv %i2, %o1, %g2
bitmap = &fs->groups[group].inode_bitmap;
40008f04: 83 28 a0 02 sll %g2, 2, %g1
40008f08: 82 00 40 02 add %g1, %g2, %g1
40008f0c: 83 28 60 04 sll %g1, 4, %g1
bit = (rtems_rfs_bitmap_bit) (no % size);
40008f10: 92 58 80 09 smul %g2, %o1, %o1
bitmap = &fs->groups[group].inode_bitmap;
40008f14: ba 07 40 01 add %i5, %g1, %i5
bit = (rtems_rfs_bitmap_bit) (no % size);
40008f18: 92 26 80 09 sub %i2, %o1, %o1
bitmap = &fs->groups[group].inode_bitmap;
40008f1c: ba 07 60 2c add %i5, 0x2c, %i5
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40008f20: 7f ff f6 69 call 400068c4 <rtems_rfs_bitmap_map_clear>
40008f24: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40008f28: d2 07 40 00 ld [ %i5 ], %o1
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40008f2c: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40008f30: 7f ff f9 85 call 40007544 <rtems_rfs_buffer_handle_release>
40008f34: 90 10 00 1c mov %i4, %o0
return rc;
}
40008f38: 81 c7 e0 08 ret
40008f3c: 81 e8 00 00 restore
size = fs->group_blocks;
40008f40: d2 07 20 28 ld [ %i4 + 0x28 ], %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
40008f44: 81 80 20 00 wr %g0, %y
40008f48: 01 00 00 00 nop
40008f4c: 01 00 00 00 nop
40008f50: 01 00 00 00 nop
40008f54: 84 76 80 09 udiv %i2, %o1, %g2
bitmap = &fs->groups[group].block_bitmap;
40008f58: 83 28 a0 02 sll %g2, 2, %g1
40008f5c: 82 00 40 02 add %g1, %g2, %g1
40008f60: 83 28 60 04 sll %g1, 4, %g1
bit = (rtems_rfs_bitmap_bit) (no % size);
40008f64: 92 58 80 09 smul %g2, %o1, %o1
bitmap = &fs->groups[group].block_bitmap;
40008f68: ba 07 40 01 add %i5, %g1, %i5
bit = (rtems_rfs_bitmap_bit) (no % size);
40008f6c: 92 26 80 09 sub %i2, %o1, %o1
bitmap = &fs->groups[group].block_bitmap;
40008f70: ba 07 60 08 add %i5, 8, %i5
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40008f74: 7f ff f6 54 call 400068c4 <rtems_rfs_bitmap_map_clear>
40008f78: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40008f7c: d2 07 40 00 ld [ %i5 ], %o1
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40008f80: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40008f84: 7f ff f9 70 call 40007544 <rtems_rfs_buffer_handle_release>
40008f88: 90 10 00 1c mov %i4, %o0
}
40008f8c: 81 c7 e0 08 ret
40008f90: 81 e8 00 00 restore
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40008f94: 10 bf ff ce b 40008ecc <rtems_rfs_group_bitmap_free+0x34> <== NOT EXECUTED
40008f98: 92 12 60 48 or %o1, 0x48, %o1 <== NOT EXECUTED
40008b9c <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40008b9c: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
40008ba0: 90 10 20 00 clr %o0
40008ba4: 40 00 08 08 call 4000abc4 <rtems_rfs_trace>
40008ba8: 13 00 00 40 sethi %hi(0x10000), %o1
40008bac: 80 a2 20 00 cmp %o0, 0
40008bb0: 32 80 00 1b bne,a 40008c1c <rtems_rfs_group_close+0x80> <== NEVER TAKEN
40008bb4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
40008bb8: 7f ff f8 92 call 40006e00 <rtems_rfs_bitmap_close>
40008bbc: 90 06 60 2c add %i1, 0x2c, %o0
rtems_rfs_buffer_handle_release (fs, handle);
40008bc0: 92 06 60 44 add %i1, 0x44, %o1
40008bc4: ba 10 00 08 mov %o0, %i5
40008bc8: 7f ff fa 5f call 40007544 <rtems_rfs_buffer_handle_release>
40008bcc: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
40008bd0: c0 2e 60 44 clrb [ %i1 + 0x44 ]
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
40008bd4: 90 06 60 08 add %i1, 8, %o0
handle->bnum = 0;
40008bd8: c0 26 60 48 clr [ %i1 + 0x48 ]
40008bdc: 7f ff f8 89 call 40006e00 <rtems_rfs_bitmap_close>
40008be0: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
40008be4: 82 92 20 00 orcc %o0, 0, %g1
40008be8: 14 80 00 05 bg 40008bfc <rtems_rfs_group_close+0x60> <== NEVER TAKEN
40008bec: 92 06 60 20 add %i1, 0x20, %o1
40008bf0: 82 38 00 1d xnor %g0, %i5, %g1
40008bf4: 83 38 60 1f sra %g1, 0x1f, %g1
40008bf8: 82 0f 40 01 and %i5, %g1, %g1
rtems_rfs_buffer_handle_release (fs, handle);
40008bfc: 90 10 00 18 mov %i0, %o0
40008c00: 7f ff fa 51 call 40007544 <rtems_rfs_buffer_handle_release>
40008c04: b0 10 00 01 mov %g1, %i0
handle->dirty = false;
40008c08: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40008c0c: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
40008c10: c0 26 60 28 clr [ %i1 + 0x28 ]
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
40008c14: 81 c7 e0 08 ret
40008c18: 81 e8 00 00 restore
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
40008c1c: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40008c20: 7f ff e8 36 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008c24: 90 12 20 20 or %o0, 0x20, %o0 ! 40022c20 <IMFS_node_control_sym_link+0xe98><== NOT EXECUTED
40008c28: 30 bf ff e4 b,a 40008bb8 <rtems_rfs_group_close+0x1c> <== NOT EXECUTED
4000896c <rtems_rfs_group_open>:
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
4000896c: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40008970: c2 06 20 04 ld [ %i0 + 4 ], %g1
40008974: 80 a0 40 19 cmp %g1, %i1
40008978: 08 80 00 7a bleu 40008b60 <rtems_rfs_group_open+0x1f4> <== NEVER TAKEN
4000897c: 84 06 40 1a add %i1, %i2, %g2
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
40008980: 80 a0 40 02 cmp %g1, %g2
40008984: 28 80 00 02 bleu,a 4000898c <rtems_rfs_group_open+0x20> <== ALWAYS TAKEN
40008988: b4 20 40 19 sub %g1, %i1, %i2
* Limit the inodes to the same size as the blocks. This is what the
* format does and if this is not done the accounting of inodes does
* not work. If we are so pushed for inodes that this makes a difference
* the format configuration needs reviewing.
*/
if (inodes > size)
4000898c: 80 a6 80 1b cmp %i2, %i3
40008990: 18 80 00 2b bgu 40008a3c <rtems_rfs_group_open+0xd0> <== ALWAYS TAKEN
40008994: a0 10 00 1a mov %i2, %l0
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40008998: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000899c: 40 00 08 8a call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400089a0: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
400089a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400089a8: 12 80 00 2d bne 40008a5c <rtems_rfs_group_open+0xf0> <== NOT EXECUTED
400089ac: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
400089b0: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
400089b4: b6 07 20 20 add %i4, 0x20, %i3
group->size = size;
400089b8: f4 27 20 04 st %i2, [ %i4 + 4 ]
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
400089bc: a2 07 20 08 add %i4, 8, %l1
handle->dirty = false;
400089c0: c0 2f 20 20 clrb [ %i4 + 0x20 ]
400089c4: 98 10 00 19 mov %i1, %o4
handle->bnum = 0;
400089c8: c0 27 20 24 clr [ %i4 + 0x24 ]
400089cc: 96 10 00 1a mov %i2, %o3
handle->buffer = NULL;
400089d0: c0 27 20 28 clr [ %i4 + 0x28 ]
400089d4: 94 10 00 1b mov %i3, %o2
400089d8: 92 10 00 18 mov %i0, %o1
400089dc: 7f ff f8 f8 call 40006dbc <rtems_rfs_bitmap_open>
400089e0: 90 10 00 11 mov %l1, %o0
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
400089e4: ba 92 20 00 orcc %o0, 0, %i5
400089e8: 14 80 00 24 bg 40008a78 <rtems_rfs_group_open+0x10c> <== NEVER TAKEN
400089ec: b4 07 20 44 add %i4, 0x44, %i2
handle->dirty = false;
400089f0: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
400089f4: c0 27 20 48 clr [ %i4 + 0x48 ]
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
400089f8: 96 10 00 10 mov %l0, %o3
handle->buffer = NULL;
400089fc: c0 27 20 4c clr [ %i4 + 0x4c ]
40008a00: 94 10 00 1a mov %i2, %o2
40008a04: d8 07 00 00 ld [ %i4 ], %o4
40008a08: 98 03 20 01 inc %o4
40008a0c: 92 10 00 18 mov %i0, %o1
40008a10: 7f ff f8 eb call 40006dbc <rtems_rfs_bitmap_open>
40008a14: 90 07 20 2c add %i4, 0x2c, %o0
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40008a18: ba 92 20 00 orcc %o0, 0, %i5
40008a1c: 14 80 00 2d bg 40008ad0 <rtems_rfs_group_open+0x164> <== NEVER TAKEN
40008a20: 92 10 00 1a mov %i2, %o1
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
40008a24: c2 06 00 00 ld [ %i0 ], %g1
40008a28: 80 88 60 01 btst 1, %g1
40008a2c: 02 80 00 44 be 40008b3c <rtems_rfs_group_open+0x1d0> <== ALWAYS TAKEN
40008a30: ba 10 20 00 clr %i5
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
40008a34: 81 c7 e0 08 ret <== NOT EXECUTED
40008a38: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40008a3c: 90 10 20 00 clr %o0
40008a40: 13 00 00 20 sethi %hi(0x8000), %o1
40008a44: 40 00 08 60 call 4000abc4 <rtems_rfs_trace>
40008a48: a0 10 00 1b mov %i3, %l0
40008a4c: 80 a2 20 00 cmp %o0, 0
40008a50: 22 bf ff d9 be,a 400089b4 <rtems_rfs_group_open+0x48> <== ALWAYS TAKEN
40008a54: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40008a58: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
40008a5c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40008a60: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40008a64: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008a68: 7f ff e8 a4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008a6c: 90 12 23 68 or %o0, 0x368, %o0 ! 40022b68 <IMFS_node_control_sym_link+0xde0><== NOT EXECUTED
group->base = base;
40008a70: 10 bf ff d1 b 400089b4 <rtems_rfs_group_open+0x48> <== NOT EXECUTED
40008a74: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40008a78: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40008a7c: 7f ff fa b2 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008a80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
40008a84: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40008a88: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->bnum = 0;
40008a8c: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
40008a90: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40008a94: 40 00 08 4c call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40008a98: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40008a9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008aa0: 02 bf ff e5 be 40008a34 <rtems_rfs_group_open+0xc8> <== NOT EXECUTED
40008aa4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40008aa8: 40 00 5a d9 call 4001f60c <strerror> <== NOT EXECUTED
40008aac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40008ab0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40008ab4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
}
40008ab8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40008abc: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008ac0: 7f ff e8 8e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008ac4: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 40022ba0 <IMFS_node_control_sym_link+0xe18><== NOT EXECUTED
}
40008ac8: 81 c7 e0 08 ret <== NOT EXECUTED
40008acc: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40008ad0: 7f ff fa 9d call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008ad4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
40008ad8: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
rtems_rfs_bitmap_close (&group->block_bitmap);
40008adc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->bnum = 0;
40008ae0: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
40008ae4: 7f ff f8 c7 call 40006e00 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40008ae8: c0 27 20 4c clr [ %i4 + 0x4c ] <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40008aec: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40008af0: 7f ff fa 95 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40008af4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
40008af8: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40008afc: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->bnum = 0;
40008b00: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
40008b04: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40008b08: 40 00 08 2f call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40008b0c: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40008b10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008b14: 02 bf ff c8 be 40008a34 <rtems_rfs_group_open+0xc8> <== NOT EXECUTED
40008b18: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40008b1c: 40 00 5a bc call 4001f60c <strerror> <== NOT EXECUTED
40008b20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40008b24: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40008b28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008b2c: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008b30: 7f ff e8 72 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008b34: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 40022be0 <IMFS_node_control_sym_link+0xe58><== NOT EXECUTED
40008b38: 30 bf ff bf b,a 40008a34 <rtems_rfs_group_open+0xc8> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40008b3c: d2 07 20 08 ld [ %i4 + 8 ], %o1
40008b40: 7f ff fa 81 call 40007544 <rtems_rfs_buffer_handle_release>
40008b44: 90 10 00 18 mov %i0, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40008b48: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40008b4c: 90 10 00 18 mov %i0, %o0
40008b50: 7f ff fa 7d call 40007544 <rtems_rfs_buffer_handle_release>
40008b54: b0 10 00 1d mov %i5, %i0
}
40008b58: 81 c7 e0 08 ret
40008b5c: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40008b60: 90 10 20 00 clr %o0 <== NOT EXECUTED
40008b64: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40008b68: 40 00 08 17 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40008b6c: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
40008b70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008b74: 02 bf ff b0 be 40008a34 <rtems_rfs_group_open+0xc8> <== NOT EXECUTED
40008b78: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
40008b7c: 40 00 5a a4 call 4001f60c <strerror> <== NOT EXECUTED
40008b80: 90 10 20 05 mov 5, %o0 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED
40008b84: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
40008b88: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40008b8c: 11 10 00 8a sethi %hi(0x40022800), %o0 <== NOT EXECUTED
40008b90: 7f ff e8 5a call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40008b94: 90 12 23 28 or %o0, 0x328, %o0 ! 40022b28 <IMFS_node_control_sym_link+0xda0><== NOT EXECUTED
40008b98: 30 bf ff a7 b,a 40008a34 <rtems_rfs_group_open+0xc8> <== NOT EXECUTED
40008f9c <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
40008f9c: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
40008fa0: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40008fa4: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
40008fa8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40008fac: 04 80 00 1e ble 40009024 <rtems_rfs_group_usage+0x88> <== NOT EXECUTED
40008fb0: 86 10 20 00 clr %g3 <== NOT EXECUTED
40008fb4: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
40008fb8: 82 00 60 14 add %g1, 0x14, %g1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
40008fbc: da 00 40 00 ld [ %g1 ], %o5 <== NOT EXECUTED
40008fc0: c8 00 60 04 ld [ %g1 + 4 ], %g4 <== NOT EXECUTED
40008fc4: c4 02 40 00 ld [ %o1 ], %g2 <== NOT EXECUTED
40008fc8: 84 00 80 0d add %g2, %o5, %g2 <== NOT EXECUTED
40008fcc: 84 20 80 04 sub %g2, %g4, %g2 <== NOT EXECUTED
40008fd0: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40008fd4: 86 00 e0 01 inc %g3 <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
40008fd8: c8 00 60 28 ld [ %g1 + 0x28 ], %g4 <== NOT EXECUTED
40008fdc: da 00 60 24 ld [ %g1 + 0x24 ], %o5 <== NOT EXECUTED
40008fe0: c4 02 80 00 ld [ %o2 ], %g2 <== NOT EXECUTED
40008fe4: 84 00 80 0d add %g2, %o5, %g2 <== NOT EXECUTED
40008fe8: 84 20 80 04 sub %g2, %g4, %g2 <== NOT EXECUTED
40008fec: c4 22 80 00 st %g2, [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40008ff0: c8 02 20 24 ld [ %o0 + 0x24 ], %g4 <== NOT EXECUTED
40008ff4: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
40008ff8: 14 bf ff f1 bg 40008fbc <rtems_rfs_group_usage+0x20> <== NOT EXECUTED
40008ffc: 82 00 60 50 add %g1, 0x50, %g1 <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
40009000: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
40009004: c6 02 40 00 ld [ %o1 ], %g3 <== NOT EXECUTED
40009008: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000900c: 38 80 00 08 bgu,a 4000902c <rtems_rfs_group_usage+0x90> <== NOT EXECUTED
40009010: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
40009014: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED
40009018: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000901c: 2a 80 00 02 bcs,a 40009024 <rtems_rfs_group_usage+0x88> <== NOT EXECUTED
40009020: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
40009024: 81 c3 e0 08 retl <== NOT EXECUTED
40009028: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (*inodes > rtems_rfs_fs_inodes (fs))
4000902c: 10 bf ff fa b 40009014 <rtems_rfs_group_usage+0x78> <== NOT EXECUTED
40009030: c4 02 80 00 ld [ %o2 ], %g2 <== NOT EXECUTED
400092f4 <rtems_rfs_inode_close>:
{
400092f4: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
400092f8: 90 10 20 00 clr %o0
400092fc: 40 00 06 32 call 4000abc4 <rtems_rfs_trace>
40009300: 13 00 02 00 sethi %hi(0x80000), %o1
40009304: 80 a2 20 00 cmp %o0, 0
40009308: 32 80 00 1d bne,a 4000937c <rtems_rfs_inode_close+0x88> <== NEVER TAKEN
4000930c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40009310: 90 10 00 18 mov %i0, %o0
40009314: 94 10 20 01 mov 1, %o2
40009318: 7f ff ff b9 call 400091fc <rtems_rfs_inode_unload>
4000931c: 92 10 00 19 mov %i1, %o1
if ((rc == 0) && (handle->loads > 0))
40009320: b0 92 20 00 orcc %o0, 0, %i0
40009324: 32 80 00 07 bne,a 40009340 <rtems_rfs_inode_close+0x4c> <== NEVER TAKEN
40009328: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
4000932c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40009330: 80 a0 60 00 cmp %g1, 0
40009334: 14 80 00 05 bg 40009348 <rtems_rfs_inode_close+0x54> <== NEVER TAKEN
40009338: 90 10 20 00 clr %o0
handle->ino = 0;
4000933c: c0 26 60 08 clr [ %i1 + 8 ]
}
40009340: 81 c7 e0 08 ret
40009344: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40009348: 13 00 02 00 sethi %hi(0x80000), %o1 <== NOT EXECUTED
4000934c: 40 00 06 1e call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40009350: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40009354: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40009358: 22 bf ff fa be,a 40009340 <rtems_rfs_inode_close+0x4c> <== NOT EXECUTED
4000935c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
40009360: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
40009364: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40009368: 7f ff e6 64 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000936c: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 40022dc0 <IMFS_node_control_sym_link+0x1038><== NOT EXECUTED
40009370: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
40009374: 81 c7 e0 08 ret <== NOT EXECUTED
40009378: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
4000937c: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40009380: 7f ff e6 5e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40009384: 90 12 21 98 or %o0, 0x198, %o0 ! 40022d98 <IMFS_node_control_sym_link+0x1010><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40009388: 10 bf ff e3 b 40009314 <rtems_rfs_inode_close+0x20> <== NOT EXECUTED
4000938c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000969c <rtems_rfs_inode_create>:
{
4000969c: 9d e3 bf 50 save %sp, -176, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
400096a0: 90 10 20 00 clr %o0
{
400096a4: e2 17 a0 5e lduh [ %fp + 0x5e ], %l1
400096a8: e4 17 a0 62 lduh [ %fp + 0x62 ], %l2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
400096ac: 13 00 10 00 sethi %hi(0x400000), %o1
400096b0: 40 00 05 45 call 4000abc4 <rtems_rfs_trace>
400096b4: a8 0f 30 00 and %i4, -4096, %l4
400096b8: 80 a2 20 00 cmp %o0, 0
400096bc: 02 80 00 2c be 4000976c <rtems_rfs_inode_create+0xd0> <== ALWAYS TAKEN
400096c0: a7 2d 20 10 sll %l4, 0x10, %l3
if (RTEMS_RFS_S_ISDIR (mode))
400096c4: 83 34 e0 10 srl %l3, 0x10, %g1 <== NOT EXECUTED
400096c8: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
400096cc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400096d0: 02 80 00 11 be 40009714 <rtems_rfs_inode_create+0x78> <== NOT EXECUTED
400096d4: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
400096d8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400096dc: 02 80 00 9f be 40009958 <rtems_rfs_inode_create+0x2bc> <== NOT EXECUTED
400096e0: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
400096e4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400096e8: 02 80 00 7a be 400098d0 <rtems_rfs_inode_create+0x234> <== NOT EXECUTED
400096ec: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
400096f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400096f4: 02 80 00 9c be 40009964 <rtems_rfs_inode_create+0x2c8> <== NOT EXECUTED
400096f8: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
400096fc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40009700: 22 80 00 9c be,a 40009970 <rtems_rfs_inode_create+0x2d4> <== NOT EXECUTED
40009704: 2d 10 00 8b sethi %hi(0x40022c00), %l6 <== NOT EXECUTED
const char* type = "unknown";
40009708: 2d 10 00 8b sethi %hi(0x40022c00), %l6 <== NOT EXECUTED
4000970c: 10 80 00 04 b 4000971c <rtems_rfs_inode_create+0x80> <== NOT EXECUTED
40009710: ac 15 a2 40 or %l6, 0x240, %l6 ! 40022e40 <IMFS_node_control_sym_link+0x10b8><== NOT EXECUTED
type = "dir";
40009714: 2d 10 00 8b sethi %hi(0x40022c00), %l6 <== NOT EXECUTED
40009718: ac 15 a2 20 or %l6, 0x220, %l6 ! 40022e20 <IMFS_node_control_sym_link+0x1098><== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
4000971c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40009720: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40009724: 7f ff e5 75 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40009728: 90 12 22 48 or %o0, 0x248, %o0 ! 40022e48 <IMFS_node_control_sym_link+0x10c0><== NOT EXECUTED
for (c = 0; c < length; c++)
4000972c: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED
40009730: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
40009734: 02 80 00 08 be 40009754 <rtems_rfs_inode_create+0xb8> <== NOT EXECUTED
40009738: aa 06 c0 1a add %i3, %i2, %l5 <== NOT EXECUTED
printf ("%c", name[c]);
4000973c: 40 00 54 9d call 4001e9b0 <putchar> <== NOT EXECUTED
40009740: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
for (c = 0; c < length; c++)
40009744: a0 04 20 01 inc %l0 <== NOT EXECUTED
40009748: 80 a5 40 10 cmp %l5, %l0 <== NOT EXECUTED
4000974c: 12 bf ff fc bne 4000973c <rtems_rfs_inode_create+0xa0> <== NOT EXECUTED
40009750: 01 00 00 00 nop <== NOT EXECUTED
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
40009754: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40009758: 96 0f 23 ff and %i4, 0x3ff, %o3 <== NOT EXECUTED
4000975c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40009760: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
40009764: 7f ff e5 65 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40009768: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
4000976c: 85 34 e0 10 srl %l3, 0x10, %g2
40009770: 03 00 00 18 sethi %hi(0x6000), %g1
40009774: 80 a0 80 01 cmp %g2, %g1
40009778: 02 80 00 12 be 400097c0 <rtems_rfs_inode_create+0x124> <== NEVER TAKEN
4000977c: 92 10 00 19 mov %i1, %o1
40009780: 08 80 00 0a bleu 400097a8 <rtems_rfs_inode_create+0x10c>
40009784: 03 3f ff f8 sethi %hi(0xffffe000), %g1
40009788: 03 3f ff f4 sethi %hi(0xffffd000), %g1
4000978c: 05 00 00 20 sethi %hi(0x8000), %g2
40009790: 82 0f 00 01 and %i4, %g1, %g1
40009794: 80 a0 40 02 cmp %g1, %g2
40009798: 02 80 00 0a be 400097c0 <rtems_rfs_inode_create+0x124> <== ALWAYS TAKEN
4000979c: a0 10 20 16 mov 0x16, %l0
}
400097a0: 81 c7 e0 08 ret
400097a4: 91 e8 00 10 restore %g0, %l0, %o0
switch (mode & RTEMS_RFS_S_IFMT)
400097a8: a8 05 00 01 add %l4, %g1, %l4
400097ac: 03 00 00 34 sethi %hi(0xd000), %g1
400097b0: 80 8d 00 01 btst %l4, %g1
400097b4: 12 bf ff fb bne 400097a0 <rtems_rfs_inode_create+0x104> <== NEVER TAKEN
400097b8: a0 10 20 16 mov 0x16, %l0
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
400097bc: 92 10 00 19 mov %i1, %o1
400097c0: 94 10 20 01 mov 1, %o2
400097c4: 96 07 bf d8 add %fp, -40, %o3
400097c8: 7f ff fd 19 call 40008c2c <rtems_rfs_group_bitmap_alloc>
400097cc: 90 10 00 18 mov %i0, %o0
*ino = bit;
400097d0: d2 07 bf d8 ld [ %fp + -40 ], %o1
400097d4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
if (rc > 0)
400097d8: a0 92 20 00 orcc %o0, 0, %l0
400097dc: 14 bf ff f1 bg 400097a0 <rtems_rfs_inode_create+0x104>
400097e0: d2 20 40 00 st %o1, [ %g1 ]
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
400097e4: 96 10 20 01 mov 1, %o3
400097e8: 94 07 bf d8 add %fp, -40, %o2
400097ec: 7f ff fe 49 call 40009110 <rtems_rfs_inode_open>
400097f0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400097f4: a0 92 20 00 orcc %o0, 0, %l0
400097f8: 14 80 00 50 bg 40009938 <rtems_rfs_inode_create+0x29c> <== NEVER TAKEN
400097fc: 98 10 00 12 mov %l2, %o4
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
40009800: 96 10 00 11 mov %l1, %o3
40009804: 94 10 00 1c mov %i4, %o2
40009808: 92 10 00 1d mov %i5, %o1
4000980c: 7f ff ff 56 call 40009564 <rtems_rfs_inode_initialise>
40009810: 90 07 bf d8 add %fp, -40, %o0
if (rc > 0)
40009814: a0 92 20 00 orcc %o0, 0, %l0
40009818: 14 80 00 45 bg 4000992c <rtems_rfs_inode_create+0x290> <== NEVER TAKEN
4000981c: 03 10 00 00 sethi %hi(0x40000000), %g1
if (RTEMS_RFS_S_ISDIR (mode))
40009820: 80 a4 c0 01 cmp %l3, %g1
40009824: 02 80 00 2e be 400098dc <rtems_rfs_inode_create+0x240>
40009828: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4000982c: 96 10 20 01 mov 1, %o3
40009830: 94 07 bf b0 add %fp, -80, %o2
40009834: 92 10 00 19 mov %i1, %o1
40009838: 7f ff fe 36 call 40009110 <rtems_rfs_inode_open>
4000983c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40009840: a0 92 20 00 orcc %o0, 0, %l0
40009844: 14 80 00 33 bg 40009910 <rtems_rfs_inode_create+0x274> <== NEVER TAKEN
40009848: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
4000984c: d8 00 40 00 ld [ %g1 ], %o4
40009850: 96 10 00 1b mov %i3, %o3
40009854: 94 10 00 1a mov %i2, %o2
40009858: 92 07 bf b0 add %fp, -80, %o1
4000985c: 40 00 2e d3 call 400153a8 <rtems_rfs_dir_add_entry>
40009860: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40009864: a0 92 20 00 orcc %o0, 0, %l0
40009868: 14 80 00 44 bg 40009978 <rtems_rfs_inode_create+0x2dc> <== NEVER TAKEN
4000986c: 03 10 00 00 sethi %hi(0x40000000), %g1
if (RTEMS_RFS_S_ISDIR (mode))
40009870: 80 a4 c0 01 cmp %l3, %g1
40009874: 02 80 00 4b be 400099a0 <rtems_rfs_inode_create+0x304>
40009878: c4 07 bf bc ld [ %fp + -68 ], %g2
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4000987c: 94 10 20 01 mov 1, %o2
40009880: 92 10 20 01 mov 1, %o1
40009884: 7f ff ff 0d call 400094b8 <rtems_rfs_inode_time_stamp_now>
40009888: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
4000988c: a0 92 20 00 orcc %o0, 0, %l0
40009890: 14 80 00 20 bg 40009910 <rtems_rfs_inode_create+0x274> <== NEVER TAKEN
40009894: 92 07 bf b0 add %fp, -80, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
40009898: 7f ff fe 97 call 400092f4 <rtems_rfs_inode_close>
4000989c: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_delete (fs, &inode);
400098a0: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
400098a4: a0 10 00 08 mov %o0, %l0
if (rc > 0)
400098a8: 80 a4 20 00 cmp %l0, 0
400098ac: 14 80 00 57 bg 40009a08 <rtems_rfs_inode_create+0x36c> <== NEVER TAKEN
400098b0: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_inode_close (fs, &inode);
400098b4: 7f ff fe 90 call 400092f4 <rtems_rfs_inode_close>
400098b8: 01 00 00 00 nop
if (rc > 0)
400098bc: a0 92 20 00 orcc %o0, 0, %l0
400098c0: 14 80 00 1f bg 4000993c <rtems_rfs_inode_create+0x2a0> <== NEVER TAKEN
400098c4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
return 0;
400098c8: 10 bf ff b6 b 400097a0 <rtems_rfs_inode_create+0x104>
400098cc: a0 10 20 00 clr %l0
type = "block";
400098d0: 2d 10 00 8b sethi %hi(0x40022c00), %l6 <== NOT EXECUTED
400098d4: 10 bf ff 92 b 4000971c <rtems_rfs_inode_create+0x80> <== NOT EXECUTED
400098d8: ac 15 a0 50 or %l6, 0x50, %l6 ! 40022c50 <IMFS_node_control_sym_link+0xec8><== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
400098dc: d8 00 40 00 ld [ %g1 ], %o4
400098e0: 96 10 20 01 mov 1, %o3
400098e4: 92 07 bf d8 add %fp, -40, %o1
400098e8: 15 10 00 86 sethi %hi(0x40021800), %o2
400098ec: 90 10 00 18 mov %i0, %o0
400098f0: 40 00 2e ae call 400153a8 <rtems_rfs_dir_add_entry>
400098f4: 94 12 a1 08 or %o2, 0x108, %o2
if (rc == 0)
400098f8: a0 92 20 00 orcc %o0, 0, %l0
400098fc: 02 80 00 3b be 400099e8 <rtems_rfs_inode_create+0x34c> <== ALWAYS TAKEN
40009900: 98 10 00 19 mov %i1, %o4
if (rc > 0)
40009904: 80 a4 20 00 cmp %l0, 0
40009908: 04 bf ff ca ble 40009830 <rtems_rfs_inode_create+0x194> <== ALWAYS TAKEN
4000990c: 96 10 20 01 mov 1, %o3
rtems_rfs_inode_delete (fs, &inode);
40009910: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40009914: 7f ff fe 9f call 40009390 <rtems_rfs_inode_delete> <== NOT EXECUTED
40009918: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4000991c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40009920: 7f ff fe 75 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40009924: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
40009928: 30 bf ff 9e b,a 400097a0 <rtems_rfs_inode_create+0x104> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4000992c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40009930: 7f ff fe 71 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40009934: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
40009938: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
4000993c: d4 00 40 00 ld [ %g1 ], %o2 <== NOT EXECUTED
40009940: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40009944: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40009948: 7f ff fd 54 call 40008e98 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4000994c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
}
40009950: 81 c7 e0 08 ret <== NOT EXECUTED
40009954: 81 e8 00 00 restore <== NOT EXECUTED
type = "char";
40009958: 2d 10 00 8b sethi %hi(0x40022c00), %l6 <== NOT EXECUTED
4000995c: 10 bf ff 70 b 4000971c <rtems_rfs_inode_create+0x80> <== NOT EXECUTED
40009960: ac 15 a2 30 or %l6, 0x230, %l6 ! 40022e30 <IMFS_node_control_sym_link+0x10a8><== NOT EXECUTED
type = "file";
40009964: 2d 10 00 8b sethi %hi(0x40022c00), %l6 <== NOT EXECUTED
40009968: 10 bf ff 6d b 4000971c <rtems_rfs_inode_create+0x80> <== NOT EXECUTED
4000996c: ac 15 a2 28 or %l6, 0x228, %l6 ! 40022e28 <IMFS_node_control_sym_link+0x10a0><== NOT EXECUTED
type = "link";
40009970: 10 bf ff 6b b 4000971c <rtems_rfs_inode_create+0x80> <== NOT EXECUTED
40009974: ac 15 a2 38 or %l6, 0x238, %l6 <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
40009978: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4000997c: 7f ff fe 85 call 40009390 <rtems_rfs_inode_delete> <== NOT EXECUTED
40009980: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40009984: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40009988: 7f ff fe 5b call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
4000998c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40009990: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40009994: 7f ff fe 58 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40009998: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
4000999c: 30 bf ff 81 b,a 400097a0 <rtems_rfs_inode_create+0x104> <== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
400099a0: c6 08 80 00 ldub [ %g2 ], %g3
400099a4: 87 28 e0 08 sll %g3, 8, %g3
400099a8: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
400099ac: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
400099b0: 07 00 00 3f sethi %hi(0xfc00), %g3
400099b4: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_ISR_Stack_size+0xefff>
400099b8: 80 a0 40 03 cmp %g1, %g3
400099bc: 22 80 00 19 be,a 40009a20 <rtems_rfs_inode_create+0x384> <== NEVER TAKEN
400099c0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode,
400099c4: 82 00 60 01 inc %g1
rtems_rfs_write_u16 (&handle->node->links, links);
400099c8: 87 28 60 10 sll %g1, 0x10, %g3
400099cc: 87 30 e0 18 srl %g3, 0x18, %g3
400099d0: c6 28 80 00 stb %g3, [ %g2 ]
400099d4: c4 07 bf bc ld [ %fp + -68 ], %g2
400099d8: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400099dc: 82 10 20 01 mov 1, %g1
}
400099e0: 10 bf ff a7 b 4000987c <rtems_rfs_inode_create+0x1e0>
400099e4: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
400099e8: 96 10 20 02 mov 2, %o3
400099ec: 92 07 bf d8 add %fp, -40, %o1
400099f0: 15 10 00 8b sethi %hi(0x40022c00), %o2
400099f4: 90 10 00 18 mov %i0, %o0
400099f8: 40 00 2e 6c call 400153a8 <rtems_rfs_dir_add_entry>
400099fc: 94 12 a2 98 or %o2, 0x298, %o2
40009a00: 10 bf ff c1 b 40009904 <rtems_rfs_inode_create+0x268>
40009a04: a0 10 00 08 mov %o0, %l0
rtems_rfs_inode_delete (fs, &inode);
40009a08: 7f ff fe 62 call 40009390 <rtems_rfs_inode_delete> <== NOT EXECUTED
40009a0c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40009a10: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40009a14: 7f ff fe 38 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40009a18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
40009a1c: 30 bf ff 61 b,a 400097a0 <rtems_rfs_inode_create+0x104> <== NOT EXECUTED
40009a20: 10 bf ff ec b 400099d0 <rtems_rfs_inode_create+0x334> <== NOT EXECUTED
40009a24: 86 10 20 00 clr %g3 <== NOT EXECUTED
40009390 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40009390: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
40009394: 90 10 20 00 clr %o0
40009398: 40 00 06 0b call 4000abc4 <rtems_rfs_trace>
4000939c: 13 00 20 00 sethi %hi(0x800000), %o1
400093a0: 80 a2 20 00 cmp %o0, 0
400093a4: 02 80 00 0b be 400093d0 <rtems_rfs_inode_delete+0x40> <== ALWAYS TAKEN
400093a8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
400093ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400093b0: 02 80 00 31 be 40009474 <rtems_rfs_inode_delete+0xe4> <== NOT EXECUTED
400093b4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400093b8: 15 10 00 8b sethi %hi(0x40022c00), %o2 <== NOT EXECUTED
400093bc: 94 12 a0 f8 or %o2, 0xf8, %o2 ! 40022cf8 <IMFS_node_control_sym_link+0xf70><== NOT EXECUTED
400093c0: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
400093c4: 7f ff e6 4d call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400093c8: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 40022df0 <IMFS_node_control_sym_link+0x1068><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
400093cc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
400093d0: 80 a0 60 00 cmp %g1, 0
400093d4: 02 80 00 09 be 400093f8 <rtems_rfs_inode_delete+0x68> <== NEVER TAKEN
400093d8: ba 10 20 00 clr %i5
return rtems_rfs_group_bitmap_free (fs, true, bit);
400093dc: d4 06 60 08 ld [ %i1 + 8 ], %o2
400093e0: 92 10 20 01 mov 1, %o1
400093e4: 7f ff fe ad call 40008e98 <rtems_rfs_group_bitmap_free>
400093e8: 90 10 00 18 mov %i0, %o0
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
if (rc > 0)
400093ec: ba 92 20 00 orcc %o0, 0, %i5
400093f0: 04 80 00 04 ble 40009400 <rtems_rfs_inode_delete+0x70> <== ALWAYS TAKEN
400093f4: 92 10 00 19 mov %i1, %o1
if (rrc > 0)
rc = rrc;
}
}
return rc;
}
400093f8: 81 c7 e0 08 ret
400093fc: 91 e8 00 1d restore %g0, %i5, %o0
rc = rtems_rfs_block_map_open (fs, handle, &map);
40009400: 94 07 bf b0 add %fp, -80, %o2
40009404: 40 00 2b 4a call 4001412c <rtems_rfs_block_map_open>
40009408: 90 10 00 18 mov %i0, %o0
if (rc == 0)
4000940c: ba 92 20 00 orcc %o0, 0, %i5
40009410: 12 bf ff fa bne 400093f8 <rtems_rfs_inode_delete+0x68> <== NEVER TAKEN
40009414: 92 07 bf b0 add %fp, -80, %o1
rrc = rtems_rfs_block_map_free_all (fs, &map);
40009418: 40 00 2e 4d call 40014d4c <rtems_rfs_block_map_free_all>
4000941c: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
40009420: 92 07 bf b0 add %fp, -80, %o1
rrc = rtems_rfs_block_map_free_all (fs, &map);
40009424: b8 10 00 08 mov %o0, %i4
rc = rtems_rfs_block_map_close (fs, &map);
40009428: 40 00 2b a0 call 400142a8 <rtems_rfs_block_map_close>
4000942c: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40009430: b6 06 60 10 add %i1, 0x10, %i3
rc = rtems_rfs_block_map_close (fs, &map);
40009434: ba 10 00 08 mov %o0, %i5
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40009438: 94 10 20 38 mov 0x38, %o2
4000943c: d0 06 60 0c ld [ %i1 + 0xc ], %o0
if (rc > 0)
40009440: 80 a7 60 00 cmp %i5, 0
40009444: 04 80 00 0f ble 40009480 <rtems_rfs_inode_delete+0xf0> <== ALWAYS TAKEN
40009448: 92 10 20 ff mov 0xff, %o1
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
4000944c: 40 00 55 14 call 4001e89c <memset> <== NOT EXECUTED
40009450: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40009454: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment> <== NOT EXECUTED
40009458: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4000945c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40009460: 7f ff f8 39 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40009464: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->loads = 0;
40009468: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED
handle->node = NULL;
4000946c: 10 bf ff e3 b 400093f8 <rtems_rfs_inode_delete+0x68> <== NOT EXECUTED
40009470: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
40009474: 15 10 00 8b sethi %hi(0x40022c00), %o2 <== NOT EXECUTED
40009478: 10 bf ff d2 b 400093c0 <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
4000947c: 94 12 a1 00 or %o2, 0x100, %o2 ! 40022d00 <IMFS_node_control_sym_link+0xf78><== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40009480: 40 00 55 07 call 4001e89c <memset>
40009484: 01 00 00 00 nop
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40009488: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
4000948c: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40009490: 92 10 00 1b mov %i3, %o1
40009494: 7f ff f8 2c call 40007544 <rtems_rfs_buffer_handle_release>
40009498: 90 10 00 18 mov %i0, %o0
handle->loads = 0;
4000949c: c0 26 60 24 clr [ %i1 + 0x24 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
400094a0: ba 10 00 08 mov %o0, %i5
if (rrc > 0)
400094a4: 80 a7 20 00 cmp %i4, 0
400094a8: 04 bf ff d4 ble 400093f8 <rtems_rfs_inode_delete+0x68> <== ALWAYS TAKEN
400094ac: c0 26 60 0c clr [ %i1 + 0xc ]
400094b0: 10 bf ff d2 b 400093f8 <rtems_rfs_inode_delete+0x68> <== NOT EXECUTED
400094b4: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
4000905c <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4000905c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
40009060: 90 10 20 00 clr %o0
40009064: 40 00 06 d8 call 4000abc4 <rtems_rfs_trace>
40009068: 13 00 04 00 sethi %hi(0x100000), %o1
4000906c: 80 a2 20 00 cmp %o0, 0
40009070: 02 80 00 0c be 400090a0 <rtems_rfs_inode_load+0x44> <== ALWAYS TAKEN
40009074: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40009078: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4000907c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009080: 02 80 00 11 be 400090c4 <rtems_rfs_inode_load+0x68> <== NOT EXECUTED
40009084: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40009088: 17 10 00 8b sethi %hi(0x40022c00), %o3 <== NOT EXECUTED
4000908c: 96 12 e0 f8 or %o3, 0xf8, %o3 ! 40022cf8 <IMFS_node_control_sym_link+0xf70><== NOT EXECUTED
40009090: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40009094: 7f ff e7 19 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40009098: 90 12 21 08 or %o0, 0x108, %o0 ! 40022d08 <IMFS_node_control_sym_link+0xf80><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
4000909c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
400090a0: 80 a0 60 00 cmp %g1, 0
400090a4: 22 80 00 0b be,a 400090d0 <rtems_rfs_inode_load+0x74>
400090a8: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400090ac: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
400090b0: 82 00 60 01 inc %g1
400090b4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
400090b8: b0 10 20 00 clr %i0
}
400090bc: 81 c7 e0 08 ret
400090c0: 81 e8 00 00 restore
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
400090c4: 17 10 00 8b sethi %hi(0x40022c00), %o3 <== NOT EXECUTED
400090c8: 10 bf ff f2 b 40009090 <rtems_rfs_inode_load+0x34> <== NOT EXECUTED
400090cc: 96 12 e1 00 or %o3, 0x100, %o3 ! 40022d00 <IMFS_node_control_sym_link+0xf78><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
400090d0: 90 10 00 18 mov %i0, %o0
400090d4: 96 10 20 01 mov 1, %o3
400090d8: 7f ff f8 52 call 40007220 <rtems_rfs_buffer_handle_request>
400090dc: 92 06 60 10 add %i1, 0x10, %o1
if (rc > 0)
400090e0: b0 92 20 00 orcc %o0, 0, %i0
400090e4: 14 bf ff f6 bg 400090bc <rtems_rfs_inode_load+0x60> <== NEVER TAKEN
400090e8: 01 00 00 00 nop
handle->node = rtems_rfs_buffer_data (&handle->buffer);
400090ec: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
handle->node += handle->offset;
400090f0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
400090f4: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
400090f8: 83 28 e0 03 sll %g3, 3, %g1
400090fc: 82 20 40 03 sub %g1, %g3, %g1
40009100: 83 28 60 03 sll %g1, 3, %g1
40009104: 82 00 80 01 add %g2, %g1, %g1
40009108: 10 bf ff e9 b 400090ac <rtems_rfs_inode_load+0x50>
4000910c: c2 26 60 0c st %g1, [ %i1 + 0xc ]
40009110 <rtems_rfs_inode_open>:
{
40009110: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
40009114: 90 10 20 00 clr %o0
40009118: 40 00 06 ab call 4000abc4 <rtems_rfs_trace>
4000911c: 13 00 01 00 sethi %hi(0x40000), %o1
40009120: 80 a2 20 00 cmp %o0, 0
40009124: 32 80 00 31 bne,a 400091e8 <rtems_rfs_inode_open+0xd8> <== NEVER TAKEN
40009128: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
4000912c: 80 a6 60 00 cmp %i1, 0
40009130: 02 80 00 2b be 400091dc <rtems_rfs_inode_open+0xcc> <== NEVER TAKEN
40009134: 82 06 7f ff add %i1, -1, %g1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
40009138: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4000913c: 80 a0 40 02 cmp %g1, %g2
40009140: 18 80 00 27 bgu 400091dc <rtems_rfs_inode_open+0xcc> <== NEVER TAKEN
40009144: 80 a6 e0 00 cmp %i3, 0
group = gino / fs->group_inodes;
40009148: fa 06 20 2c ld [ %i0 + 0x2c ], %i5
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4000914c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40009150: c8 06 20 30 ld [ %i0 + 0x30 ], %g4
gino = gino % fs->group_inodes;
40009154: 81 80 20 00 wr %g0, %y
40009158: 01 00 00 00 nop
4000915c: 01 00 00 00 nop
40009160: 01 00 00 00 nop
40009164: 84 70 40 1d udiv %g1, %i5, %g2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40009168: 87 28 a0 02 sll %g2, 2, %g3
4000916c: 86 00 c0 02 add %g3, %g2, %g3
gino = gino % fs->group_inodes;
40009170: 84 58 80 1d smul %g2, %i5, %g2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40009174: 87 28 e0 04 sll %g3, 4, %g3
40009178: c6 07 00 03 ld [ %i4 + %g3 ], %g3
gino = gino % fs->group_inodes;
4000917c: 82 20 40 02 sub %g1, %g2, %g1
handle->ino = ino;
40009180: f2 26 a0 08 st %i1, [ %i2 + 8 ]
handle->offset = gino % fs->inodes_per_block;
40009184: 81 80 20 00 wr %g0, %y
40009188: 01 00 00 00 nop
4000918c: 01 00 00 00 nop
40009190: 01 00 00 00 nop
40009194: 84 70 40 04 udiv %g1, %g4, %g2
handle->node = NULL;
40009198: c0 26 a0 0c clr [ %i2 + 0xc ]
handle->offset = gino % fs->inodes_per_block;
4000919c: 88 58 80 04 smul %g2, %g4, %g4
handle->loads = 0;
400091a0: c0 26 a0 24 clr [ %i2 + 0x24 ]
handle->offset = gino % fs->inodes_per_block;
400091a4: 82 20 40 04 sub %g1, %g4, %g1
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
400091a8: 84 00 a0 02 add %g2, 2, %g2
handle->offset = gino % fs->inodes_per_block;
400091ac: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400091b0: 84 00 c0 02 add %g3, %g2, %g2
handle->dirty = false;
400091b4: c0 2e a0 10 clrb [ %i2 + 0x10 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
400091b8: 82 10 20 00 clr %g1
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400091bc: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
handle->bnum = 0;
400091c0: c0 26 a0 14 clr [ %i2 + 0x14 ]
if ((rc == 0) && load)
400091c4: 12 80 00 04 bne 400091d4 <rtems_rfs_inode_open+0xc4> <== ALWAYS TAKEN
400091c8: c0 26 a0 18 clr [ %i2 + 0x18 ]
}
400091cc: 81 c7 e0 08 ret <== NOT EXECUTED
400091d0: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, handle);
400091d4: 7f ff ff a2 call 4000905c <rtems_rfs_inode_load>
400091d8: 93 e8 00 1a restore %g0, %i2, %o1
return EINVAL;
400091dc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
}
400091e0: 81 c7 e0 08 ret <== NOT EXECUTED
400091e4: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
400091e8: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
400091ec: 7f ff e6 c3 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400091f0: 90 12 21 40 or %o0, 0x140, %o0 ! 40022d40 <IMFS_node_control_sym_link+0xfb8><== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
400091f4: 10 bf ff cf b 40009130 <rtems_rfs_inode_open+0x20> <== NOT EXECUTED
400091f8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400094b8 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
400094b8: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
400094bc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400094c0: 80 a0 60 00 cmp %g1, 0
400094c4: 02 80 00 26 be 4000955c <rtems_rfs_inode_time_stamp_now+0xa4> <== NEVER TAKEN
400094c8: ba 10 00 18 mov %i0, %i5
return ENXIO;
now = time (NULL);
400094cc: 40 00 59 4e call 4001fa04 <time>
400094d0: 90 10 20 00 clr %o0
if (atime)
400094d4: 80 a6 60 00 cmp %i1, 0
400094d8: 32 80 00 14 bne,a 40009528 <rtems_rfs_inode_time_stamp_now+0x70> <== ALWAYS TAKEN
400094dc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
400094e0: 80 a6 a0 00 cmp %i2, 0
400094e4: 02 80 00 0f be 40009520 <rtems_rfs_inode_time_stamp_now+0x68> <== NEVER TAKEN
400094e8: b0 10 20 00 clr %i0
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
400094ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400094f0: 85 32 60 18 srl %o1, 0x18, %g2
400094f4: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
400094f8: 85 32 60 10 srl %o1, 0x10, %g2
400094fc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40009500: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40009504: 85 32 60 08 srl %o1, 8, %g2
40009508: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000950c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40009510: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40009514: d2 28 60 17 stb %o1, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40009518: 82 10 20 01 mov 1, %g1
4000951c: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
}
40009520: 81 c7 e0 08 ret
40009524: 81 e8 00 00 restore
rtems_rfs_write_u32 (&handle->node->atime, atime);
40009528: 85 32 60 18 srl %o1, 0x18, %g2
4000952c: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
40009530: 83 32 60 10 srl %o1, 0x10, %g1
40009534: c4 06 20 0c ld [ %i0 + 0xc ], %g2
40009538: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
4000953c: 83 32 60 08 srl %o1, 8, %g1
40009540: c4 06 20 0c ld [ %i0 + 0xc ], %g2
40009544: c2 28 a0 12 stb %g1, [ %g2 + 0x12 ]
40009548: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000954c: d2 28 60 13 stb %o1, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40009550: 82 10 20 01 mov 1, %g1
}
40009554: 10 bf ff e3 b 400094e0 <rtems_rfs_inode_time_stamp_now+0x28>
40009558: c2 2e 20 10 stb %g1, [ %i0 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
4000955c: 81 c7 e0 08 ret <== NOT EXECUTED
40009560: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
400091fc <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
400091fc: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
40009200: 90 10 20 00 clr %o0
40009204: 40 00 06 70 call 4000abc4 <rtems_rfs_trace>
40009208: 13 00 08 00 sethi %hi(0x200000), %o1
4000920c: 80 a2 20 00 cmp %o0, 0
40009210: 02 80 00 0c be 40009240 <rtems_rfs_inode_unload+0x44> <== ALWAYS TAKEN
40009214: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40009218: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4000921c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009220: 02 80 00 22 be 400092a8 <rtems_rfs_inode_unload+0xac> <== NOT EXECUTED
40009224: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40009228: 17 10 00 8b sethi %hi(0x40022c00), %o3 <== NOT EXECUTED
4000922c: 96 12 e0 f8 or %o3, 0xf8, %o3 ! 40022cf8 <IMFS_node_control_sym_link+0xf70><== NOT EXECUTED
40009230: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
40009234: 7f ff e6 b1 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40009238: 90 12 21 60 or %o0, 0x160, %o0 ! 40022d60 <IMFS_node_control_sym_link+0xfd8><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
4000923c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40009240: 80 a0 60 00 cmp %g1, 0
40009244: 22 80 00 0b be,a 40009270 <rtems_rfs_inode_unload+0x74>
40009248: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
4000924c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40009250: 80 a0 60 00 cmp %g1, 0
40009254: 02 80 00 07 be 40009270 <rtems_rfs_inode_unload+0x74> <== NEVER TAKEN
40009258: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
4000925c: 82 00 7f ff add %g1, -1, %g1
if (handle->loads == 0)
40009260: 80 a0 60 00 cmp %g1, 0
40009264: 02 80 00 05 be 40009278 <rtems_rfs_inode_unload+0x7c>
40009268: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
int rc = 0;
4000926c: 90 10 20 00 clr %o0
handle->node = NULL;
}
}
return rc;
}
40009270: 81 c7 e0 08 ret
40009274: 91 e8 00 08 restore %g0, %o0, %o0
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
40009278: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
4000927c: 80 a0 60 00 cmp %g1, 0
40009280: 02 80 00 04 be 40009290 <rtems_rfs_inode_unload+0x94>
40009284: 80 a6 a0 00 cmp %i2, 0
40009288: 12 80 00 0b bne 400092b4 <rtems_rfs_inode_unload+0xb8> <== ALWAYS TAKEN
4000928c: 01 00 00 00 nop
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40009290: 92 06 60 10 add %i1, 0x10, %o1
40009294: 7f ff f8 ac call 40007544 <rtems_rfs_buffer_handle_release>
40009298: 90 10 00 18 mov %i0, %o0
handle->node = NULL;
4000929c: c0 26 60 0c clr [ %i1 + 0xc ]
}
400092a0: 81 c7 e0 08 ret
400092a4: 91 e8 00 08 restore %g0, %o0, %o0
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
400092a8: 17 10 00 8b sethi %hi(0x40022c00), %o3 <== NOT EXECUTED
400092ac: 10 bf ff e1 b 40009230 <rtems_rfs_inode_unload+0x34> <== NOT EXECUTED
400092b0: 96 12 e1 00 or %o3, 0x100, %o3 ! 40022d00 <IMFS_node_control_sym_link+0xf78><== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
400092b4: 40 00 59 d4 call 4001fa04 <time>
400092b8: 90 10 20 00 clr %o0
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
400092bc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400092c0: 85 32 60 18 srl %o1, 0x18, %g2
400092c4: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
400092c8: 85 32 60 10 srl %o1, 0x10, %g2
400092cc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400092d0: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
400092d4: 85 32 60 08 srl %o1, 8, %g2
400092d8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400092dc: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
400092e0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400092e4: d2 28 60 1b stb %o1, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400092e8: 82 10 20 01 mov 1, %g1
}
400092ec: 10 bf ff e9 b 40009290 <rtems_rfs_inode_unload+0x94>
400092f0: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
40017e04 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
40017e04: 9d e3 bf 50 save %sp, -176, %sp
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
40017e08: 90 10 20 00 clr %o0
40017e0c: 7f ff cb 6e call 4000abc4 <rtems_rfs_trace>
40017e10: 13 00 40 00 sethi %hi(0x1000000), %o1
40017e14: 80 a2 20 00 cmp %o0, 0
40017e18: 12 80 00 51 bne 40017f5c <rtems_rfs_link+0x158> <== NEVER TAKEN
40017e1c: 96 10 20 01 mov 1, %o3
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40017e20: 94 07 bf d8 add %fp, -40, %o2
40017e24: 92 10 00 1c mov %i4, %o1
40017e28: 7f ff c4 ba call 40009110 <rtems_rfs_inode_open>
40017e2c: 90 10 00 18 mov %i0, %o0
if (rc)
40017e30: a0 92 20 00 orcc %o0, 0, %l0
40017e34: 12 80 00 40 bne 40017f34 <rtems_rfs_link+0x130> <== NEVER TAKEN
40017e38: 80 a7 60 00 cmp %i5, 0
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
40017e3c: 12 80 00 0a bne 40017e64 <rtems_rfs_link+0x60>
40017e40: c2 07 bf e4 ld [ %fp + -28 ], %g1
40017e44: 05 00 00 3c sethi %hi(0xf000), %g2
40017e48: c2 08 60 02 ldub [ %g1 + 2 ], %g1
40017e4c: 83 28 60 08 sll %g1, 8, %g1
40017e50: 82 08 40 02 and %g1, %g2, %g1
40017e54: 05 00 00 10 sethi %hi(0x4000), %g2
40017e58: 80 a0 40 02 cmp %g1, %g2
40017e5c: 02 80 00 5f be 40017fd8 <rtems_rfs_link+0x1d4> <== NEVER TAKEN
40017e60: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40017e64: 96 10 20 01 mov 1, %o3
40017e68: 94 07 bf b0 add %fp, -80, %o2
40017e6c: 92 10 00 1b mov %i3, %o1
40017e70: 7f ff c4 a8 call 40009110 <rtems_rfs_inode_open>
40017e74: 90 10 00 18 mov %i0, %o0
if (rc)
40017e78: a0 92 20 00 orcc %o0, 0, %l0
40017e7c: 12 80 00 32 bne 40017f44 <rtems_rfs_link+0x140> <== NEVER TAKEN
40017e80: 98 10 00 1c mov %i4, %o4
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
40017e84: 96 10 00 1a mov %i2, %o3
40017e88: 94 10 00 19 mov %i1, %o2
40017e8c: 92 07 bf b0 add %fp, -80, %o1
40017e90: 7f ff f5 46 call 400153a8 <rtems_rfs_dir_add_entry>
40017e94: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40017e98: a0 92 20 00 orcc %o0, 0, %l0
40017e9c: 14 80 00 44 bg 40017fac <rtems_rfs_link+0x1a8> <== NEVER TAKEN
40017ea0: c4 07 bf e4 ld [ %fp + -28 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
40017ea4: c6 08 80 00 ldub [ %g2 ], %g3
40017ea8: 87 28 e0 08 sll %g3, 8, %g3
40017eac: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
40017eb0: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
40017eb4: 07 00 00 3f sethi %hi(0xfc00), %g3
40017eb8: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_ISR_Stack_size+0xefff>
40017ebc: 80 a0 40 03 cmp %g1, %g3
40017ec0: 22 80 00 44 be,a 40017fd0 <rtems_rfs_link+0x1cc> <== NEVER TAKEN
40017ec4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
40017ec8: 82 00 60 01 inc %g1
rtems_rfs_write_u16 (&handle->node->links, links);
40017ecc: 87 28 60 10 sll %g1, 0x10, %g3
40017ed0: 87 30 e0 18 srl %g3, 0x18, %g3
40017ed4: c6 28 80 00 stb %g3, [ %g2 ]
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40017ed8: 92 10 20 01 mov 1, %o1
40017edc: c4 07 bf e4 ld [ %fp + -28 ], %g2
40017ee0: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40017ee4: 82 10 20 01 mov 1, %g1
40017ee8: 94 10 20 01 mov 1, %o2
40017eec: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40017ef0: 7f ff c5 72 call 400094b8 <rtems_rfs_inode_time_stamp_now>
40017ef4: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
40017ef8: 92 07 bf b0 add %fp, -80, %o1
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40017efc: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40017f00: 80 a4 20 00 cmp %l0, 0
40017f04: 14 80 00 0e bg 40017f3c <rtems_rfs_link+0x138> <== NEVER TAKEN
40017f08: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
40017f0c: 7f ff c4 fa call 400092f4 <rtems_rfs_inode_close>
40017f10: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
40017f14: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
40017f18: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40017f1c: 80 a4 20 00 cmp %l0, 0
40017f20: 14 80 00 0b bg 40017f4c <rtems_rfs_link+0x148> <== NEVER TAKEN
40017f24: 90 10 00 18 mov %i0, %o0
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
40017f28: 7f ff c4 f3 call 400092f4 <rtems_rfs_inode_close>
40017f2c: 01 00 00 00 nop
40017f30: a0 10 00 08 mov %o0, %l0
return rc;
}
40017f34: 81 c7 e0 08 ret
40017f38: 91 e8 00 10 restore %g0, %l0, %o0
rtems_rfs_inode_close (fs, &parent_inode);
40017f3c: 7f ff c4 ee call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40017f40: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40017f44: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40017f48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40017f4c: 7f ff c4 ea call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40017f50: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
}
40017f54: 81 c7 e0 08 ret <== NOT EXECUTED
40017f58: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
40017f5c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40017f60: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40017f64: 7f ff ab 65 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017f68: 90 12 20 40 or %o0, 0x40, %o0 ! 40024440 <IMFS_LIMITS_AND_OPTIONS+0xf00><== NOT EXECUTED
for (c = 0; c < length; c++)
40017f6c: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
40017f70: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40017f74: 04 80 00 08 ble 40017f94 <rtems_rfs_link+0x190> <== NOT EXECUTED
40017f78: a2 06 80 19 add %i2, %i1, %l1 <== NOT EXECUTED
printf ("%c", name[c]);
40017f7c: 40 00 1a 8d call 4001e9b0 <putchar> <== NOT EXECUTED
40017f80: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
for (c = 0; c < length; c++)
40017f84: a0 04 20 01 inc %l0 <== NOT EXECUTED
40017f88: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
40017f8c: 12 bf ff fc bne 40017f7c <rtems_rfs_link+0x178> <== NOT EXECUTED
40017f90: 01 00 00 00 nop <== NOT EXECUTED
printf ("(%" PRIu32 ")\n", target);
40017f94: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40017f98: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40017f9c: 7f ff ab 57 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40017fa0: 90 12 20 60 or %o0, 0x60, %o0 ! 40024460 <IMFS_LIMITS_AND_OPTIONS+0xf20><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40017fa4: 10 bf ff 9f b 40017e20 <rtems_rfs_link+0x1c> <== NOT EXECUTED
40017fa8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40017fac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40017fb0: 7f ff c4 d1 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40017fb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40017fb8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40017fbc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40017fc0: 7f ff c4 cd call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40017fc4: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
}
40017fc8: 81 c7 e0 08 ret <== NOT EXECUTED
40017fcc: 81 e8 00 00 restore <== NOT EXECUTED
40017fd0: 10 bf ff c1 b 40017ed4 <rtems_rfs_link+0xd0> <== NOT EXECUTED
40017fd4: 86 10 20 00 clr %g3 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40017fd8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40017fdc: 7f ff c4 c6 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40017fe0: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
return ENOTSUP;
40017fe4: 30 bf ff d4 b,a 40017f34 <rtems_rfs_link+0x130> <== NOT EXECUTED
4000a688 <rtems_rfs_rtems_fdatasync>:
{
4000a688: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4000a68c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
4000a690: 7f ff f4 22 call 40007718 <rtems_rfs_buffer_sync> <== NOT EXECUTED
4000a694: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
4000a698: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000a69c: 12 80 00 04 bne 4000a6ac <rtems_rfs_rtems_fdatasync+0x24> <== NOT EXECUTED
4000a6a0: 01 00 00 00 nop <== NOT EXECUTED
}
4000a6a4: 81 c7 e0 08 ret <== NOT EXECUTED
4000a6a8: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
4000a6ac: 40 00 4f 1c call 4001e31c <__errno> <== NOT EXECUTED
4000a6b0: 01 00 00 00 nop <== NOT EXECUTED
4000a6b4: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
}
4000a6b8: 81 c7 e0 08 ret <== NOT EXECUTED
4000a6bc: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4000a158 <rtems_rfs_rtems_fstat>:
{
4000a158: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4000a15c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000a160: fa 00 60 08 ld [ %g1 + 8 ], %i5
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4000a164: d2 06 20 08 ld [ %i0 + 8 ], %o1
4000a168: 96 10 20 01 mov 1, %o3
4000a16c: 94 07 bf d8 add %fp, -40, %o2
4000a170: 7f ff fb e8 call 40009110 <rtems_rfs_inode_open>
4000a174: 90 10 00 1d mov %i5, %o0
if (rc)
4000a178: b0 92 20 00 orcc %o0, 0, %i0
4000a17c: 12 80 00 b1 bne 4000a440 <rtems_rfs_rtems_fstat+0x2e8> <== NEVER TAKEN
4000a180: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_read_u16 (&handle->node->mode);
4000a184: c4 08 60 02 ldub [ %g1 + 2 ], %g2
4000a188: 85 28 a0 08 sll %g2, 8, %g2
4000a18c: d0 08 60 03 ldub [ %g1 + 3 ], %o0
4000a190: 90 12 00 02 or %o0, %g2, %o0
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
4000a194: 07 00 00 08 sethi %hi(0x2000), %g3
4000a198: 05 3f ff ec sethi %hi(0xffffb000), %g2
4000a19c: 84 0a 00 02 and %o0, %g2, %g2
4000a1a0: 80 a0 80 03 cmp %g2, %g3
4000a1a4: 22 80 00 47 be,a 4000a2c0 <rtems_rfs_rtems_fstat+0x168> <== NEVER TAKEN
4000a1a8: da 08 60 20 ldub [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
4000a1ac: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000a1b0: c2 26 60 04 st %g1, [ %i1 + 4 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
4000a1b4: c2 07 bf e0 ld [ %fp + -32 ], %g1
4000a1b8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
4000a1bc: c0 26 40 00 clr [ %i1 ]
buf->st_mode = rtems_rfs_rtems_mode (mode);
4000a1c0: 40 00 02 7f call 4000abbc <rtems_rfs_rtems_mode>
4000a1c4: c0 26 60 08 clr [ %i1 + 8 ]
4000a1c8: d0 26 60 10 st %o0, [ %i1 + 0x10 ]
links = rtems_rfs_read_u16 (&handle->node->links);
4000a1cc: c4 07 bf e4 ld [ %fp + -28 ], %g2
4000a1d0: c6 08 80 00 ldub [ %g2 ], %g3
4000a1d4: 87 28 e0 08 sll %g3, 8, %g3
4000a1d8: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
4000a1dc: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
4000a1e0: 07 00 00 3f sethi %hi(0xfc00), %g3
4000a1e4: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_ISR_Stack_size+0xefff>
4000a1e8: 80 a0 40 03 cmp %g1, %g3
4000a1ec: 12 80 00 03 bne 4000a1f8 <rtems_rfs_rtems_fstat+0xa0> <== ALWAYS TAKEN
4000a1f0: 88 10 00 01 mov %g1, %g4
links = 0;
4000a1f4: 88 10 20 00 clr %g4 <== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4000a1f8: c8 36 60 14 sth %g4, [ %i1 + 0x14 ]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
4000a1fc: 90 10 00 1d mov %i5, %o0
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4000a200: c6 08 a0 06 ldub [ %g2 + 6 ], %g3
4000a204: c2 08 a0 07 ldub [ %g2 + 7 ], %g1
4000a208: 87 28 e0 08 sll %g3, 8, %g3
4000a20c: 82 10 40 03 or %g1, %g3, %g1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
4000a210: c2 36 60 16 sth %g1, [ %i1 + 0x16 ]
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4000a214: c2 08 a0 05 ldub [ %g2 + 5 ], %g1
4000a218: c6 08 a0 04 ldub [ %g2 + 4 ], %g3
4000a21c: 85 28 e0 18 sll %g3, 0x18, %g2
4000a220: 83 28 60 10 sll %g1, 0x10, %g1
4000a224: 82 10 40 02 or %g1, %g2, %g1
4000a228: 83 30 60 10 srl %g1, 0x10, %g1
4000a22c: c2 36 60 18 sth %g1, [ %i1 + 0x18 ]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
4000a230: 40 00 34 a2 call 400174b8 <rtems_rfs_file_get_shared>
4000a234: d2 07 bf e0 ld [ %fp + -32 ], %o1
if (shared)
4000a238: 80 a2 20 00 cmp %o0, 0
4000a23c: 02 80 00 3b be 4000a328 <rtems_rfs_rtems_fstat+0x1d0>
4000a240: c2 07 bf e4 ld [ %fp + -28 ], %g1
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4000a244: c4 02 20 94 ld [ %o0 + 0x94 ], %g2
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4000a248: c2 02 20 84 ld [ %o0 + 0x84 ], %g1
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4000a24c: c8 02 20 8c ld [ %o0 + 0x8c ], %g4
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4000a250: c6 02 20 90 ld [ %o0 + 0x90 ], %g3
4000a254: c6 26 60 44 st %g3, [ %i1 + 0x44 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4000a258: c4 26 60 54 st %g2, [ %i1 + 0x54 ]
if (S_ISLNK (buf->st_mode))
4000a25c: 05 00 00 3c sethi %hi(0xf000), %g2
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4000a260: c2 26 60 64 st %g1, [ %i1 + 0x64 ]
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4000a264: c0 26 60 30 clr [ %i1 + 0x30 ]
4000a268: c8 26 60 34 st %g4, [ %i1 + 0x34 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4000a26c: c0 26 60 40 clr [ %i1 + 0x40 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4000a270: c0 26 60 50 clr [ %i1 + 0x50 ]
if (S_ISLNK (buf->st_mode))
4000a274: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000a278: 82 08 40 02 and %g1, %g2, %g1
4000a27c: 05 00 00 28 sethi %hi(0xa000), %g2
4000a280: 80 a0 40 02 cmp %g1, %g2
4000a284: 12 80 00 25 bne 4000a318 <rtems_rfs_rtems_fstat+0x1c0> <== ALWAYS TAKEN
4000a288: 92 02 20 84 add %o0, 0x84, %o1
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
4000a28c: c2 12 20 8a lduh [ %o0 + 0x8a ], %g1 <== NOT EXECUTED
4000a290: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
4000a294: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4000a298: 90 10 00 1d mov %i5, %o0
buf->st_blksize = rtems_rfs_fs_block_size (fs);
4000a29c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000a2a0: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
rc = rtems_rfs_inode_close (fs, &inode);
4000a2a4: 7f ff fc 14 call 400092f4 <rtems_rfs_inode_close>
4000a2a8: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4000a2ac: ba 92 20 00 orcc %o0, 0, %i5
4000a2b0: 14 80 00 5f bg 4000a42c <rtems_rfs_rtems_fstat+0x2d4> <== NEVER TAKEN
4000a2b4: 01 00 00 00 nop
}
4000a2b8: 81 c7 e0 08 ret
4000a2bc: 81 e8 00 00 restore
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4000a2c0: c6 08 60 1d ldub [ %g1 + 0x1d ], %g3 <== NOT EXECUTED
4000a2c4: f8 08 60 21 ldub [ %g1 + 0x21 ], %i4 <== NOT EXECUTED
4000a2c8: c8 08 60 22 ldub [ %g1 + 0x22 ], %g4 <== NOT EXECUTED
4000a2cc: f4 08 60 23 ldub [ %g1 + 0x23 ], %i2 <== NOT EXECUTED
4000a2d0: de 08 60 1c ldub [ %g1 + 0x1c ], %o7 <== NOT EXECUTED
4000a2d4: c4 08 60 1e ldub [ %g1 + 0x1e ], %g2 <== NOT EXECUTED
4000a2d8: f6 08 60 1f ldub [ %g1 + 0x1f ], %i3 <== NOT EXECUTED
4000a2dc: 83 2b 60 18 sll %o5, 0x18, %g1 <== NOT EXECUTED
4000a2e0: b9 2f 20 10 sll %i4, 0x10, %i4 <== NOT EXECUTED
4000a2e4: b8 17 00 01 or %i4, %g1, %i4 <== NOT EXECUTED
4000a2e8: 83 28 e0 10 sll %g3, 0x10, %g1 <== NOT EXECUTED
4000a2ec: 89 29 20 08 sll %g4, 8, %g4 <== NOT EXECUTED
4000a2f0: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000a2f4: 88 11 00 1c or %g4, %i4, %g4 <== NOT EXECUTED
4000a2f8: 86 10 40 0f or %g1, %o7, %g3 <== NOT EXECUTED
4000a2fc: 88 16 80 04 or %i2, %g4, %g4 <== NOT EXECUTED
4000a300: 83 28 a0 08 sll %g2, 8, %g1 <== NOT EXECUTED
buf->st_rdev =
4000a304: c8 26 60 24 st %g4, [ %i1 + 0x24 ] <== NOT EXECUTED
4000a308: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED
4000a30c: 82 16 c0 01 or %i3, %g1, %g1 <== NOT EXECUTED
4000a310: 10 bf ff a7 b 4000a1ac <rtems_rfs_rtems_fstat+0x54> <== NOT EXECUTED
4000a314: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
4000a318: 40 00 27 72 call 400140e0 <rtems_rfs_block_get_size>
4000a31c: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
4000a320: 10 bf ff de b 4000a298 <rtems_rfs_rtems_fstat+0x140>
4000a324: d0 3e 60 28 std %o0, [ %i1 + 0x28 ]
return rtems_rfs_read_u32 (&handle->node->atime);
4000a328: c8 08 60 13 ldub [ %g1 + 0x13 ], %g4
4000a32c: f8 08 60 10 ldub [ %g1 + 0x10 ], %i4
4000a330: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
4000a334: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
4000a338: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
4000a33c: c0 26 60 30 clr [ %i1 + 0x30 ]
4000a340: 87 28 e0 10 sll %g3, 0x10, %g3
4000a344: 85 28 a0 08 sll %g2, 8, %g2
4000a348: 86 10 c0 1c or %g3, %i4, %g3
4000a34c: 84 10 80 03 or %g2, %g3, %g2
4000a350: 84 11 00 02 or %g4, %g2, %g2
4000a354: c4 26 60 34 st %g2, [ %i1 + 0x34 ]
return rtems_rfs_read_u32 (&handle->node->mtime);
4000a358: c8 08 60 17 ldub [ %g1 + 0x17 ], %g4
4000a35c: f8 08 60 14 ldub [ %g1 + 0x14 ], %i4
4000a360: c6 08 60 15 ldub [ %g1 + 0x15 ], %g3
4000a364: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
4000a368: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
4000a36c: c0 26 60 40 clr [ %i1 + 0x40 ]
4000a370: 87 28 e0 10 sll %g3, 0x10, %g3
4000a374: 85 28 a0 08 sll %g2, 8, %g2
4000a378: 86 10 c0 1c or %g3, %i4, %g3
4000a37c: 84 10 80 03 or %g2, %g3, %g2
4000a380: 84 11 00 02 or %g4, %g2, %g2
4000a384: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
return rtems_rfs_read_u32 (&handle->node->ctime);
4000a388: c8 08 60 1b ldub [ %g1 + 0x1b ], %g4
4000a38c: f8 08 60 18 ldub [ %g1 + 0x18 ], %i4
4000a390: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
4000a394: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
4000a398: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
4000a39c: c0 26 60 50 clr [ %i1 + 0x50 ]
4000a3a0: 87 28 e0 10 sll %g3, 0x10, %g3
4000a3a4: 85 28 a0 08 sll %g2, 8, %g2
4000a3a8: 86 10 c0 1c or %g3, %i4, %g3
4000a3ac: 84 10 80 03 or %g2, %g3, %g2
4000a3b0: 84 11 00 02 or %g4, %g2, %g2
4000a3b4: c4 26 60 54 st %g2, [ %i1 + 0x54 ]
return rtems_rfs_read_u32 (&handle->node->block_count);
4000a3b8: f8 08 60 0c ldub [ %g1 + 0xc ], %i4
4000a3bc: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4000a3c0: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
4000a3c4: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
4000a3c8: b9 2f 20 18 sll %i4, 0x18, %i4
4000a3cc: 87 28 e0 10 sll %g3, 0x10, %g3
4000a3d0: 85 28 a0 08 sll %g2, 8, %g2
4000a3d4: 86 10 c0 1c or %g3, %i4, %g3
4000a3d8: 84 10 80 03 or %g2, %g3, %g2
4000a3dc: 84 11 00 02 or %g4, %g2, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
4000a3e0: c4 26 60 64 st %g2, [ %i1 + 0x64 ]
if (S_ISLNK (buf->st_mode))
4000a3e4: 07 00 00 3c sethi %hi(0xf000), %g3
4000a3e8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4000a3ec: 84 08 80 03 and %g2, %g3, %g2
4000a3f0: 07 00 00 28 sethi %hi(0xa000), %g3
4000a3f4: 80 a0 80 03 cmp %g2, %g3
4000a3f8: 12 80 00 09 bne 4000a41c <rtems_rfs_rtems_fstat+0x2c4>
4000a3fc: 92 07 bf d8 add %fp, -40, %o1
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
4000a400: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4000a404: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
4000a408: 85 28 a0 08 sll %g2, 8, %g2
4000a40c: c0 26 60 28 clr [ %i1 + 0x28 ]
4000a410: 82 10 40 02 or %g1, %g2, %g1
4000a414: 10 bf ff a1 b 4000a298 <rtems_rfs_rtems_fstat+0x140>
4000a418: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
4000a41c: 7f ff fd 83 call 40009a28 <rtems_rfs_inode_get_size>
4000a420: 90 10 00 1d mov %i5, %o0
4000a424: 10 bf ff 9d b 4000a298 <rtems_rfs_rtems_fstat+0x140>
4000a428: d0 3e 60 28 std %o0, [ %i1 + 0x28 ]
return rtems_rfs_rtems_error ("stat: closing inode", rc);
4000a42c: 40 00 4f bc call 4001e31c <__errno> <== NOT EXECUTED
4000a430: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000a434: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
4000a438: 81 c7 e0 08 ret <== NOT EXECUTED
4000a43c: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
4000a440: 40 00 4f b7 call 4001e31c <__errno> <== NOT EXECUTED
4000a444: 01 00 00 00 nop <== NOT EXECUTED
4000a448: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
4000a44c: 81 c7 e0 08 ret <== NOT EXECUTED
4000a450: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4000a6c0 <rtems_rfs_rtems_initialise>:
{
4000a6c0: 9d e3 bf 98 save %sp, -104, %sp
uint32_t flags = 0;
4000a6c4: ba 10 20 00 clr %i5
{
4000a6c8: a2 10 00 18 mov %i0, %l1
while (options)
4000a6cc: 80 a6 60 00 cmp %i1, 0
4000a6d0: 02 80 00 22 be 4000a758 <rtems_rfs_rtems_initialise+0x98> <== ALWAYS TAKEN
4000a6d4: b0 10 20 05 mov 5, %i0
printf ("options=%s\n", options);
4000a6d8: 35 10 00 8b sethi %hi(0x40022c00), %i2 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4000a6dc: 37 10 00 8b sethi %hi(0x40022c00), %i3 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4000a6e0: 39 10 00 8b sethi %hi(0x40022c00), %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4000a6e4: 21 10 00 8b sethi %hi(0x40022c00), %l0 <== NOT EXECUTED
printf ("options=%s\n", options);
4000a6e8: b4 16 a2 a0 or %i2, 0x2a0, %i2 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4000a6ec: b6 16 e2 b0 or %i3, 0x2b0, %i3 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4000a6f0: b8 17 22 c0 or %i4, 0x2c0, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4000a6f4: a0 14 22 d0 or %l0, 0x2d0, %l0 <== NOT EXECUTED
printf ("options=%s\n", options);
4000a6f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000a6fc: 7f ff e1 7f call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000a700: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4000a704: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000a708: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
4000a70c: 40 00 53 f1 call 4001f6d0 <strncmp> <== NOT EXECUTED
4000a710: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4000a714: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4000a718: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4000a71c: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4000a720: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a724: 12 80 00 34 bne 4000a7f4 <rtems_rfs_rtems_initialise+0x134> <== NOT EXECUTED
4000a728: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
4000a72c: ba 17 60 01 or %i5, 1, %i5 <== NOT EXECUTED
options = strchr (options, ',');
4000a730: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000a734: 40 00 51 6b call 4001ece0 <strchr> <== NOT EXECUTED
4000a738: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
4000a73c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000a740: 02 80 00 07 be 4000a75c <rtems_rfs_rtems_initialise+0x9c> <== NOT EXECUTED
4000a744: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
if (*options == '\0')
4000a748: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
4000a74c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a750: 12 bf ff ea bne 4000a6f8 <rtems_rfs_rtems_initialise+0x38> <== NOT EXECUTED
4000a754: b2 02 20 01 add %o0, 1, %i1 <== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4000a758: 92 10 20 01 mov 1, %o1
4000a75c: 40 00 21 1d call 40012bd0 <calloc>
4000a760: 90 10 20 18 mov 0x18, %o0
if (!rtems)
4000a764: b8 92 20 00 orcc %o0, 0, %i4
4000a768: 02 80 00 54 be 4000a8b8 <rtems_rfs_rtems_initialise+0x1f8> <== NEVER TAKEN
4000a76c: 01 00 00 00 nop
rc = rtems_rfs_mutex_create (&rtems->access);
4000a770: 40 00 38 51 call 400188b4 <rtems_rfs_mutex_create>
4000a774: 01 00 00 00 nop
4000a778: b6 10 00 08 mov %o0, %i3
if (rc > 0)
4000a77c: 80 a6 e0 00 cmp %i3, 0
4000a780: 14 80 00 47 bg 4000a89c <rtems_rfs_rtems_initialise+0x1dc> <== NEVER TAKEN
4000a784: 90 10 00 1c mov %i4, %o0
_Mutex_recursive_Acquire( mutex );
4000a788: 40 00 08 f3 call 4000cb54 <_Mutex_recursive_Acquire>
4000a78c: 01 00 00 00 nop
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
4000a790: d0 04 60 38 ld [ %l1 + 0x38 ], %o0
4000a794: 96 10 00 18 mov %i0, %o3
4000a798: 98 07 bf fc add %fp, -4, %o4
4000a79c: 94 10 00 1d mov %i5, %o2
4000a7a0: 40 00 33 65 call 40017534 <rtems_rfs_fs_open>
4000a7a4: 92 10 00 1c mov %i4, %o1
if (rc)
4000a7a8: b0 92 20 00 orcc %o0, 0, %i0
4000a7ac: 12 80 00 26 bne 4000a844 <rtems_rfs_rtems_initialise+0x184> <== NEVER TAKEN
4000a7b0: d0 07 bf fc ld [ %fp + -4 ], %o0
mt_entry->ops = &rtems_rfs_ops;
4000a7b4: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000a7b8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 40022ee0 <rtems_rfs_ops>
mt_entry->fs_info = fs;
4000a7bc: d0 24 60 08 st %o0, [ %l1 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
4000a7c0: c2 24 60 0c st %g1, [ %l1 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
4000a7c4: 82 10 20 01 mov 1, %g1
4000a7c8: c4 04 60 24 ld [ %l1 + 0x24 ], %g2
4000a7cc: c2 20 a0 08 st %g1, [ %g2 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
4000a7d0: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000a7d4: 82 10 63 74 or %g1, 0x374, %g1 ! 40022f74 <rtems_rfs_rtems_dir_handlers>
4000a7d8: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
4000a7dc: 7f ff f3 ed call 40007790 <rtems_rfs_buffers_release>
4000a7e0: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
_Mutex_recursive_Release( mutex );
4000a7e4: 40 00 09 01 call 4000cbe8 <_Mutex_recursive_Release>
4000a7e8: 90 10 00 1d mov %i5, %o0
}
4000a7ec: 81 c7 e0 08 ret
4000a7f0: 81 e8 00 00 restore
else if (strncmp (options, "no-local-cache",
4000a7f4: 40 00 53 b7 call 4001f6d0 <strncmp> <== NOT EXECUTED
4000a7f8: 01 00 00 00 nop <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4000a7fc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4000a800: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4000a804: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4000a808: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a80c: 12 80 00 04 bne 4000a81c <rtems_rfs_rtems_initialise+0x15c> <== NOT EXECUTED
4000a810: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000a814: 10 bf ff c8 b 4000a734 <rtems_rfs_rtems_initialise+0x74> <== NOT EXECUTED
4000a818: ba 17 60 02 or %i5, 2, %i5 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4000a81c: 40 00 53 ad call 4001f6d0 <strncmp> <== NOT EXECUTED
4000a820: 01 00 00 00 nop <== NOT EXECUTED
4000a824: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000a828: 12 80 00 17 bne 4000a884 <rtems_rfs_rtems_initialise+0x1c4> <== NOT EXECUTED
4000a82c: 94 10 20 00 clr %o2 <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
4000a830: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000a834: 40 00 54 6d call 4001f9e8 <strtoul> <== NOT EXECUTED
4000a838: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
4000a83c: 10 bf ff bd b 4000a730 <rtems_rfs_rtems_initialise+0x70> <== NOT EXECUTED
4000a840: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000a844: 40 00 08 e9 call 4000cbe8 <_Mutex_recursive_Release> <== NOT EXECUTED
4000a848: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
4000a84c: 40 00 38 25 call 400188e0 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
4000a850: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free (rtems);
4000a854: 7f ff e1 eb call 40003000 <free> <== NOT EXECUTED
4000a858: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
4000a85c: 40 00 4e b0 call 4001e31c <__errno> <== NOT EXECUTED
4000a860: 01 00 00 00 nop <== NOT EXECUTED
4000a864: 40 00 4e ae call 4001e31c <__errno> <== NOT EXECUTED
4000a868: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
4000a86c: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
4000a870: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4000a874: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000a878: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
4000a87c: 81 c7 e0 08 ret <== NOT EXECUTED
4000a880: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
4000a884: 40 00 4e a6 call 4001e31c <__errno> <== NOT EXECUTED
4000a888: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000a88c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000a890: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000a894: 81 c7 e0 08 ret <== NOT EXECUTED
4000a898: 81 e8 00 00 restore <== NOT EXECUTED
free (rtems);
4000a89c: 7f ff e1 d9 call 40003000 <free> <== NOT EXECUTED
4000a8a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
4000a8a4: 40 00 4e 9e call 4001e31c <__errno> <== NOT EXECUTED
4000a8a8: 01 00 00 00 nop <== NOT EXECUTED
4000a8ac: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
4000a8b0: 81 c7 e0 08 ret <== NOT EXECUTED
4000a8b4: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
4000a8b8: 40 00 4e 99 call 4001e31c <__errno> <== NOT EXECUTED
4000a8bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000a8c0: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000a8c4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000a8c8: 81 c7 e0 08 ret <== NOT EXECUTED
4000a8cc: 81 e8 00 00 restore <== NOT EXECUTED
4000aad4 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
4000aad4: 9d e3 bf a0 save %sp, -96, %sp
return rtems_rfs_read_u16 (&handle->node->mode);
4000aad8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4000aadc: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
4000aae0: d2 08 a0 03 ldub [ %g2 + 3 ], %o1
4000aae4: 83 28 60 08 sll %g1, 8, %g1
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
4000aae8: 05 00 00 10 sethi %hi(0x4000), %g2
4000aaec: 92 12 40 01 or %o1, %g1, %o1
4000aaf0: 82 0a 70 00 and %o1, -4096, %g1
4000aaf4: 80 a0 40 02 cmp %g1, %g2
4000aaf8: 02 80 00 1b be 4000ab64 <rtems_rfs_rtems_set_handlers+0x90>
4000aafc: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
4000ab00: 05 3f ff ec sethi %hi(0xffffb000), %g2
4000ab04: 07 00 00 08 sethi %hi(0x2000), %g3
4000ab08: 84 0a 40 02 and %o1, %g2, %g2
4000ab0c: 80 a0 80 03 cmp %g2, %g3
4000ab10: 12 80 00 09 bne 4000ab34 <rtems_rfs_rtems_set_handlers+0x60> <== ALWAYS TAKEN
4000ab14: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
4000ab18: 05 10 00 91 sethi %hi(0x40024400), %g2 <== NOT EXECUTED
4000ab1c: 84 10 a2 8c or %g2, 0x28c, %g2 ! 4002468c <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
4000ab20: c4 26 20 10 st %g2, [ %i0 + 0x10 ] <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
4000ab24: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
}
4000ab28: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
4000ab2c: 81 c7 e0 08 ret <== NOT EXECUTED
4000ab30: 81 e8 00 00 restore <== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
4000ab34: 80 a0 40 02 cmp %g1, %g2
4000ab38: 02 80 00 17 be 4000ab94 <rtems_rfs_rtems_set_handlers+0xc0>
4000ab3c: 05 00 00 20 sethi %hi(0x8000), %g2
else if (RTEMS_RFS_S_ISREG (mode))
4000ab40: 80 a0 40 02 cmp %g1, %g2
4000ab44: 12 80 00 0f bne 4000ab80 <rtems_rfs_rtems_set_handlers+0xac> <== NEVER TAKEN
4000ab48: 05 10 00 91 sethi %hi(0x40024400), %g2
return true;
4000ab4c: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (file);
4000ab50: 84 10 a2 cc or %g2, 0x2cc, %g2
4000ab54: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
4000ab58: b0 08 60 01 and %g1, 1, %i0
4000ab5c: 81 c7 e0 08 ret
4000ab60: 81 e8 00 00 restore
return true;
4000ab64: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (dir);
4000ab68: 05 10 00 8b sethi %hi(0x40022c00), %g2
4000ab6c: 84 10 a3 74 or %g2, 0x374, %g2 ! 40022f74 <rtems_rfs_rtems_dir_handlers>
4000ab70: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
4000ab74: b0 08 60 01 and %g1, 1, %i0
4000ab78: 81 c7 e0 08 ret
4000ab7c: 81 e8 00 00 restore
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
4000ab80: 11 10 00 8b sethi %hi(0x40022c00), %o0 <== NOT EXECUTED
4000ab84: 7f ff e0 5d call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4000ab88: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40022fb8 <rtems_rfs_rtems_dir_handlers+0x44><== NOT EXECUTED
return false;
4000ab8c: 10 bf ff e7 b 4000ab28 <rtems_rfs_rtems_set_handlers+0x54> <== NOT EXECUTED
4000ab90: 82 10 20 00 clr %g1 <== NOT EXECUTED
return true;
4000ab94: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (link);
4000ab98: 05 10 00 8b sethi %hi(0x40022c00), %g2
4000ab9c: 84 10 a3 2c or %g2, 0x32c, %g2 ! 40022f2c <rtems_rfs_rtems_link_handlers>
4000aba0: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
4000aba4: b0 08 60 01 and %g1, 1, %i0
4000aba8: 81 c7 e0 08 ret
4000abac: 81 e8 00 00 restore
4001845c <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001845c: 9d e3 bf 00 save %sp, -256, %sp
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
40018460: 90 10 20 02 mov 2, %o0
{
40018464: e2 17 a0 5e lduh [ %fp + 0x5e ], %l1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
40018468: 7f ff c9 d7 call 4000abc4 <rtems_rfs_trace>
4001846c: 92 10 20 00 clr %o1
40018470: 80 a2 20 00 cmp %o0, 0
40018474: 32 80 00 3f bne,a 40018570 <rtems_rfs_symlink+0x114> <== NEVER TAKEN
40018478: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
4001847c: c2 06 20 08 ld [ %i0 + 8 ], %g1
40018480: 80 a0 40 1c cmp %g1, %i4
40018484: 08 80 00 13 bleu 400184d0 <rtems_rfs_symlink+0x74> <== NEVER TAKEN
40018488: b4 10 20 5b mov 0x5b, %i2
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4001848c: 40 00 1c 67 call 4001f628 <strlen>
40018490: 90 10 00 19 mov %i1, %o0
40018494: 82 07 bf 74 add %fp, -140, %g1
40018498: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
4001849c: 96 10 00 08 mov %o0, %o3
400184a0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
400184a4: 9a 10 20 01 mov 1, %o5
400184a8: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
400184ac: 19 00 00 28 sethi %hi(0xa000), %o4
400184b0: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
400184b4: 98 13 21 ff or %o4, 0x1ff, %o4
400184b8: 94 10 00 19 mov %i1, %o2
400184bc: 7f ff c4 78 call 4000969c <rtems_rfs_inode_create>
400184c0: 90 10 00 18 mov %i0, %o0
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
400184c4: b4 92 20 00 orcc %o0, 0, %i2
400184c8: 04 80 00 04 ble 400184d8 <rtems_rfs_symlink+0x7c> <== ALWAYS TAKEN
400184cc: d2 07 bf 74 ld [ %fp + -140 ], %o1
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
400184d0: 81 c7 e0 08 ret
400184d4: 91 e8 00 1a restore %g0, %i2, %o0
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400184d8: 96 10 20 01 mov 1, %o3
400184dc: 94 07 bf 88 add %fp, -120, %o2
400184e0: 7f ff c3 0c call 40009110 <rtems_rfs_inode_open>
400184e4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400184e8: b4 92 20 00 orcc %o0, 0, %i2
400184ec: 14 bf ff f9 bg 400184d0 <rtems_rfs_symlink+0x74> <== NEVER TAKEN
400184f0: 80 a7 20 13 cmp %i4, 0x13
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
400184f4: 18 80 00 3b bgu 400185e0 <rtems_rfs_symlink+0x184> <== NEVER TAKEN
400184f8: 92 07 bf 88 add %fp, -120, %o1
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
400184fc: fa 07 bf 94 ld [ %fp + -108 ], %i5
40018500: 82 07 60 1c add %i5, 0x1c, %g1
40018504: 94 10 20 14 mov 0x14, %o2
40018508: 90 10 00 01 mov %g1, %o0
4001850c: 40 00 18 e4 call 4001e89c <memset>
40018510: 92 10 20 00 clr %o1
memcpy (inode.node->data.name, link, link_length);
40018514: 94 10 00 1c mov %i4, %o2
40018518: 40 00 18 57 call 4001e674 <memcpy>
4001851c: 92 10 00 1b mov %i3, %o1
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
40018520: c0 2f 60 0c clrb [ %i5 + 0xc ]
40018524: c2 07 bf 94 ld [ %fp + -108 ], %g1
40018528: c0 28 60 0d clrb [ %g1 + 0xd ]
4001852c: c2 07 bf 94 ld [ %fp + -108 ], %g1
40018530: c0 28 60 0e clrb [ %g1 + 0xe ]
40018534: c2 07 bf 94 ld [ %fp + -108 ], %g1
40018538: c0 28 60 0f clrb [ %g1 + 0xf ]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001853c: 83 2f 20 10 sll %i4, 0x10, %g1
40018540: c4 07 bf 94 ld [ %fp + -108 ], %g2
40018544: 83 30 60 18 srl %g1, 0x18, %g1
40018548: c2 28 a0 0a stb %g1, [ %g2 + 0xa ]
rc = rtems_rfs_inode_close (fs, &inode);
4001854c: 92 07 bf 88 add %fp, -120, %o1
40018550: c2 07 bf 94 ld [ %fp + -108 ], %g1
40018554: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40018558: 82 10 20 01 mov 1, %g1
4001855c: 90 10 00 18 mov %i0, %o0
40018560: 7f ff c3 65 call 400092f4 <rtems_rfs_inode_close>
40018564: c2 2f bf 98 stb %g1, [ %fp + -104 ]
return rc;
40018568: 10 bf ff da b 400184d0 <rtems_rfs_symlink+0x74>
4001856c: b4 10 00 08 mov %o0, %i2
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
40018570: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018574: 7f ff a9 e1 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018578: 90 12 22 38 or %o0, 0x238, %o0 ! 40024638 <IMFS_LIMITS_AND_OPTIONS+0x10f8><== NOT EXECUTED
for (c = 0; c < length; c++)
4001857c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40018580: 04 80 00 0a ble 400185a8 <rtems_rfs_symlink+0x14c> <== NOT EXECUTED
40018584: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018588: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
4001858c: b4 06 80 19 add %i2, %i1, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
40018590: 40 00 19 08 call 4001e9b0 <putchar> <== NOT EXECUTED
40018594: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
for (c = 0; c < length; c++)
40018598: a0 04 20 01 inc %l0 <== NOT EXECUTED
4001859c: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
400185a0: 12 bf ff fc bne 40018590 <rtems_rfs_symlink+0x134> <== NOT EXECUTED
400185a4: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
printf (" link:");
400185a8: 7f ff a9 d4 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400185ac: 90 12 22 60 or %o0, 0x260, %o0 ! 40024660 <IMFS_LIMITS_AND_OPTIONS+0x1120><== NOT EXECUTED
for (c = 0; c < link_length; c++)
400185b0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
400185b4: 04 bf ff b2 ble 4001847c <rtems_rfs_symlink+0x20> <== NOT EXECUTED
400185b8: a0 07 00 1b add %i4, %i3, %l0 <== NOT EXECUTED
400185bc: b4 10 00 1b mov %i3, %i2 <== NOT EXECUTED
printf ("%c", link[c]);
400185c0: 40 00 18 fc call 4001e9b0 <putchar> <== NOT EXECUTED
400185c4: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
400185c8: b4 06 a0 01 inc %i2 <== NOT EXECUTED
400185cc: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
400185d0: 12 bf ff fc bne 400185c0 <rtems_rfs_symlink+0x164> <== NOT EXECUTED
400185d4: 01 00 00 00 nop <== NOT EXECUTED
400185d8: 10 bf ff aa b 40018480 <rtems_rfs_symlink+0x24> <== NOT EXECUTED
400185dc: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
400185e0: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
400185e4: 7f ff ee d2 call 4001412c <rtems_rfs_block_map_open> <== NOT EXECUTED
400185e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
400185ec: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
400185f0: 14 80 00 27 bg 4001868c <rtems_rfs_symlink+0x230> <== NOT EXECUTED
400185f4: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
400185f8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
400185fc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40018600: 7f ff f0 1d call 40014674 <rtems_rfs_block_map_grow> <== NOT EXECUTED
40018604: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
40018608: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
4001860c: 14 80 00 24 bg 4001869c <rtems_rfs_symlink+0x240> <== NOT EXECUTED
40018610: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
handle->dirty = false;
40018614: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
40018618: 96 10 20 00 clr %o3 <== NOT EXECUTED
handle->bnum = 0;
4001861c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
40018620: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
handle->buffer = NULL;
40018624: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
40018628: 7f ff ba fe call 40007220 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
4001862c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
40018630: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
40018634: 14 80 00 1a bg 4001869c <rtems_rfs_symlink+0x240> <== NOT EXECUTED
40018638: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
4001863c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
40018640: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED
40018644: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
40018648: 40 00 18 95 call 4001e89c <memset> <== NOT EXECUTED
4001864c: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
memcpy (data, link, link_length);
40018650: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40018654: 40 00 18 08 call 4001e674 <memcpy> <== NOT EXECUTED
40018658: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001865c: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
40018660: 7f ff bb b9 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40018664: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
40018668: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
handle->dirty = false;
4001866c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
40018670: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->bnum = 0;
40018674: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
40018678: 7f ff ef 0c call 400142a8 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001867c: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
if (rc > 0)
40018680: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
40018684: 04 bf ff af ble 40018540 <rtems_rfs_symlink+0xe4> <== NOT EXECUTED
40018688: 83 2f 20 10 sll %i4, 0x10, %g1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001868c: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40018690: 7f ff c3 19 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40018694: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
40018698: 30 bf ff 8e b,a 400184d0 <rtems_rfs_symlink+0x74> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001869c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
400186a0: 7f ff ef 02 call 400142a8 <rtems_rfs_block_map_close> <== NOT EXECUTED
400186a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400186a8: 10 bf ff fa b 40018690 <rtems_rfs_symlink+0x234> <== NOT EXECUTED
400186ac: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
400186b0 <rtems_rfs_symlink_read>:
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
400186b0: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
400186b4: 90 10 20 04 mov 4, %o0
400186b8: 7f ff c9 43 call 4000abc4 <rtems_rfs_trace>
400186bc: 92 10 20 00 clr %o1
400186c0: 80 a2 20 00 cmp %o0, 0
400186c4: 12 80 00 6b bne 40018870 <rtems_rfs_symlink_read+0x1c0> <== NEVER TAKEN
400186c8: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
400186cc: 96 10 20 01 mov 1, %o3
400186d0: 94 07 bf 88 add %fp, -120, %o2
400186d4: 92 10 00 19 mov %i1, %o1
400186d8: 7f ff c2 8e call 40009110 <rtems_rfs_inode_open>
400186dc: 90 10 00 18 mov %i0, %o0
if (rc)
400186e0: ba 92 20 00 orcc %o0, 0, %i5
400186e4: 12 80 00 25 bne 40018778 <rtems_rfs_symlink_read+0xc8> <== NEVER TAKEN
400186e8: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
400186ec: 05 00 00 3c sethi %hi(0xf000), %g2
400186f0: c2 0a 60 02 ldub [ %o1 + 2 ], %g1
400186f4: 83 28 60 08 sll %g1, 8, %g1
400186f8: 82 08 40 02 and %g1, %g2, %g1
400186fc: 05 00 00 28 sethi %hi(0xa000), %g2
40018700: 80 a0 40 02 cmp %g1, %g2
40018704: 32 80 00 67 bne,a 400188a0 <rtems_rfs_symlink_read+0x1f0> <== NEVER TAKEN
40018708: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4001870c: c2 0a 60 0a ldub [ %o1 + 0xa ], %g1
40018710: d4 0a 60 0b ldub [ %o1 + 0xb ], %o2
40018714: 83 28 60 08 sll %g1, 8, %g1
40018718: 94 12 80 01 or %o2, %g1, %o2
4001871c: 80 a2 80 1b cmp %o2, %i3
40018720: 38 80 00 45 bgu,a 40018834 <rtems_rfs_symlink_read+0x184>
40018724: 94 10 00 1b mov %i3, %o2
40018728: d4 27 00 00 st %o2, [ %i4 ]
return rtems_rfs_read_u32 (&handle->node->block_count);
4001872c: c6 0a 60 0c ldub [ %o1 + 0xc ], %g3
40018730: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
40018734: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
40018738: c8 0a 60 0f ldub [ %o1 + 0xf ], %g4
4001873c: 87 28 e0 18 sll %g3, 0x18, %g3
40018740: 85 28 a0 10 sll %g2, 0x10, %g2
40018744: 83 28 60 08 sll %g1, 8, %g1
40018748: 84 10 80 03 or %g2, %g3, %g2
4001874c: 82 10 40 02 or %g1, %g2, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
40018750: 80 91 00 01 orcc %g4, %g1, %g0
40018754: 32 80 00 0b bne,a 40018780 <rtems_rfs_symlink_read+0xd0> <== NEVER TAKEN
40018758: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
4001875c: 92 02 60 1c add %o1, 0x1c, %o1
40018760: 40 00 17 c5 call 4001e674 <memcpy>
40018764: 90 10 00 1a mov %i2, %o0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
40018768: 92 07 bf 88 add %fp, -120, %o1
4001876c: 7f ff c2 e2 call 400092f4 <rtems_rfs_inode_close>
40018770: 90 10 00 18 mov %i0, %o0
40018774: ba 10 00 08 mov %o0, %i5
return rc;
}
40018778: 81 c7 e0 08 ret
4001877c: 91 e8 00 1d restore %g0, %i5, %o0
rc = rtems_rfs_block_map_open (fs, &inode, &map);
40018780: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
40018784: 7f ff ee 6a call 4001412c <rtems_rfs_block_map_open> <== NOT EXECUTED
40018788: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
4001878c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40018790: 14 80 00 24 bg 40018820 <rtems_rfs_symlink_read+0x170> <== NOT EXECUTED
40018794: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40018798: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001879c: 96 10 20 00 clr %o3 <== NOT EXECUTED
400187a0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
400187a4: 7f ff ef 89 call 400145c8 <rtems_rfs_block_map_seek> <== NOT EXECUTED
400187a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
400187ac: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400187b0: 14 80 00 35 bg 40018884 <rtems_rfs_symlink_read+0x1d4> <== NOT EXECUTED
400187b4: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
handle->dirty = false;
400187b8: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
400187bc: 96 10 20 00 clr %o3 <== NOT EXECUTED
handle->bnum = 0;
400187c0: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
400187c4: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
handle->buffer = NULL;
400187c8: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
400187cc: 7f ff ba 95 call 40007220 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
400187d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
400187d4: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400187d8: 14 80 00 2b bg 40018884 <rtems_rfs_symlink_read+0x1d4> <== NOT EXECUTED
400187dc: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memcpy (path, data, *length);
400187e0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
400187e4: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
400187e8: 40 00 17 a3 call 4001e674 <memcpy> <== NOT EXECUTED
400187ec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400187f0: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
400187f4: 7f ff bb 54 call 40007544 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
400187f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
400187fc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
handle->dirty = false;
40018800: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
40018804: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->bnum = 0;
40018808: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
4001880c: 7f ff ee a7 call 400142a8 <rtems_rfs_block_map_close> <== NOT EXECUTED
40018810: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
if (rc > 0)
40018814: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40018818: 04 bf ff d5 ble 4001876c <rtems_rfs_symlink_read+0xbc> <== NOT EXECUTED
4001881c: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40018820: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40018824: 7f ff c2 b4 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40018828: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
4001882c: 81 c7 e0 08 ret <== NOT EXECUTED
40018830: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40018834: d4 27 00 00 st %o2, [ %i4 ]
40018838: c6 0a 60 0c ldub [ %o1 + 0xc ], %g3
4001883c: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
40018840: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
40018844: c8 0a 60 0f ldub [ %o1 + 0xf ], %g4
40018848: 87 28 e0 18 sll %g3, 0x18, %g3
4001884c: 85 28 a0 10 sll %g2, 0x10, %g2
40018850: 83 28 60 08 sll %g1, 8, %g1
40018854: 84 10 80 03 or %g2, %g3, %g2
40018858: 82 10 40 02 or %g1, %g2, %g1
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001885c: 80 91 00 01 orcc %g4, %g1, %g0
40018860: 32 bf ff c8 bne,a 40018780 <rtems_rfs_symlink_read+0xd0> <== NEVER TAKEN
40018864: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
memcpy (path, inode.node->data.name, *length);
40018868: 10 bf ff be b 40018760 <rtems_rfs_symlink_read+0xb0>
4001886c: 92 02 60 1c add %o1, 0x1c, %o1
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
40018870: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018874: 7f ff a9 21 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018878: 90 12 22 68 or %o0, 0x268, %o0 ! 40024668 <IMFS_LIMITS_AND_OPTIONS+0x1128><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001887c: 10 bf ff 95 b 400186d0 <rtems_rfs_symlink_read+0x20> <== NOT EXECUTED
40018880: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
40018884: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40018888: 7f ff ee 88 call 400142a8 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001888c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40018890: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40018894: 7f ff c2 98 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
40018898: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
4001889c: 30 bf ff e4 b,a 4001882c <rtems_rfs_symlink_read+0x17c> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400188a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400188a4: 7f ff c2 94 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
400188a8: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
}
400188ac: 81 c7 e0 08 ret <== NOT EXECUTED
400188b0: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40017fe8 <rtems_rfs_unlink>:
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
40017fe8: 9d e3 bf 50 save %sp, -176, %sp
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40017fec: 90 10 20 00 clr %o0
40017ff0: 7f ff ca f5 call 4000abc4 <rtems_rfs_trace>
40017ff4: 13 00 80 00 sethi %hi(0x2000000), %o1
40017ff8: 80 a2 20 00 cmp %o0, 0
40017ffc: 12 80 00 57 bne 40018158 <rtems_rfs_unlink+0x170> <== NEVER TAKEN
40018000: 94 10 00 1a mov %i2, %o2
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40018004: 96 10 20 01 mov 1, %o3
40018008: 94 07 bf d8 add %fp, -40, %o2
4001800c: 92 10 00 1a mov %i2, %o1
40018010: 7f ff c4 40 call 40009110 <rtems_rfs_inode_open>
40018014: 90 10 00 18 mov %i0, %o0
if (rc)
40018018: ba 92 20 00 orcc %o0, 0, %i5
4001801c: 12 80 00 4d bne 40018150 <rtems_rfs_unlink+0x168> <== NEVER TAKEN
40018020: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_read_u16 (&handle->node->mode);
40018024: 05 00 00 3c sethi %hi(0xf000), %g2
40018028: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001802c: 83 28 60 08 sll %g1, 8, %g1
40018030: 82 08 40 02 and %g1, %g2, %g1
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
40018034: 05 00 00 10 sethi %hi(0x4000), %g2
40018038: 80 a0 40 02 cmp %g1, %g2
4001803c: 12 80 00 07 bne 40018058 <rtems_rfs_unlink+0x70>
40018040: a1 28 60 10 sll %g1, 0x10, %l0
{
switch (dir_mode)
40018044: 80 a7 20 00 cmp %i4, 0
40018048: 02 80 00 8d be 4001827c <rtems_rfs_unlink+0x294> <== NEVER TAKEN
4001804c: 80 a7 20 01 cmp %i4, 1
40018050: 02 80 00 54 be 400181a0 <rtems_rfs_unlink+0x1b8>
40018054: 92 07 bf d8 add %fp, -40, %o1
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40018058: 96 10 20 01 mov 1, %o3
4001805c: 94 07 bf b0 add %fp, -80, %o2
40018060: 92 10 00 19 mov %i1, %o1
40018064: 7f ff c4 2b call 40009110 <rtems_rfs_inode_open>
40018068: 90 10 00 18 mov %i0, %o0
if (rc)
4001806c: ba 92 20 00 orcc %o0, 0, %i5
40018070: 12 80 00 40 bne 40018170 <rtems_rfs_unlink+0x188> <== NEVER TAKEN
40018074: 96 10 00 1b mov %i3, %o3
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
40018078: 94 10 00 1a mov %i2, %o2
4001807c: 92 07 bf b0 add %fp, -80, %o1
40018080: 7f ff f5 d6 call 400157d8 <rtems_rfs_dir_del_entry>
40018084: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40018088: ba 92 20 00 orcc %o0, 0, %i5
4001808c: 14 80 00 96 bg 400182e4 <rtems_rfs_unlink+0x2fc> <== NEVER TAKEN
40018090: c4 07 bf e4 ld [ %fp + -28 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
40018094: c2 08 80 00 ldub [ %g2 ], %g1
40018098: 83 28 60 08 sll %g1, 8, %g1
4001809c: fa 08 a0 01 ldub [ %g2 + 1 ], %i5
400180a0: ba 17 40 01 or %i5, %g1, %i5
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400180a4: 90 10 20 00 clr %o0
if (links == 0xffff)
400180a8: 03 00 00 3f sethi %hi(0xfc00), %g1
400180ac: b9 2f 60 10 sll %i5, 0x10, %i4
400180b0: 82 10 63 ff or %g1, 0x3ff, %g1
400180b4: 80 a7 40 01 cmp %i5, %g1
400180b8: 02 80 00 4e be 400181f0 <rtems_rfs_unlink+0x208> <== NEVER TAKEN
400180bc: 13 00 80 00 sethi %hi(0x2000000), %o1
400180c0: 7f ff ca c1 call 4000abc4 <rtems_rfs_trace>
400180c4: 01 00 00 00 nop
400180c8: 80 a2 20 00 cmp %o0, 0
400180cc: 12 80 00 ac bne 4001837c <rtems_rfs_unlink+0x394> <== NEVER TAKEN
400180d0: 94 10 00 1d mov %i5, %o2
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
400180d4: b9 37 20 10 srl %i4, 0x10, %i4
400180d8: 80 a7 20 01 cmp %i4, 1
400180dc: 08 80 00 4a bleu 40018204 <rtems_rfs_unlink+0x21c>
400180e0: c4 07 bf e4 ld [ %fp + -28 ], %g2
{
links--;
400180e4: ba 07 7f ff add %i5, -1, %i5
rtems_rfs_write_u16 (&handle->node->links, links);
400180e8: 83 2f 60 10 sll %i5, 0x10, %g1
400180ec: 83 30 60 18 srl %g1, 0x18, %g1
400180f0: c2 28 80 00 stb %g1, [ %g2 ]
400180f4: c2 07 bf e4 ld [ %fp + -28 ], %g1
400180f8: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400180fc: 82 10 20 01 mov 1, %g1
40018100: c2 2f bf e8 stb %g1, [ %fp + -24 ]
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40018104: 94 10 20 01 mov 1, %o2
40018108: 92 10 20 01 mov 1, %o1
4001810c: 7f ff c4 eb call 400094b8 <rtems_rfs_inode_time_stamp_now>
40018110: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
40018114: ba 92 20 00 orcc %o0, 0, %i5
40018118: 14 80 00 65 bg 400182ac <rtems_rfs_unlink+0x2c4> <== NEVER TAKEN
4001811c: 90 10 20 00 clr %o0
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
40018120: 92 07 bf b0 add %fp, -80, %o1
40018124: 7f ff c4 74 call 400092f4 <rtems_rfs_inode_close>
40018128: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001812c: ba 92 20 00 orcc %o0, 0, %i5
40018130: 14 80 00 85 bg 40018344 <rtems_rfs_unlink+0x35c> <== NEVER TAKEN
40018134: 90 10 20 00 clr %o0
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
40018138: 92 07 bf d8 add %fp, -40, %o1
4001813c: 7f ff c4 6e call 400092f4 <rtems_rfs_inode_close>
40018140: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40018144: ba 92 20 00 orcc %o0, 0, %i5
40018148: 14 80 00 93 bg 40018394 <rtems_rfs_unlink+0x3ac> <== NEVER TAKEN
4001814c: 90 10 20 00 clr %o0
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
40018150: 81 c7 e0 08 ret
40018154: 91 e8 00 1d restore %g0, %i5, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
40018158: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001815c: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018160: 7f ff aa e6 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018164: 90 12 20 68 or %o0, 0x68, %o0 ! 40024468 <IMFS_LIMITS_AND_OPTIONS+0xf28><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40018168: 10 bf ff a8 b 40018008 <rtems_rfs_unlink+0x20> <== NOT EXECUTED
4001816c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40018170: 90 10 20 00 clr %o0 <== NOT EXECUTED
40018174: 7f ff ca 94 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40018178: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001817c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40018180: 12 80 00 68 bne 40018320 <rtems_rfs_unlink+0x338> <== NOT EXECUTED
40018184: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40018188: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001818c: 90 10 00 18 mov %i0, %o0
40018190: 7f ff c4 59 call 400092f4 <rtems_rfs_inode_close>
40018194: b0 10 00 1d mov %i5, %i0
}
40018198: 81 c7 e0 08 ret
4001819c: 81 e8 00 00 restore
rc = rtems_rfs_dir_empty (fs, &target_inode);
400181a0: 7f ff f7 8f call 40015fdc <rtems_rfs_dir_empty>
400181a4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400181a8: ba 92 20 00 orcc %o0, 0, %i5
400181ac: 04 bf ff ac ble 4001805c <rtems_rfs_unlink+0x74>
400181b0: 96 10 20 01 mov 1, %o3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400181b4: 90 10 20 00 clr %o0
400181b8: 7f ff ca 83 call 4000abc4 <rtems_rfs_trace>
400181bc: 13 00 80 00 sethi %hi(0x2000000), %o1
400181c0: 80 a2 20 00 cmp %o0, 0
400181c4: 22 bf ff f2 be,a 4001818c <rtems_rfs_unlink+0x1a4> <== ALWAYS TAKEN
400181c8: 92 07 bf d8 add %fp, -40, %o1
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
400181cc: 40 00 1d 10 call 4001f60c <strerror> <== NOT EXECUTED
400181d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400181d4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400181d8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400181dc: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
400181e0: 7f ff aa c6 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400181e4: 90 12 20 b8 or %o0, 0xb8, %o0 ! 400244b8 <IMFS_LIMITS_AND_OPTIONS+0xf78><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
400181e8: 10 bf ff e9 b 4001818c <rtems_rfs_unlink+0x1a4> <== NOT EXECUTED
400181ec: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400181f0: 7f ff ca 75 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400181f4: 01 00 00 00 nop <== NOT EXECUTED
400181f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400181fc: 12 80 00 8f bne 40018438 <rtems_rfs_unlink+0x450> <== NOT EXECUTED
40018200: 94 10 20 00 clr %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
40018204: 92 07 bf d8 add %fp, -40, %o1
40018208: 7f ff c4 62 call 40009390 <rtems_rfs_inode_delete>
4001820c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40018210: ba 92 20 00 orcc %o0, 0, %i5
40018214: 14 80 00 6d bg 400183c8 <rtems_rfs_unlink+0x3e0> <== NEVER TAKEN
40018218: 03 10 00 00 sethi %hi(0x40000000), %g1
if (dir)
4001821c: 80 a4 00 01 cmp %l0, %g1
40018220: 12 bf ff ba bne 40018108 <rtems_rfs_unlink+0x120>
40018224: 94 10 20 01 mov 1, %o2
links = rtems_rfs_read_u16 (&handle->node->links);
40018228: c4 07 bf bc ld [ %fp + -68 ], %g2
4001822c: c6 08 80 00 ldub [ %g2 ], %g3
40018230: 87 28 e0 08 sll %g3, 8, %g3
40018234: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
40018238: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
4001823c: 07 00 00 3f sethi %hi(0xfc00), %g3
40018240: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_ISR_Stack_size+0xefff>
40018244: 80 a0 40 03 cmp %g1, %g3
40018248: 02 80 00 82 be 40018450 <rtems_rfs_unlink+0x468> <== NEVER TAKEN
4001824c: 80 a0 60 01 cmp %g1, 1
if (links > 1)
40018250: 08 80 00 05 bleu 40018264 <rtems_rfs_unlink+0x27c>
40018254: 86 10 20 00 clr %g3
links--;
40018258: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_write_u16 (&handle->node->links, links);
4001825c: 87 28 60 10 sll %g1, 0x10, %g3
40018260: 87 30 e0 18 srl %g3, 0x18, %g3
40018264: c6 28 80 00 stb %g3, [ %g2 ]
40018268: c4 07 bf bc ld [ %fp + -68 ], %g2
4001826c: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40018270: 82 10 20 01 mov 1, %g1
}
40018274: 10 bf ff a4 b 40018104 <rtems_rfs_unlink+0x11c>
40018278: c2 2f bf c0 stb %g1, [ %fp + -64 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001827c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40018280: 7f ff ca 51 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40018284: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40018288: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001828c: 12 80 00 5e bne 40018404 <rtems_rfs_unlink+0x41c> <== NOT EXECUTED
40018290: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40018294: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40018298: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001829c: 7f ff c4 16 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
400182a0: ba 10 20 15 mov 0x15, %i5 <== NOT EXECUTED
}
400182a4: 81 c7 e0 08 ret <== NOT EXECUTED
400182a8: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400182ac: 7f ff ca 46 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400182b0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400182b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400182b8: 12 80 00 57 bne 40018414 <rtems_rfs_unlink+0x42c> <== NOT EXECUTED
400182bc: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
400182c0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
400182c4: 7f ff c4 0c call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
400182c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
400182cc: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
400182d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400182d4: 7f ff c4 08 call 400092f4 <rtems_rfs_inode_close> <== NOT EXECUTED
400182d8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
400182dc: 81 c7 e0 08 ret <== NOT EXECUTED
400182e0: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400182e4: 90 10 20 00 clr %o0 <== NOT EXECUTED
400182e8: 7f ff ca 37 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400182ec: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400182f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400182f4: 22 bf ff f4 be,a 400182c4 <rtems_rfs_unlink+0x2dc> <== NOT EXECUTED
400182f8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
400182fc: 40 00 1c c4 call 4001f60c <strerror> <== NOT EXECUTED
40018300: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018304: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40018308: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001830c: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018310: 7f ff aa 7a call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018314: 90 12 21 08 or %o0, 0x108, %o0 ! 40024508 <IMFS_LIMITS_AND_OPTIONS+0xfc8><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40018318: 10 bf ff eb b 400182c4 <rtems_rfs_unlink+0x2dc> <== NOT EXECUTED
4001831c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
40018320: 40 00 1c bb call 4001f60c <strerror> <== NOT EXECUTED
40018324: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018328: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001832c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40018330: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018334: 7f ff aa 71 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018338: 90 12 20 d8 or %o0, 0xd8, %o0 ! 400244d8 <IMFS_LIMITS_AND_OPTIONS+0xf98><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001833c: 10 bf ff 94 b 4001818c <rtems_rfs_unlink+0x1a4> <== NOT EXECUTED
40018340: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40018344: 7f ff ca 20 call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40018348: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001834c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40018350: 22 bf ff 8f be,a 4001818c <rtems_rfs_unlink+0x1a4> <== NOT EXECUTED
40018354: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
40018358: 40 00 1c ad call 4001f60c <strerror> <== NOT EXECUTED
4001835c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018360: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40018364: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40018368: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
4001836c: 7f ff aa 63 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018370: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 400245c8 <IMFS_LIMITS_AND_OPTIONS+0x1088><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40018374: 10 bf ff 86 b 4001818c <rtems_rfs_unlink+0x1a4> <== NOT EXECUTED
40018378: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001837c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40018380: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018384: 7f ff aa 5d call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018388: 90 12 21 38 or %o0, 0x138, %o0 ! 40024538 <IMFS_LIMITS_AND_OPTIONS+0xff8><== NOT EXECUTED
if (links > 1)
4001838c: 10 bf ff 53 b 400180d8 <rtems_rfs_unlink+0xf0> <== NOT EXECUTED
40018390: b9 37 20 10 srl %i4, 0x10, %i4 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40018394: 7f ff ca 0c call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
40018398: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001839c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400183a0: 02 bf ff 6c be 40018150 <rtems_rfs_unlink+0x168> <== NOT EXECUTED
400183a4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
400183a8: 40 00 1c 99 call 4001f60c <strerror> <== NOT EXECUTED
400183ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400183b0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400183b4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400183b8: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
400183bc: 7f ff aa 4f call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400183c0: 90 12 22 00 or %o0, 0x200, %o0 ! 40024600 <IMFS_LIMITS_AND_OPTIONS+0x10c0><== NOT EXECUTED
400183c4: 30 bf ff 63 b,a 40018150 <rtems_rfs_unlink+0x168> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400183c8: 90 10 20 00 clr %o0 <== NOT EXECUTED
400183cc: 7f ff c9 fe call 4000abc4 <rtems_rfs_trace> <== NOT EXECUTED
400183d0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400183d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400183d8: 22 bf ff bb be,a 400182c4 <rtems_rfs_unlink+0x2dc> <== NOT EXECUTED
400183dc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
400183e0: 40 00 1c 8b call 4001f60c <strerror> <== NOT EXECUTED
400183e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400183e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400183ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400183f0: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
400183f4: 7f ff aa 41 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
400183f8: 90 12 21 60 or %o0, 0x160, %o0 ! 40024560 <IMFS_LIMITS_AND_OPTIONS+0x1020><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
400183fc: 10 bf ff b2 b 400182c4 <rtems_rfs_unlink+0x2dc> <== NOT EXECUTED
40018400: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
40018404: 7f ff aa 4b call 40002d30 <__wrap_puts> <== NOT EXECUTED
40018408: 90 12 20 98 or %o0, 0x98, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001840c: 10 bf ff a3 b 40018298 <rtems_rfs_unlink+0x2b0> <== NOT EXECUTED
40018410: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
40018414: 40 00 1c 7e call 4001f60c <strerror> <== NOT EXECUTED
40018418: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001841c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40018420: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40018424: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018428: 7f ff aa 34 call 40002cf8 <__wrap_printf> <== NOT EXECUTED
4001842c: 90 12 21 90 or %o0, 0x190, %o0 ! 40024590 <IMFS_LIMITS_AND_OPTIONS+0x1050><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40018430: 10 bf ff a5 b 400182c4 <rtems_rfs_unlink+0x2dc> <== NOT EXECUTED
40018434: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
40018438: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001843c: 11 10 00 91 sethi %hi(0x40024400), %o0 <== NOT EXECUTED
40018440: 7f ff aa 2e call 40002cf8 <__wrap_printf> <== NOT EXECUTED
40018444: 90 12 21 38 or %o0, 0x138, %o0 ! 40024538 <IMFS_LIMITS_AND_OPTIONS+0xff8><== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
40018448: 10 bf ff 70 b 40018208 <rtems_rfs_unlink+0x220> <== NOT EXECUTED
4001844c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40018450: 82 10 20 00 clr %g1 <== NOT EXECUTED
40018454: 10 bf ff 84 b 40018264 <rtems_rfs_unlink+0x27c> <== NOT EXECUTED
40018458: 86 10 20 00 clr %g3 <== NOT EXECUTED