RTEMS-5
Annotated Report
Fri Aug 10 14:06:35 2018
4001a964 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
4001a964: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
4001a968: 90 10 00 18 mov %i0, %o0
{
4001a96c: ba 10 00 18 mov %i0, %i5
rc = rtems_rfs_bitmap_load_map (control, &map);
4001a970: 7f ff fe 93 call 4001a3bc <rtems_rfs_bitmap_load_map>
4001a974: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001a978: b0 92 20 00 orcc %o0, 0, %i0
4001a97c: 24 80 00 04 ble,a 4001a98c <rtems_rfs_bitmap_create_search+0x28>
<== ALWAYS TAKEN
4001a980: c0 27 60 10 clr [ %i5 + 0x10 ]
bit++;
map++;
}
return 0;
}
4001a984: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a988: 81 e8 00 00 restore
<== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001a98c: 82 10 3f ff mov -1, %g1
search_map = control->search_bits;
4001a990: f0 07 60 14 ld [ %i5 + 0x14 ], %i0
size = control->size;
4001a994: c6 07 60 0c ld [ %i5 + 0xc ], %g3
while (size)
4001a998: 80 a0 e0 00 cmp %g3, 0
4001a99c: 02 80 00 31 be 4001aa60 <rtems_rfs_bitmap_create_search+0xfc>
<== NEVER TAKEN
4001a9a0: c2 26 00 00 st %g1, [ %i0 ]
4001a9a4: f8 07 bf fc ld [ %fp + -4 ], %i4
bit = 0;
4001a9a8: b4 10 20 00 clr %i2
available = rtems_rfs_bitmap_element_bits ();
4001a9ac: 9a 10 20 20 mov 0x20, %o5
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001a9b0: 9e 10 3f ff mov -1, %o7
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001a9b4: 10 80 00 10 b 4001a9f4 <rtems_rfs_bitmap_create_search+0x90>
4001a9b8: b2 10 20 01 mov 1, %i1
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001a9bc: 82 23 40 03 sub %o5, %g3, %g1
available = size;
4001a9c0: b6 10 00 03 mov %g3, %i3
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001a9c4: 83 33 c0 01 srl %o7, %g1, %g1
4001a9c8: 84 08 80 01 and %g2, %g1, %g2
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4001a9cc: 80 a0 a0 00 cmp %g2, 0
4001a9d0: 12 80 00 10 bne 4001aa10 <rtems_rfs_bitmap_create_search+0xac>
<== ALWAYS TAKEN
4001a9d4: 86 10 20 00 clr %g3
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
4001a9d8: 80 a6 a0 1f cmp %i2, 0x1f
<== NOT EXECUTED
4001a9dc: 22 80 00 1c be,a 4001aa4c <rtems_rfs_bitmap_create_search+0xe8>
<== NOT EXECUTED
4001a9e0: de 26 20 04 st %o7, [ %i0 + 4 ]
<== NOT EXECUTED
bit++;
4001a9e4: b4 06 a0 01 inc %i2
<== NOT EXECUTED
while (size)
4001a9e8: 80 a0 e0 00 cmp %g3, 0
4001a9ec: 02 80 00 1d be 4001aa60 <rtems_rfs_bitmap_create_search+0xfc>
4001a9f0: b8 07 20 04 add %i4, 4, %i4
if (size < rtems_rfs_bitmap_element_bits ())
4001a9f4: 80 a0 e0 1f cmp %g3, 0x1f
4001a9f8: 08 bf ff f1 bleu 4001a9bc <rtems_rfs_bitmap_create_search+0x58>
4001a9fc: c4 07 00 00 ld [ %i4 ], %g2
4001aa00: 86 00 ff e0 add %g3, -32, %g3
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4001aa04: 80 a0 a0 00 cmp %g2, 0
4001aa08: 02 bf ff f4 be 4001a9d8 <rtems_rfs_bitmap_create_search+0x74>
<== NEVER TAKEN
4001aa0c: b6 10 20 20 mov 0x20, %i3
for (b = 0; b < available; b++)
4001aa10: 82 10 20 00 clr %g1
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001aa14: 89 2e 40 01 sll %i1, %g1, %g4
if (!rtems_rfs_bitmap_test (bits, b))
4001aa18: 80 89 00 02 btst %g4, %g2
4001aa1c: 02 80 00 05 be 4001aa30 <rtems_rfs_bitmap_create_search+0xcc>
4001aa20: 82 00 60 01 inc %g1
control->free++;
4001aa24: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
4001aa28: 88 01 20 01 inc %g4
4001aa2c: c8 27 60 10 st %g4, [ %i5 + 0x10 ]
for (b = 0; b < available; b++)
4001aa30: 80 a6 c0 01 cmp %i3, %g1
4001aa34: 12 bf ff f9 bne 4001aa18 <rtems_rfs_bitmap_create_search+0xb4>
4001aa38: 89 2e 40 01 sll %i1, %g1, %g4
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
4001aa3c: 80 a6 a0 1f cmp %i2, 0x1f
4001aa40: 12 bf ff ea bne 4001a9e8 <rtems_rfs_bitmap_create_search+0x84>
<== ALWAYS TAKEN
4001aa44: b4 06 a0 01 inc %i2
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001aa48: de 26 20 04 st %o7, [ %i0 + 4 ]
<== NOT EXECUTED
bit = 0;
4001aa4c: b4 10 20 00 clr %i2
<== NOT EXECUTED
search_map++;
4001aa50: b0 06 20 04 add %i0, 4, %i0
<== NOT EXECUTED
while (size)
4001aa54: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4001aa58: 12 bf ff e7 bne 4001a9f4 <rtems_rfs_bitmap_create_search+0x90>
<== NOT EXECUTED
4001aa5c: b8 07 20 04 add %i4, 4, %i4
<== NOT EXECUTED
}
4001aa60: 81 c7 e0 08 ret
4001aa64: 91 e8 20 00 restore %g0, 0, %o0
4001a860 <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)
{
4001a860: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
4001a864: 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;
4001a868: 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))
4001a86c: 80 a6 60 00 cmp %i1, 0
4001a870: 06 80 00 1e bl 4001a8e8 <rtems_rfs_bitmap_map_alloc+0x88>
<== NEVER TAKEN
4001a874: 80 a7 60 00 cmp %i5, 0
4001a878: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001a87c: 80 a0 40 19 cmp %g1, %i1
4001a880: 08 80 00 1a bleu 4001a8e8 <rtems_rfs_bitmap_map_alloc+0x88>
4001a884: 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;
4001a888: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001a88c: 96 10 20 01 mov 1, %o3
4001a890: 94 10 00 1a mov %i2, %o2
4001a894: 92 10 00 1b mov %i3, %o1
4001a898: 7f ff fe dd call 4001a40c <rtems_rfs_search_map_for_clear_bit.constprop.0>
4001a89c: 90 10 00 18 mov %i0, %o0
window, 1);
if ((rc > 0) || *allocated)
4001a8a0: 80 a2 20 00 cmp %o0, 0
4001a8a4: 14 80 00 2c bg 4001a954 <rtems_rfs_bitmap_map_alloc+0xf4>
<== NEVER TAKEN
4001a8a8: 01 00 00 00 nop
4001a8ac: c2 0e 80 00 ldub [ %i2 ], %g1
4001a8b0: 80 a0 60 00 cmp %g1, 0
4001a8b4: 12 80 00 28 bne 4001a954 <rtems_rfs_bitmap_map_alloc+0xf4>
4001a8b8: 80 a7 60 00 cmp %i5, 0
break;
}
if (lower_seed >= 0)
4001a8bc: 36 80 00 14 bge,a 4001a90c <rtems_rfs_bitmap_map_alloc+0xac>
<== ALWAYS TAKEN
4001a8c0: 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)
4001a8c4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
4001a8c8: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
4001a8cc: 1a bf ff e9 bcc 4001a870 <rtems_rfs_bitmap_map_alloc+0x10>
<== NOT EXECUTED
4001a8d0: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
upper_seed += window;
4001a8d4: b2 06 68 00 add %i1, 0x800, %i1
<== NOT EXECUTED
while (((upper_seed >= 0) && (upper_seed < control->size))
4001a8d8: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001a8dc: 16 bf ff e9 bge 4001a880 <rtems_rfs_bitmap_map_alloc+0x20>
<== NOT EXECUTED
4001a8e0: 80 a0 40 19 cmp %g1, %i1
<== NOT EXECUTED
|| ((lower_seed >= 0) && (lower_seed < control->size)))
4001a8e4: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001a8e8: 06 80 00 1b bl 4001a954 <rtems_rfs_bitmap_map_alloc+0xf4>
<== ALWAYS TAKEN
4001a8ec: 01 00 00 00 nop
4001a8f0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
4001a8f4: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
4001a8f8: 08 80 00 17 bleu 4001a954 <rtems_rfs_bitmap_map_alloc+0xf4>
<== NOT EXECUTED
4001a8fc: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
if (upper_seed < control->size)
4001a900: 2a bf ff e3 bcs,a 4001a88c <rtems_rfs_bitmap_map_alloc+0x2c>
<== NOT EXECUTED
4001a904: f2 26 c0 00 st %i1, [ %i3 ]
<== NOT EXECUTED
*bit = lower_seed;
4001a908: fa 26 c0 00 st %i5, [ %i3 ]
<== NOT EXECUTED
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001a90c: 96 10 3f ff mov -1, %o3
4001a910: 94 10 00 1a mov %i2, %o2
4001a914: 92 10 00 1b mov %i3, %o1
4001a918: 7f ff fe bd call 4001a40c <rtems_rfs_search_map_for_clear_bit.constprop.0>
4001a91c: 90 10 00 18 mov %i0, %o0
if ((rc > 0) || *allocated)
4001a920: 80 a2 20 00 cmp %o0, 0
4001a924: 14 80 00 0c bg 4001a954 <rtems_rfs_bitmap_map_alloc+0xf4>
<== NEVER TAKEN
4001a928: 01 00 00 00 nop
4001a92c: c2 0e 80 00 ldub [ %i2 ], %g1
4001a930: 80 a0 60 00 cmp %g1, 0
4001a934: 12 80 00 08 bne 4001a954 <rtems_rfs_bitmap_map_alloc+0xf4>
4001a938: 01 00 00 00 nop
if (upper_seed < control->size)
4001a93c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001a940: 80 a6 40 01 cmp %i1, %g1
4001a944: 2a 80 00 06 bcs,a 4001a95c <rtems_rfs_bitmap_map_alloc+0xfc>
<== ALWAYS TAKEN
4001a948: b2 06 68 00 add %i1, 0x800, %i1
if (lower_seed >= 0)
lower_seed -= window;
4001a94c: 10 bf ff c8 b 4001a86c <rtems_rfs_bitmap_map_alloc+0xc>
<== NOT EXECUTED
4001a950: ba 07 78 00 add %i5, -2048, %i5
<== NOT EXECUTED
}
return 0;
}
4001a954: 81 c7 e0 08 ret
4001a958: 91 e8 20 00 restore %g0, 0, %o0
lower_seed -= window;
4001a95c: 10 bf ff c4 b 4001a86c <rtems_rfs_bitmap_map_alloc+0xc>
4001a960: ba 07 78 00 add %i5, -2048, %i5
4001a704 <rtems_rfs_bitmap_map_clear>:
{
4001a704: 9d e3 bf 98 save %sp, -104, %sp
rc = rtems_rfs_bitmap_load_map (control, &map);
4001a708: 92 07 bf fc add %fp, -4, %o1
4001a70c: 7f ff ff 2c call 4001a3bc <rtems_rfs_bitmap_load_map>
4001a710: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a714: 80 a2 20 00 cmp %o0, 0
4001a718: 24 80 00 04 ble,a 4001a728 <rtems_rfs_bitmap_map_clear+0x24>
<== ALWAYS TAKEN
4001a71c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
}
4001a720: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a724: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
if (bit >= control->size)
4001a728: 80 a0 40 19 cmp %g1, %i1
4001a72c: 08 bf ff fd bleu 4001a720 <rtems_rfs_bitmap_map_clear+0x1c>
<== NEVER TAKEN
4001a730: 90 10 20 16 mov 0x16, %o0
element = map[index];
4001a734: f8 07 bf fc ld [ %fp + -4 ], %i4
index = rtems_rfs_bitmap_map_index (bit);
4001a738: 85 3e 60 05 sra %i1, 5, %g2
element = map[index];
4001a73c: bb 28 a0 02 sll %g2, 2, %i5
4001a740: c8 07 00 1d ld [ %i4 + %i5 ], %g4
search_map = control->search_bits;
4001a744: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
4001a748: 86 10 20 01 mov 1, %g3
4001a74c: 83 28 c0 19 sll %g3, %i1, %g1
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4001a750: 82 10 40 04 or %g1, %g4, %g1
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
4001a754: c2 27 00 1d st %g1, [ %i4 + %i5 ]
if (rtems_rfs_bitmap_match(element, map[index]))
4001a758: 80 a1 00 01 cmp %g4, %g1
4001a75c: 02 bf ff f1 be 4001a720 <rtems_rfs_bitmap_map_clear+0x1c>
<== NEVER TAKEN
4001a760: 90 10 20 00 clr %o0
index = rtems_rfs_bitmap_map_index (bit);
4001a764: b3 3e 60 0a sra %i1, 0xa, %i1
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4001a768: b3 2e 60 02 sll %i1, 2, %i1
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4001a76c: c2 06 c0 19 ld [ %i3 + %i1 ], %g1
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a770: c8 06 00 00 ld [ %i0 ], %g4
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4001a774: 85 28 c0 02 sll %g3, %g2, %g2
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4001a778: 84 10 40 02 or %g1, %g2, %g2
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4001a77c: c4 26 c0 19 st %g2, [ %i3 + %i1 ]
control->free++;
4001a780: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a784: c6 29 00 00 stb %g3, [ %g4 ]
control->free++;
4001a788: 82 00 60 01 inc %g1
4001a78c: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
}
4001a790: 81 c7 e0 08 ret
4001a794: 91 e8 00 08 restore %g0, %o0, %o0
4001a798 <rtems_rfs_bitmap_map_clear_all>:
{
4001a798: 9d e3 bf 98 save %sp, -104, %sp
rc = rtems_rfs_bitmap_load_map (control, &map);
4001a79c: 90 10 00 18 mov %i0, %o0
{
4001a7a0: ba 10 00 18 mov %i0, %i5
rc = rtems_rfs_bitmap_load_map (control, &map);
4001a7a4: 7f ff ff 06 call 4001a3bc <rtems_rfs_bitmap_load_map>
4001a7a8: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001a7ac: b0 92 20 00 orcc %o0, 0, %i0
4001a7b0: 24 80 00 04 ble,a 4001a7c0 <rtems_rfs_bitmap_map_clear_all+0x28>
<== ALWAYS TAKEN
4001a7b4: c4 07 60 0c ld [ %i5 + 0xc ], %g2
}
4001a7b8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a7bc: 81 e8 00 00 restore
<== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
4001a7c0: 86 00 bf ff add %g2, -1, %g3
control->free = control->size;
4001a7c4: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
elements = rtems_rfs_bitmap_elements (control->size);
4001a7c8: b9 30 e0 05 srl %g3, 5, %i4
4001a7cc: c4 07 bf fc ld [ %fp + -4 ], %g2
4001a7d0: 89 2f 20 02 sll %i4, 2, %g4
4001a7d4: 82 00 a0 04 add %g2, 4, %g1
4001a7d8: b8 07 20 01 inc %i4
4001a7dc: 88 00 40 04 add %g1, %g4, %g4
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001a7e0: 10 80 00 03 b 4001a7ec <rtems_rfs_bitmap_map_clear_all+0x54>
4001a7e4: b6 10 3f ff mov -1, %i3
4001a7e8: 82 00 60 04 add %g1, 4, %g1
4001a7ec: f6 20 80 00 st %i3, [ %g2 ]
for (e = 0; e < elements; e++)
4001a7f0: 80 a1 00 01 cmp %g4, %g1
4001a7f4: 12 bf ff fd bne 4001a7e8 <rtems_rfs_bitmap_map_clear_all+0x50>
4001a7f8: 84 10 00 01 mov %g1, %g2
if (last_search_bit == 0)
4001a7fc: b8 8f 20 1f andcc %i4, 0x1f, %i4
4001a800: 02 80 00 04 be 4001a810 <rtems_rfs_bitmap_map_clear_all+0x78>
<== NEVER TAKEN
4001a804: b4 10 3f ff mov -1, %i2
4001a808: b8 20 00 1c neg %i4
4001a80c: b5 36 c0 1c srl %i3, %i4, %i2
elements = rtems_rfs_bitmap_elements (elements);
4001a810: 85 30 e0 0a srl %g3, 0xa, %g2
for (e = 0; e < (elements - 1); e++)
4001a814: 80 a0 a0 00 cmp %g2, 0
4001a818: 02 80 00 0b be 4001a844 <rtems_rfs_bitmap_map_clear_all+0xac>
<== ALWAYS TAKEN
4001a81c: f6 07 60 14 ld [ %i5 + 0x14 ], %i3
4001a820: 87 28 a0 02 sll %g2, 2, %g3
<== NOT EXECUTED
4001a824: 82 10 00 1b mov %i3, %g1
<== NOT EXECUTED
4001a828: 86 00 c0 1b add %g3, %i3, %g3
<== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001a82c: 88 10 3f ff mov -1, %g4
<== NOT EXECUTED
4001a830: c8 20 40 00 st %g4, [ %g1 ]
<== NOT EXECUTED
4001a834: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
for (e = 0; e < (elements - 1); e++)
4001a838: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
4001a83c: 32 bf ff fe bne,a 4001a834 <rtems_rfs_bitmap_map_clear_all+0x9c>
<== NOT EXECUTED
4001a840: c8 20 40 00 st %g4, [ %g1 ]
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a844: c2 07 40 00 ld [ %i5 ], %g1
control->search_bits[elements - 1] =
4001a848: 85 28 a0 02 sll %g2, 2, %g2
4001a84c: f4 26 c0 02 st %i2, [ %i3 + %g2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a850: 84 10 20 01 mov 1, %g2
4001a854: c4 28 40 00 stb %g2, [ %g1 ]
}
4001a858: 81 c7 e0 08 ret
4001a85c: 91 e8 20 00 restore %g0, 0, %o0
4001a668 <rtems_rfs_bitmap_map_set>:
{
4001a668: 9d e3 bf 98 save %sp, -104, %sp
rc = rtems_rfs_bitmap_load_map (control, &map);
4001a66c: 92 07 bf fc add %fp, -4, %o1
4001a670: 7f ff ff 53 call 4001a3bc <rtems_rfs_bitmap_load_map>
4001a674: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a678: 80 a2 20 00 cmp %o0, 0
4001a67c: 24 80 00 04 ble,a 4001a68c <rtems_rfs_bitmap_map_set+0x24>
<== ALWAYS TAKEN
4001a680: c2 06 20 0c ld [ %i0 + 0xc ], %g1
}
4001a684: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a688: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
if (bit >= control->size)
4001a68c: 80 a0 40 19 cmp %g1, %i1
4001a690: 08 bf ff fd bleu 4001a684 <rtems_rfs_bitmap_map_set+0x1c>
<== NEVER TAKEN
4001a694: 90 10 20 16 mov 0x16, %o0
element = map[index];
4001a698: fa 07 bf fc ld [ %fp + -4 ], %i5
index = rtems_rfs_bitmap_map_index (bit);
4001a69c: b9 3e 60 05 sra %i1, 5, %i4
element = map[index];
4001a6a0: 89 2f 20 02 sll %i4, 2, %g4
4001a6a4: c6 07 40 04 ld [ %i5 + %g4 ], %g3
search_map = control->search_bits;
4001a6a8: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
4001a6ac: 84 10 20 01 mov 1, %g2
4001a6b0: 83 28 80 19 sll %g2, %i1, %g1
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
4001a6b4: 82 28 c0 01 andn %g3, %g1, %g1
if (rtems_rfs_bitmap_match(element, map[index]))
4001a6b8: 80 a0 c0 01 cmp %g3, %g1
4001a6bc: 02 80 00 0f be 4001a6f8 <rtems_rfs_bitmap_map_set+0x90>
<== NEVER TAKEN
4001a6c0: c2 27 40 04 st %g1, [ %i5 + %g4 ]
control->free--;
4001a6c4: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
4001a6c8: 86 00 ff ff add %g3, -1, %g3
rtems_rfs_buffer_mark_dirty (control->buffer);
4001a6cc: c8 06 00 00 ld [ %i0 ], %g4
control->free--;
4001a6d0: c6 26 20 10 st %g3, [ %i0 + 0x10 ]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
4001a6d4: 80 a0 60 00 cmp %g1, 0
4001a6d8: 12 80 00 08 bne 4001a6f8 <rtems_rfs_bitmap_map_set+0x90>
<== ALWAYS TAKEN
4001a6dc: c4 29 00 00 stb %g2, [ %g4 ]
index = rtems_rfs_bitmap_map_index (bit);
4001a6e0: b3 3e 60 0a sra %i1, 0xa, %i1
<== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
4001a6e4: b3 2e 60 02 sll %i1, 2, %i1
<== NOT EXECUTED
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
4001a6e8: c2 06 c0 19 ld [ %i3 + %i1 ], %g1
<== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
4001a6ec: 85 28 80 1c sll %g2, %i4, %g2
<== NOT EXECUTED
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
4001a6f0: 84 28 40 02 andn %g1, %g2, %g2
<== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
4001a6f4: c4 26 c0 19 st %g2, [ %i3 + %i1 ]
<== NOT EXECUTED
return 0;
4001a6f8: 90 10 20 00 clr %o0
}
4001a6fc: 81 c7 e0 08 ret
4001a700: 91 e8 00 08 restore %g0, %o0, %o0
4001aa68 <rtems_rfs_bitmap_open>:
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
4001aa68: 9d e3 bf a0 save %sp, -96, %sp
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
4001aa6c: f4 26 00 00 st %i2, [ %i0 ]
size_t elements = rtems_rfs_bitmap_elements (size);
4001aa70: 90 06 ff ff add %i3, -1, %o0
control->fs = fs;
4001aa74: f2 26 20 04 st %i1, [ %i0 + 4 ]
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
4001aa78: 91 32 20 0a srl %o0, 0xa, %o0
control->block = block;
4001aa7c: f8 26 20 08 st %i4, [ %i0 + 8 ]
elements = rtems_rfs_bitmap_elements (elements);
4001aa80: 90 02 20 01 inc %o0
control->size = size;
4001aa84: f6 26 20 0c st %i3, [ %i0 + 0xc ]
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
4001aa88: 7f ff bc 62 call 40009c10 <malloc>
4001aa8c: 91 2a 20 02 sll %o0, 2, %o0
if (!control->search_bits)
4001aa90: 80 a2 20 00 cmp %o0, 0
4001aa94: 02 80 00 04 be 4001aaa4 <rtems_rfs_bitmap_open+0x3c>
<== NEVER TAKEN
4001aa98: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
4001aa9c: 7f ff ff b2 call 4001a964 <rtems_rfs_bitmap_create_search>
4001aaa0: 81 e8 00 00 restore
}
4001aaa4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001aaa8: 91 e8 20 0c restore %g0, 0xc, %o0
<== NOT EXECUTED
4001afc8 <rtems_rfs_block_map_close>:
{
4001afc8: 9d e3 bf a0 save %sp, -96, %sp
if (map->dirty && map->inode)
4001afcc: c2 0e 40 00 ldub [ %i1 ], %g1
4001afd0: 80 a0 60 00 cmp %g1, 0
4001afd4: 02 80 00 5f be 4001b150 <rtems_rfs_block_map_close+0x188>
4001afd8: ba 10 00 18 mov %i0, %i5
4001afdc: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001afe0: 80 a2 60 00 cmp %o1, 0
4001afe4: 02 80 00 5b be 4001b150 <rtems_rfs_block_map_close+0x188>
<== NEVER TAKEN
4001afe8: 90 10 00 18 mov %i0, %o0
brc = rtems_rfs_inode_load (fs, map->inode);
4001afec: 7f ff e1 b0 call 400136ac <rtems_rfs_inode_load>
4001aff0: b8 06 60 38 add %i1, 0x38, %i4
if (brc > 0)
4001aff4: 80 a2 20 00 cmp %o0, 0
4001aff8: 14 80 00 58 bg 4001b158 <rtems_rfs_block_map_close+0x190>
<== NEVER TAKEN
4001affc: b0 10 00 08 mov %o0, %i0
4001b000: 9e 10 3f f8 mov -8, %o7
4001b004: 84 06 60 24 add %i1, 0x24, %g2
4001b008: 9e 23 c0 19 sub %o7, %i1, %o7
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b00c: b0 10 20 01 mov 1, %i0
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
4001b010: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001b014: c6 00 80 00 ld [ %g2 ], %g3
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4001b018: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b01c: 88 03 c0 02 add %o7, %g2, %g4
4001b020: b5 30 e0 18 srl %g3, 0x18, %i2
4001b024: f4 2e c0 04 stb %i2, [ %i3 + %g4 ]
4001b028: b5 30 e0 10 srl %g3, 0x10, %i2
4001b02c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b030: b6 06 c0 04 add %i3, %g4, %i3
4001b034: f4 2e e0 01 stb %i2, [ %i3 + 1 ]
4001b038: b5 30 e0 08 srl %g3, 8, %i2
4001b03c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b040: b6 06 c0 04 add %i3, %g4, %i3
4001b044: f4 2e e0 02 stb %i2, [ %i3 + 2 ]
4001b048: 84 00 a0 04 add %g2, 4, %g2
4001b04c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b050: 88 06 c0 04 add %i3, %g4, %g4
4001b054: c6 29 20 03 stb %g3, [ %g4 + 3 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001b058: 80 a7 00 02 cmp %i4, %g2
4001b05c: 12 bf ff ed bne 4001b010 <rtems_rfs_block_map_close+0x48>
4001b060: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
4001b064: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001b068: c4 06 60 08 ld [ %i1 + 8 ], %g2
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
4001b06c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4001b070: 89 30 a0 18 srl %g2, 0x18, %g4
4001b074: c8 28 e0 0c stb %g4, [ %g3 + 0xc ]
4001b078: 89 30 a0 10 srl %g2, 0x10, %g4
4001b07c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4001b080: c8 28 e0 0d stb %g4, [ %g3 + 0xd ]
4001b084: 89 30 a0 08 srl %g2, 8, %g4
4001b088: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4001b08c: c8 28 e0 0e stb %g4, [ %g3 + 0xe ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001b090: 94 10 20 01 mov 1, %o2
4001b094: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4001b098: c4 28 e0 0f stb %g2, [ %g3 + 0xf ]
4001b09c: 90 10 00 1d mov %i5, %o0
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
4001b0a0: c6 06 60 04 ld [ %i1 + 4 ], %g3
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001b0a4: c8 0e 60 0e ldub [ %i1 + 0xe ], %g4
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b0a8: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001b0ac: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
4001b0b0: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001b0b4: c8 28 60 0a stb %g4, [ %g1 + 0xa ]
4001b0b8: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
4001b0bc: c4 28 60 0b stb %g2, [ %g1 + 0xb ]
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
4001b0c0: c4 06 60 04 ld [ %i1 + 4 ], %g2
4001b0c4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b0c8: f0 28 e0 10 stb %i0, [ %g3 + 0x10 ]
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
4001b0cc: 89 30 60 18 srl %g1, 0x18, %g4
4001b0d0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b0d4: c8 28 e0 30 stb %g4, [ %g3 + 0x30 ]
4001b0d8: 89 30 60 10 srl %g1, 0x10, %g4
4001b0dc: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b0e0: c8 28 e0 31 stb %g4, [ %g3 + 0x31 ]
4001b0e4: 89 30 60 08 srl %g1, 8, %g4
4001b0e8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b0ec: c8 28 e0 32 stb %g4, [ %g3 + 0x32 ]
4001b0f0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b0f4: c2 28 e0 33 stb %g1, [ %g3 + 0x33 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4001b0f8: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001b0fc: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b100: f0 28 a0 10 stb %i0, [ %g2 + 0x10 ]
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
4001b104: 89 30 e0 18 srl %g3, 0x18, %g4
4001b108: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001b10c: c8 28 a0 34 stb %g4, [ %g2 + 0x34 ]
4001b110: 89 30 e0 10 srl %g3, 0x10, %g4
4001b114: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001b118: c8 28 a0 35 stb %g4, [ %g2 + 0x35 ]
4001b11c: 89 30 e0 08 srl %g3, 8, %g4
4001b120: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001b124: c8 28 a0 36 stb %g4, [ %g2 + 0x36 ]
4001b128: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001b12c: c6 28 a0 37 stb %g3, [ %g2 + 0x37 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b130: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001b134: 7f ff e1 c4 call 40013844 <rtems_rfs_inode_unload>
4001b138: d2 06 60 04 ld [ %i1 + 4 ], %o1
map->dirty = false;
4001b13c: c0 2e 40 00 clrb [ %i1 ]
4001b140: 82 38 00 08 xnor %g0, %o0, %g1
4001b144: 83 38 60 1f sra %g1, 0x1f, %g1
4001b148: 10 80 00 04 b 4001b158 <rtems_rfs_block_map_close+0x190>
4001b14c: b0 0a 00 01 and %o0, %g1, %i0
int rc = 0;
4001b150: b0 10 20 00 clr %i0
4001b154: b8 06 60 38 add %i1, 0x38, %i4
map->inode = NULL;
4001b158: c0 26 60 04 clr [ %i1 + 4 ]
rtems_rfs_buffer_handle_release (fs, handle);
4001b15c: 92 10 00 1c mov %i4, %o1
4001b160: 40 00 04 1c call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001b164: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
4001b168: c0 2e 60 38 clrb [ %i1 + 0x38 ]
rtems_rfs_buffer_handle_release (fs, handle);
4001b16c: 92 06 60 44 add %i1, 0x44, %o1
handle->bnum = 0;
4001b170: c0 26 60 3c clr [ %i1 + 0x3c ]
rtems_rfs_buffer_handle_release (fs, handle);
4001b174: 90 10 00 1d mov %i5, %o0
4001b178: 40 00 04 16 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001b17c: c0 26 60 40 clr [ %i1 + 0x40 ]
handle->dirty = false;
4001b180: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
4001b184: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
4001b188: c0 26 60 4c clr [ %i1 + 0x4c ]
}
4001b18c: 81 c7 e0 08 ret
4001b190: 81 e8 00 00 restore
4001b194 <rtems_rfs_block_map_find>:
{
4001b194: 9d e3 bf 98 save %sp, -104, %sp
*block = 0;
4001b198: c0 26 c0 00 clr [ %i3 ]
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
4001b19c: c2 06 80 00 ld [ %i2 ], %g1
4001b1a0: 80 a0 60 00 cmp %g1, 0
4001b1a4: 02 80 00 05 be 4001b1b8 <rtems_rfs_block_map_find+0x24>
4001b1a8: c4 06 60 08 ld [ %i1 + 8 ], %g2
4001b1ac: 80 a0 a0 00 cmp %g2, 0
4001b1b0: 02 80 00 1a be 4001b218 <rtems_rfs_block_map_find+0x84>
<== NEVER TAKEN
4001b1b4: 90 10 20 06 mov 6, %o0
4001b1b8: 80 a0 40 02 cmp %g1, %g2
4001b1bc: 1a 80 00 17 bcc 4001b218 <rtems_rfs_block_map_find+0x84>
4001b1c0: 90 10 20 06 mov 6, %o0
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
4001b1c4: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
4001b1c8: 80 a0 40 03 cmp %g1, %g3
4001b1cc: 22 80 00 39 be,a 4001b2b0 <rtems_rfs_block_map_find+0x11c>
4001b1d0: c6 06 60 18 ld [ %i1 + 0x18 ], %g3
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
4001b1d4: 80 a0 a0 05 cmp %g2, 5
4001b1d8: 38 80 00 12 bgu,a 4001b220 <rtems_rfs_block_map_find+0x8c>
4001b1dc: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
*block = map->blocks[bpos->bno];
4001b1e0: 82 00 60 08 add %g1, 8, %g1
4001b1e4: 83 28 60 02 sll %g1, 2, %g1
4001b1e8: 82 06 40 01 add %i1, %g1, %g1
4001b1ec: c2 00 60 04 ld [ %g1 + 4 ], %g1
4001b1f0: c2 26 c0 00 st %g1, [ %i3 ]
map->bpos.block = *block;
4001b1f4: 90 10 20 00 clr %o0
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
4001b1f8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4001b1fc: c4 06 80 00 ld [ %i2 ], %g2
4001b200: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001b204: c6 26 60 18 st %g3, [ %i1 + 0x18 ]
4001b208: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
4001b20c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
map->bpos.block = *block;
4001b210: c2 06 c0 00 ld [ %i3 ], %g1
4001b214: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
4001b218: 81 c7 e0 08 ret
4001b21c: 91 e8 00 08 restore %g0, %o0, %o0
direct = bpos->bno % fs->blocks_per_block;
4001b220: 81 80 20 00 wr %g0, %y
4001b224: 01 00 00 00 nop
4001b228: 01 00 00 00 nop
4001b22c: 01 00 00 00 nop
4001b230: 96 70 40 03 udiv %g1, %g3, %o3
singly = bpos->bno / fs->blocks_per_block;
4001b234: d6 27 bf fc st %o3, [ %fp + -4 ]
direct = bpos->bno % fs->blocks_per_block;
4001b238: ba 5a c0 03 smul %o3, %g3, %i5
if (map->size.count <= fs->block_map_singly_blocks)
4001b23c: c8 06 20 38 ld [ %i0 + 0x38 ], %g4
4001b240: 80 a1 00 02 cmp %g4, %g2
4001b244: 1a 80 00 20 bcc 4001b2c4 <rtems_rfs_block_map_find+0x130>
<== ALWAYS TAKEN
4001b248: ba 20 40 1d sub %g1, %i5, %i5
singly %= fs->blocks_per_block;
4001b24c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001b250: 01 00 00 00 nop
<== NOT EXECUTED
4001b254: 01 00 00 00 nop
<== NOT EXECUTED
4001b258: 01 00 00 00 nop
<== NOT EXECUTED
4001b25c: 82 72 c0 03 udiv %o3, %g3, %g1
<== NOT EXECUTED
4001b260: 86 58 40 03 smul %g1, %g3, %g3
<== NOT EXECUTED
4001b264: 96 22 c0 03 sub %o3, %g3, %o3
<== NOT EXECUTED
4001b268: d6 27 bf fc st %o3, [ %fp + -4 ]
<== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001b26c: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
<== NOT EXECUTED
4001b270: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
4001b274: 08 bf ff e9 bleu 4001b218 <rtems_rfs_block_map_find+0x84>
<== NOT EXECUTED
4001b278: 90 10 20 06 mov 6, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_find_indirect (fs,
4001b27c: 82 00 60 08 add %g1, 8, %g1
<== NOT EXECUTED
4001b280: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4001b284: 82 06 40 01 add %i1, %g1, %g1
<== NOT EXECUTED
4001b288: d4 00 60 04 ld [ %g1 + 4 ], %o2
<== NOT EXECUTED
4001b28c: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
4001b290: 92 06 60 44 add %i1, 0x44, %o1
<== NOT EXECUTED
4001b294: 7f ff fe 5e call 4001ac0c <rtems_rfs_block_find_indirect>
<== NOT EXECUTED
4001b298: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc == 0)
4001b29c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b2a0: 12 bf ff de bne 4001b218 <rtems_rfs_block_map_find+0x84>
<== NOT EXECUTED
4001b2a4: d4 07 bf fc ld [ %fp + -4 ], %o2
<== NOT EXECUTED
rc = rtems_rfs_block_find_indirect (fs,
4001b2a8: 10 80 00 0c b 4001b2d8 <rtems_rfs_block_map_find+0x144>
<== NOT EXECUTED
4001b2ac: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
4001b2b0: 80 a0 e0 00 cmp %g3, 0
4001b2b4: 02 bf ff c9 be 4001b1d8 <rtems_rfs_block_map_find+0x44>
<== ALWAYS TAKEN
4001b2b8: 80 a0 a0 05 cmp %g2, 5
*block = map->bpos.block;
4001b2bc: 10 bf ff ce b 4001b1f4 <rtems_rfs_block_map_find+0x60>
<== NOT EXECUTED
4001b2c0: c6 26 c0 00 st %g3, [ %i3 ]
<== NOT EXECUTED
rc = rtems_rfs_block_find_indirect (fs,
4001b2c4: 96 02 e0 08 add %o3, 8, %o3
4001b2c8: 97 2a e0 02 sll %o3, 2, %o3
4001b2cc: 96 06 40 0b add %i1, %o3, %o3
4001b2d0: d4 02 e0 04 ld [ %o3 + 4 ], %o2
rc = rtems_rfs_block_find_indirect (fs,
4001b2d4: 98 10 00 1b mov %i3, %o4
4001b2d8: 96 10 00 1d mov %i5, %o3
4001b2dc: 92 06 60 38 add %i1, 0x38, %o1
4001b2e0: 7f ff fe 4b call 4001ac0c <rtems_rfs_block_find_indirect>
4001b2e4: 90 10 00 18 mov %i0, %o0
if (rc == 0)
4001b2e8: 80 a2 20 00 cmp %o0, 0
4001b2ec: 22 bf ff c3 be,a 4001b1f8 <rtems_rfs_block_map_find+0x64>
<== ALWAYS TAKEN
4001b2f0: 90 10 20 00 clr %o0
4001b2f4: 30 bf ff c9 b,a 4001b218 <rtems_rfs_block_map_find+0x84>
<== NOT EXECUTED
4001b3a4 <rtems_rfs_block_map_grow>:
{
4001b3a4: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001b3a8: 90 10 20 00 clr %o0
4001b3ac: 7f ff e7 22 call 40015034 <rtems_rfs_trace>
4001b3b0: 13 00 00 08 sethi %hi(0x2000), %o1
4001b3b4: 80 a2 20 00 cmp %o0, 0
4001b3b8: 32 80 00 eb bne,a 4001b764 <rtems_rfs_block_map_grow+0x3c0>
<== NEVER TAKEN
4001b3bc: d4 06 60 08 ld [ %i1 + 8 ], %o2
<== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001b3c0: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001b3c4: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
4001b3c8: 82 06 80 01 add %i2, %g1, %g1
4001b3cc: 80 a0 40 02 cmp %g1, %g2
4001b3d0: 1a 80 00 68 bcc 4001b570 <rtems_rfs_block_map_grow+0x1cc>
<== NEVER TAKEN
4001b3d4: b8 10 20 1b mov 0x1b, %i4
for (b = 0; b < blocks; b++)
4001b3d8: 80 a6 a0 00 cmp %i2, 0
4001b3dc: 02 80 00 65 be 4001b570 <rtems_rfs_block_map_grow+0x1cc>
<== NEVER TAKEN
4001b3e0: b8 10 20 00 clr %i4
4001b3e4: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
4001b3e8: a8 10 20 00 clr %l4
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001b3ec: a0 10 20 01 mov 1, %l0
rc = rtems_rfs_buffer_handle_request (fs,
4001b3f0: a4 06 60 44 add %i1, 0x44, %l2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b3f4: 10 80 00 10 b 4001b434 <rtems_rfs_block_map_grow+0x90>
4001b3f8: a2 06 60 38 add %i1, 0x38, %l1
map->blocks[map->size.count] = block;
4001b3fc: 84 00 60 08 add %g1, 8, %g2
4001b400: 85 28 a0 02 sll %g2, 2, %g2
4001b404: 84 06 40 02 add %i1, %g2, %g2
4001b408: d2 20 a0 04 st %o1, [ %g2 + 4 ]
map->size.count++;
4001b40c: 82 00 60 01 inc %g1
map->size.offset = 0;
4001b410: c0 26 60 0c clr [ %i1 + 0xc ]
if (b == 0)
4001b414: 80 a5 20 00 cmp %l4, 0
4001b418: 02 80 00 4f be 4001b554 <rtems_rfs_block_map_grow+0x1b0>
<== ALWAYS TAKEN
4001b41c: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->last_data_block = block;
4001b420: d2 26 60 20 st %o1, [ %i1 + 0x20 ]
<== NOT EXECUTED
for (b = 0; b < blocks; b++)
4001b424: a8 05 20 01 inc %l4
<== NOT EXECUTED
4001b428: 80 a5 00 1a cmp %l4, %i2
<== NOT EXECUTED
4001b42c: 02 80 00 50 be 4001b56c <rtems_rfs_block_map_grow+0x1c8>
<== NOT EXECUTED
4001b430: e0 2e 40 00 stb %l0, [ %i1 ]
<== NOT EXECUTED
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
4001b434: 96 07 bf f8 add %fp, -8, %o3
4001b438: 94 10 20 00 clr %o2
4001b43c: 7f ff df 77 call 40013218 <rtems_rfs_group_bitmap_alloc>
4001b440: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b444: b8 92 20 00 orcc %o0, 0, %i4
4001b448: 14 80 00 4a bg 4001b570 <rtems_rfs_block_map_grow+0x1cc>
4001b44c: 01 00 00 00 nop
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
4001b450: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001b454: 80 a0 60 04 cmp %g1, 4
4001b458: 08 bf ff e9 bleu 4001b3fc <rtems_rfs_block_map_grow+0x58>
4001b45c: d2 07 bf f8 ld [ %fp + -8 ], %o1
direct = map->size.count % fs->blocks_per_block;
4001b460: e6 06 20 34 ld [ %i0 + 0x34 ], %l3
if (map->size.count < fs->block_map_singly_blocks)
4001b464: c4 06 20 38 ld [ %i0 + 0x38 ], %g2
direct = map->size.count % fs->blocks_per_block;
4001b468: 81 80 20 00 wr %g0, %y
4001b46c: 01 00 00 00 nop
4001b470: 01 00 00 00 nop
4001b474: 01 00 00 00 nop
4001b478: 96 70 40 13 udiv %g1, %l3, %o3
if (map->size.count < fs->block_map_singly_blocks)
4001b47c: 80 a0 40 02 cmp %g1, %g2
direct = map->size.count % fs->blocks_per_block;
4001b480: ba 5a c0 13 smul %o3, %l3, %i5
if (map->size.count < fs->block_map_singly_blocks)
4001b484: 1a 80 00 3d bcc 4001b578 <rtems_rfs_block_map_grow+0x1d4>
<== NEVER TAKEN
4001b488: ba 20 40 1d sub %g1, %i5, %i5
if ((direct == 0) ||
4001b48c: 80 a7 60 00 cmp %i5, 0
4001b490: 02 80 00 06 be 4001b4a8 <rtems_rfs_block_map_grow+0x104>
<== NEVER TAKEN
4001b494: 80 a2 e0 00 cmp %o3, 0
4001b498: 12 80 00 95 bne 4001b6ec <rtems_rfs_block_map_grow+0x348>
<== NEVER TAKEN
4001b49c: 80 a7 60 05 cmp %i5, 5
4001b4a0: 32 80 00 94 bne,a 4001b6f0 <rtems_rfs_block_map_grow+0x34c>
4001b4a4: 82 02 e0 08 add %o3, 8, %g1
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
4001b4a8: 82 18 60 05 xor %g1, 5, %g1
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b4ac: 80 a0 00 01 cmp %g0, %g1
&map->blocks[singly],
4001b4b0: 96 02 e0 09 add %o3, 9, %o3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b4b4: 98 60 3f ff subx %g0, -1, %o4
&map->blocks[singly],
4001b4b8: 97 2a e0 02 sll %o3, 2, %o3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b4bc: 94 10 00 11 mov %l1, %o2
4001b4c0: 96 06 40 0b add %i1, %o3, %o3
4001b4c4: 92 10 00 19 mov %i1, %o1
4001b4c8: 7f ff fd 7e call 4001aac0 <rtems_rfs_block_map_indirect_alloc>
4001b4cc: 90 10 00 18 mov %i0, %o0
4001b4d0: b8 10 00 08 mov %o0, %i4
if (rc > 0)
4001b4d4: 80 a7 20 00 cmp %i4, 0
4001b4d8: 14 80 00 aa bg 4001b780 <rtems_rfs_block_map_grow+0x3dc>
<== NEVER TAKEN
4001b4dc: d4 07 bf f8 ld [ %fp + -8 ], %o2
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001b4e0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001b4e4: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
4001b4e8: c6 0f bf f8 ldub [ %fp + -8 ], %g3
4001b4ec: 83 2f 60 02 sll %i5, 2, %g1
4001b4f0: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
if (b == 0)
4001b4f4: 80 a5 20 00 cmp %l4, 0
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001b4f8: c4 06 60 40 ld [ %i1 + 0x40 ], %g2
4001b4fc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4001b500: c6 17 bf f8 lduh [ %fp + -8 ], %g3
4001b504: 84 00 80 01 add %g2, %g1, %g2
4001b508: c6 28 a0 01 stb %g3, [ %g2 + 1 ]
4001b50c: c4 06 60 40 ld [ %i1 + 0x40 ], %g2
4001b510: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4001b514: c6 07 bf f8 ld [ %fp + -8 ], %g3
4001b518: 84 00 80 01 add %g2, %g1, %g2
4001b51c: 87 30 e0 08 srl %g3, 8, %g3
4001b520: c6 28 a0 02 stb %g3, [ %g2 + 2 ]
4001b524: c4 06 60 40 ld [ %i1 + 0x40 ], %g2
4001b528: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4001b52c: 82 00 80 01 add %g2, %g1, %g1
4001b530: c4 07 bf f8 ld [ %fp + -8 ], %g2
4001b534: c4 28 60 03 stb %g2, [ %g1 + 3 ]
4001b538: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.count++;
4001b53c: 82 00 60 01 inc %g1
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001b540: e0 2e 60 38 stb %l0, [ %i1 + 0x38 ]
map->size.offset = 0;
4001b544: c0 26 60 0c clr [ %i1 + 0xc ]
map->size.count++;
4001b548: c2 26 60 08 st %g1, [ %i1 + 8 ]
if (b == 0)
4001b54c: 12 bf ff b5 bne 4001b420 <rtems_rfs_block_map_grow+0x7c>
<== NEVER TAKEN
4001b550: d2 07 bf f8 ld [ %fp + -8 ], %o1
*new_block = block;
4001b554: d2 26 c0 00 st %o1, [ %i3 ]
for (b = 0; b < blocks; b++)
4001b558: a8 05 20 01 inc %l4
map->last_data_block = block;
4001b55c: d2 26 60 20 st %o1, [ %i1 + 0x20 ]
for (b = 0; b < blocks; b++)
4001b560: 80 a5 00 1a cmp %l4, %i2
4001b564: 12 bf ff b4 bne 4001b434 <rtems_rfs_block_map_grow+0x90>
<== NEVER TAKEN
4001b568: e0 2e 40 00 stb %l0, [ %i1 ]
return 0;
4001b56c: b8 10 20 00 clr %i4
}
4001b570: 81 c7 e0 08 ret
4001b574: 91 e8 00 1c restore %g0, %i4, %o0
doubly = singly / fs->blocks_per_block;
4001b578: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001b57c: 01 00 00 00 nop
<== NOT EXECUTED
4001b580: 01 00 00 00 nop
<== NOT EXECUTED
4001b584: 01 00 00 00 nop
<== NOT EXECUTED
4001b588: aa 72 c0 13 udiv %o3, %l3, %l5
<== NOT EXECUTED
if (direct == 0)
4001b58c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
singly %= fs->blocks_per_block;
4001b590: a6 5d 40 13 smul %l5, %l3, %l3
<== NOT EXECUTED
if (direct == 0)
4001b594: 12 80 00 37 bne 4001b670 <rtems_rfs_block_map_grow+0x2cc>
<== NOT EXECUTED
4001b598: a6 22 c0 13 sub %o3, %l3, %l3
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b59c: 98 10 20 00 clr %o4
<== NOT EXECUTED
4001b5a0: 96 07 bf fc add %fp, -4, %o3
<== NOT EXECUTED
4001b5a4: 94 10 00 11 mov %l1, %o2
<== NOT EXECUTED
4001b5a8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001b5ac: 7f ff fd 45 call 4001aac0 <rtems_rfs_block_map_indirect_alloc>
<== NOT EXECUTED
4001b5b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b5b4: b8 92 20 00 orcc %o0, 0, %i4
<== NOT EXECUTED
4001b5b8: 14 80 00 71 bg 4001b77c <rtems_rfs_block_map_grow+0x3d8>
<== NOT EXECUTED
4001b5bc: 80 a4 e0 00 cmp %l3, 0
<== NOT EXECUTED
if ((singly == 0) ||
4001b5c0: 02 80 00 06 be 4001b5d8 <rtems_rfs_block_map_grow+0x234>
<== NOT EXECUTED
4001b5c4: 80 a5 60 00 cmp %l5, 0
<== NOT EXECUTED
4001b5c8: 12 80 00 53 bne 4001b714 <rtems_rfs_block_map_grow+0x370>
<== NOT EXECUTED
4001b5cc: 80 a4 e0 05 cmp %l3, 5
<== NOT EXECUTED
4001b5d0: 12 80 00 52 bne 4001b718 <rtems_rfs_block_map_grow+0x374>
<== NOT EXECUTED
4001b5d4: 82 05 60 08 add %l5, 8, %g1
<== NOT EXECUTED
upping = map->size.count == fs->block_map_singly_blocks;
4001b5d8: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4001b5dc: c4 06 20 38 ld [ %i0 + 0x38 ], %g2
<== NOT EXECUTED
4001b5e0: 82 18 40 02 xor %g1, %g2, %g1
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b5e4: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
&map->blocks[doubly],
4001b5e8: 96 05 60 09 add %l5, 9, %o3
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b5ec: 98 60 3f ff subx %g0, -1, %o4
<== NOT EXECUTED
&map->blocks[doubly],
4001b5f0: 97 2a e0 02 sll %o3, 2, %o3
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001b5f4: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001b5f8: 96 06 40 0b add %i1, %o3, %o3
<== NOT EXECUTED
4001b5fc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001b600: 7f ff fd 30 call 4001aac0 <rtems_rfs_block_map_indirect_alloc>
<== NOT EXECUTED
4001b604: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b608: b8 92 20 00 orcc %o0, 0, %i4
<== NOT EXECUTED
4001b60c: 14 80 00 4e bg 4001b744 <rtems_rfs_block_map_grow+0x3a0>
<== NOT EXECUTED
4001b610: d4 07 bf fc ld [ %fp + -4 ], %o2
<== NOT EXECUTED
rtems_rfs_block_set_number (&map->doubly_buffer,
4001b614: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
4001b618: c4 0f bf fc ldub [ %fp + -4 ], %g2
<== NOT EXECUTED
4001b61c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4001b620: 97 2c e0 02 sll %l3, 2, %o3
<== NOT EXECUTED
4001b624: c4 28 40 0b stb %g2, [ %g1 + %o3 ]
<== NOT EXECUTED
4001b628: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
4001b62c: c4 17 bf fc lduh [ %fp + -4 ], %g2
<== NOT EXECUTED
4001b630: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4001b634: 82 00 40 0b add %g1, %o3, %g1
<== NOT EXECUTED
4001b638: c4 28 60 01 stb %g2, [ %g1 + 1 ]
<== NOT EXECUTED
4001b63c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
4001b640: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4001b644: c4 07 bf fc ld [ %fp + -4 ], %g2
<== NOT EXECUTED
4001b648: 82 00 40 0b add %g1, %o3, %g1
<== NOT EXECUTED
4001b64c: 85 30 a0 08 srl %g2, 8, %g2
<== NOT EXECUTED
4001b650: c4 28 60 02 stb %g2, [ %g1 + 2 ]
<== NOT EXECUTED
4001b654: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
4001b658: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
<== NOT EXECUTED
4001b65c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4001b660: 96 04 c0 0b add %l3, %o3, %o3
<== NOT EXECUTED
4001b664: c2 2a e0 03 stb %g1, [ %o3 + 3 ]
<== NOT EXECUTED
4001b668: 10 bf ff 9e b 4001b4e0 <rtems_rfs_block_map_grow+0x13c>
<== NOT EXECUTED
4001b66c: e0 2e 60 44 stb %l0, [ %i1 + 0x44 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,
4001b670: aa 05 60 08 add %l5, 8, %l5
<== NOT EXECUTED
4001b674: ab 2d 60 02 sll %l5, 2, %l5
<== NOT EXECUTED
4001b678: aa 06 40 15 add %i1, %l5, %l5
<== NOT EXECUTED
4001b67c: d4 05 60 04 ld [ %l5 + 4 ], %o2
<== NOT EXECUTED
4001b680: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001b684: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001b688: 40 00 02 0b call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001b68c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b690: b8 92 20 00 orcc %o0, 0, %i4
<== NOT EXECUTED
4001b694: 14 80 00 3a bg 4001b77c <rtems_rfs_block_map_grow+0x3d8>
<== NOT EXECUTED
4001b698: 97 2c e0 02 sll %l3, 2, %o3
<== NOT EXECUTED
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b69c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
4001b6a0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
<== NOT EXECUTED
4001b6a4: d4 08 80 0b ldub [ %g2 + %o3 ], %o2
<== NOT EXECUTED
4001b6a8: 82 00 80 0b add %g2, %o3, %g1
<== NOT EXECUTED
4001b6ac: c6 08 60 03 ldub [ %g1 + 3 ], %g3
<== NOT EXECUTED
4001b6b0: c4 08 60 01 ldub [ %g1 + 1 ], %g2
<== NOT EXECUTED
4001b6b4: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
4001b6b8: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001b6bc: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001b6c0: 95 2a a0 18 sll %o2, 0x18, %o2
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b6c4: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b6c8: 94 12 80 03 or %o2, %g3, %o2
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b6cc: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b6d0: 94 12 80 02 or %o2, %g2, %o2
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b6d4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b6d8: 94 12 80 01 or %o2, %g1, %o2
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b6dc: 40 00 01 f6 call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001b6e0: d4 27 bf fc st %o2, [ %fp + -4 ]
<== NOT EXECUTED
4001b6e4: 10 bf ff 7c b 4001b4d4 <rtems_rfs_block_map_grow+0x130>
<== NOT EXECUTED
4001b6e8: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b6ec: 82 02 e0 08 add %o3, 8, %g1
<== NOT EXECUTED
4001b6f0: 83 28 60 02 sll %g1, 2, %g1
4001b6f4: 82 06 40 01 add %i1, %g1, %g1
4001b6f8: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001b6fc: 96 10 20 01 mov 1, %o3
4001b700: 92 10 00 11 mov %l1, %o1
4001b704: 40 00 01 ec call 4001beb4 <rtems_rfs_buffer_handle_request>
4001b708: 90 10 00 18 mov %i0, %o0
4001b70c: 10 bf ff 72 b 4001b4d4 <rtems_rfs_block_map_grow+0x130>
4001b710: b8 10 00 08 mov %o0, %i4
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001b714: 82 05 60 08 add %l5, 8, %g1
<== NOT EXECUTED
4001b718: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4001b71c: 82 06 40 01 add %i1, %g1, %g1
<== NOT EXECUTED
4001b720: d4 00 60 04 ld [ %g1 + 4 ], %o2
<== NOT EXECUTED
4001b724: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001b728: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001b72c: 40 00 01 e2 call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001b730: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b734: b8 92 20 00 orcc %o0, 0, %i4
<== NOT EXECUTED
4001b738: 24 bf ff b8 ble,a 4001b618 <rtems_rfs_block_map_grow+0x274>
<== NOT EXECUTED
4001b73c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, singly_block);
4001b740: d4 07 bf fc ld [ %fp + -4 ], %o2
<== NOT EXECUTED
4001b744: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b748: 7f ff df 62 call 400134d0 <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
4001b74c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
4001b750: d4 07 bf f8 ld [ %fp + -8 ], %o2
<== NOT EXECUTED
4001b754: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b758: 7f ff df 5e call 400134d0 <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
4001b75c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rc;
4001b760: 30 bf ff 84 b,a 4001b570 <rtems_rfs_block_map_grow+0x1cc>
<== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
4001b764: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001b768: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001b76c: 7f ff e6 bf call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001b770: 90 12 20 78 or %o0, 0x78, %o0 ! 40032878 <status_code_to_errno+0x134>
<== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001b774: 10 bf ff 14 b 4001b3c4 <rtems_rfs_block_map_grow+0x20>
<== NOT EXECUTED
4001b778: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
4001b77c: d4 07 bf f8 ld [ %fp + -8 ], %o2
<== NOT EXECUTED
4001b780: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b784: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001b788: 7f ff df 52 call 400134d0 <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
4001b78c: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
}
4001b790: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b794: 81 e8 00 00 restore
<== NOT EXECUTED
4001ae4c <rtems_rfs_block_map_open>:
{
4001ae4c: 9d e3 bf a0 save %sp, -96, %sp
map->dirty = false;
4001ae50: c0 2e 80 00 clrb [ %i2 ]
rc = rtems_rfs_inode_load (fs, inode);
4001ae54: 92 10 00 19 mov %i1, %o1
map->inode = NULL;
4001ae58: c0 26 a0 04 clr [ %i2 + 4 ]
rc = rtems_rfs_inode_load (fs, inode);
4001ae5c: 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;
4001ae60: c0 26 a0 08 clr [ %i2 + 8 ]
{
4001ae64: ba 10 00 1a mov %i2, %i5
size->offset = 0;
4001ae68: c0 26 a0 0c clr [ %i2 + 0xc ]
bpos->bno = 0;
4001ae6c: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
4001ae70: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
4001ae74: c0 26 a0 18 clr [ %i2 + 0x18 ]
handle->dirty = false;
4001ae78: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
4001ae7c: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
4001ae80: c0 26 a0 40 clr [ %i2 + 0x40 ]
handle->dirty = false;
4001ae84: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
4001ae88: c0 26 a0 48 clr [ %i2 + 0x48 ]
rc = rtems_rfs_inode_load (fs, inode);
4001ae8c: 7f ff e2 08 call 400136ac <rtems_rfs_inode_load>
4001ae90: c0 26 a0 4c clr [ %i2 + 0x4c ]
if (rc > 0)
4001ae94: b8 92 20 00 orcc %o0, 0, %i4
4001ae98: 14 80 00 3d bg 4001af8c <rtems_rfs_block_map_open+0x140>
<== NEVER TAKEN
4001ae9c: 88 06 a0 24 add %i2, 0x24, %g4
4001aea0: de 06 60 0c ld [ %i1 + 0xc ], %o7
map->inode = inode;
4001aea4: f2 26 a0 04 st %i1, [ %i2 + 4 ]
4001aea8: 82 03 e0 1c add %o7, 0x1c, %g1
4001aeac: b4 06 a0 38 add %i2, 0x38, %i2
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4001aeb0: f6 08 40 00 ldub [ %g1 ], %i3
4001aeb4: c6 08 60 01 ldub [ %g1 + 1 ], %g3
4001aeb8: c4 08 60 02 ldub [ %g1 + 2 ], %g2
4001aebc: f8 08 60 03 ldub [ %g1 + 3 ], %i4
4001aec0: b7 2e e0 18 sll %i3, 0x18, %i3
4001aec4: 87 28 e0 10 sll %g3, 0x10, %g3
4001aec8: 85 28 a0 08 sll %g2, 8, %g2
4001aecc: 86 10 c0 1b or %g3, %i3, %g3
4001aed0: 84 10 80 03 or %g2, %g3, %g2
4001aed4: 84 17 00 02 or %i4, %g2, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
4001aed8: c4 21 00 00 st %g2, [ %g4 ]
4001aedc: 88 01 20 04 add %g4, 4, %g4
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001aee0: 80 a6 80 04 cmp %i2, %g4
4001aee4: 12 bf ff f3 bne 4001aeb0 <rtems_rfs_block_map_open+0x64>
4001aee8: 82 00 60 04 add %g1, 4, %g1
return rtems_rfs_read_u32 (&handle->node->block_count);
4001aeec: c6 0b e0 0f ldub [ %o7 + 0xf ], %g3
4001aef0: c8 0b e0 0c ldub [ %o7 + 0xc ], %g4
4001aef4: c4 0b e0 0d ldub [ %o7 + 0xd ], %g2
4001aef8: c2 0b e0 0e ldub [ %o7 + 0xe ], %g1
4001aefc: 89 29 20 18 sll %g4, 0x18, %g4
4001af00: 85 28 a0 10 sll %g2, 0x10, %g2
4001af04: 83 28 60 08 sll %g1, 8, %g1
4001af08: 84 10 80 04 or %g2, %g4, %g2
4001af0c: 82 10 40 02 or %g1, %g2, %g1
4001af10: 82 10 c0 01 or %g3, %g1, %g1
map->size.count = rtems_rfs_inode_get_block_count (inode);
4001af14: c2 27 60 08 st %g1, [ %i5 + 8 ]
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001af18: c4 0b e0 0b ldub [ %o7 + 0xb ], %g2
4001af1c: c2 0b e0 0a ldub [ %o7 + 0xa ], %g1
4001af20: 83 28 60 08 sll %g1, 8, %g1
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
4001af24: 82 10 40 02 or %g1, %g2, %g1
4001af28: c2 27 60 0c st %g1, [ %i5 + 0xc ]
return rtems_rfs_read_u32 (&handle->node->last_map_block);
4001af2c: c6 0b e0 33 ldub [ %o7 + 0x33 ], %g3
4001af30: c8 0b e0 30 ldub [ %o7 + 0x30 ], %g4
4001af34: c4 0b e0 31 ldub [ %o7 + 0x31 ], %g2
4001af38: c2 0b e0 32 ldub [ %o7 + 0x32 ], %g1
4001af3c: 89 29 20 18 sll %g4, 0x18, %g4
4001af40: 85 28 a0 10 sll %g2, 0x10, %g2
4001af44: 83 28 60 08 sll %g1, 8, %g1
4001af48: 84 10 80 04 or %g2, %g4, %g2
4001af4c: 82 10 40 02 or %g1, %g2, %g1
4001af50: 82 10 c0 01 or %g3, %g1, %g1
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
4001af54: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
return rtems_rfs_read_u32 (&handle->node->last_data_block);
4001af58: c8 0b e0 34 ldub [ %o7 + 0x34 ], %g4
4001af5c: c4 0b e0 35 ldub [ %o7 + 0x35 ], %g2
4001af60: c2 0b e0 36 ldub [ %o7 + 0x36 ], %g1
4001af64: c6 0b e0 37 ldub [ %o7 + 0x37 ], %g3
4001af68: 89 29 20 18 sll %g4, 0x18, %g4
4001af6c: 85 28 a0 10 sll %g2, 0x10, %g2
4001af70: 83 28 60 08 sll %g1, 8, %g1
4001af74: 84 10 80 04 or %g2, %g4, %g2
4001af78: 82 10 40 02 or %g1, %g2, %g1
4001af7c: 82 10 c0 01 or %g3, %g1, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
4001af80: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
4001af84: 7f ff e2 30 call 40013844 <rtems_rfs_inode_unload>
4001af88: 95 e8 20 00 restore %g0, 0, %o2
rtems_rfs_buffer_handle_release (fs, handle);
4001af8c: 92 06 a0 38 add %i2, 0x38, %o1
<== NOT EXECUTED
4001af90: 40 00 04 90 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001af94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->dirty = false;
4001af98: c0 2e a0 38 clrb [ %i2 + 0x38 ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001af9c: 92 06 a0 44 add %i2, 0x44, %o1
<== NOT EXECUTED
handle->bnum = 0;
4001afa0: c0 26 a0 3c clr [ %i2 + 0x3c ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001afa4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->buffer = NULL;
4001afa8: c0 26 a0 40 clr [ %i2 + 0x40 ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001afac: 40 00 04 89 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001afb0: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
handle->dirty = false;
4001afb4: c0 2e a0 44 clrb [ %i2 + 0x44 ]
<== NOT EXECUTED
handle->bnum = 0;
4001afb8: c0 26 a0 48 clr [ %i2 + 0x48 ]
<== NOT EXECUTED
handle->buffer = NULL;
4001afbc: c0 26 a0 4c clr [ %i2 + 0x4c ]
<== NOT EXECUTED
}
4001afc0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001afc4: 81 e8 00 00 restore
<== NOT EXECUTED
4001b798 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
4001b798: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
4001b79c: 90 10 20 00 clr %o0
4001b7a0: 7f ff e6 25 call 40015034 <rtems_rfs_trace>
4001b7a4: 13 00 00 10 sethi %hi(0x4000), %o1
4001b7a8: 80 a2 20 00 cmp %o0, 0
4001b7ac: 32 80 00 a3 bne,a 4001ba38 <rtems_rfs_block_map_shrink+0x2a0>
<== NEVER TAKEN
4001b7b0: 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)
4001b7b4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001b7b8: 80 a0 60 00 cmp %g1, 0
4001b7bc: 02 80 00 9a be 4001ba24 <rtems_rfs_block_map_shrink+0x28c>
4001b7c0: 80 a0 40 1a cmp %g1, %i2
4001b7c4: 18 80 00 9b bgu 4001ba30 <rtems_rfs_block_map_shrink+0x298>
<== NEVER TAKEN
4001b7c8: b6 10 00 01 mov %g1, %i3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001b7cc: 80 a6 e0 00 cmp %i3, 0
4001b7d0: 02 80 00 8e be 4001ba08 <rtems_rfs_block_map_shrink+0x270>
<== NEVER TAKEN
4001b7d4: a2 06 60 44 add %i1, 0x44, %l1
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b7d8: a0 06 60 38 add %i1, 0x38, %l0
if (rc > 0)
return rc;
map->last_map_block = singly;
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001b7dc: a6 06 60 4c add %i1, 0x4c, %l3
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001b7e0: a4 06 60 40 add %i1, 0x40, %l2
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
4001b7e4: 10 80 00 13 b 4001b830 <rtems_rfs_block_map_shrink+0x98>
4001b7e8: b4 10 20 01 mov 1, %i2
4001b7ec: 82 06 40 01 add %i1, %g1, %g1
block_to_free = map->blocks[block];
4001b7f0: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
map->blocks[block] = 0;
4001b7f4: c0 20 60 20 clr [ %g1 + 0x20 ]
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001b7f8: 94 10 00 1d mov %i5, %o2
4001b7fc: 92 10 20 00 clr %o1
4001b800: 7f ff df 34 call 400134d0 <rtems_rfs_group_bitmap_free>
4001b804: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b808: 80 a2 20 00 cmp %o0, 0
4001b80c: 14 80 00 61 bg 4001b990 <rtems_rfs_block_map_shrink+0x1f8>
<== NEVER TAKEN
4001b810: b6 86 ff ff addcc %i3, -1, %i3
map->size.count--;
4001b814: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001b818: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
4001b81c: c0 26 60 0c clr [ %i1 + 0xc ]
map->size.count--;
4001b820: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->last_data_block = block_to_free;
4001b824: fa 26 60 20 st %i5, [ %i1 + 0x20 ]
while (blocks)
4001b828: 02 80 00 8a be 4001ba50 <rtems_rfs_block_map_shrink+0x2b8>
4001b82c: f4 2e 40 00 stb %i2, [ %i1 ]
block = map->size.count - 1;
4001b830: 84 00 7f ff add %g1, -1, %g2
if (block < RTEMS_RFS_INODE_BLOCKS)
4001b834: 80 a0 a0 04 cmp %g2, 4
4001b838: 28 bf ff ed bleu,a 4001b7ec <rtems_rfs_block_map_shrink+0x54>
4001b83c: 83 28 60 02 sll %g1, 2, %g1
direct = block % fs->blocks_per_block;
4001b840: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
if (block < fs->block_map_singly_blocks)
4001b844: c8 06 20 38 ld [ %i0 + 0x38 ], %g4
direct = block % fs->blocks_per_block;
4001b848: 81 80 20 00 wr %g0, %y
4001b84c: 01 00 00 00 nop
4001b850: 01 00 00 00 nop
4001b854: 01 00 00 00 nop
4001b858: aa 70 80 03 udiv %g2, %g3, %l5
if (block < fs->block_map_singly_blocks)
4001b85c: 80 a1 00 02 cmp %g4, %g2
direct = block % fs->blocks_per_block;
4001b860: ac 5d 40 03 smul %l5, %g3, %l6
if (block < fs->block_map_singly_blocks)
4001b864: 18 80 00 4d bgu 4001b998 <rtems_rfs_block_map_shrink+0x200>
<== ALWAYS TAKEN
4001b868: ac 20 80 16 sub %g2, %l6, %l6
else if (block < fs->block_map_doubly_blocks)
4001b86c: c8 06 20 3c ld [ %i0 + 0x3c ], %g4
<== NOT EXECUTED
4001b870: 80 a1 00 02 cmp %g4, %g2
<== NOT EXECUTED
4001b874: 08 80 00 77 bleu 4001ba50 <rtems_rfs_block_map_shrink+0x2b8>
<== NOT EXECUTED
4001b878: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
doubly = singly / fs->blocks_per_block;
4001b87c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001b880: 01 00 00 00 nop
<== NOT EXECUTED
4001b884: 01 00 00 00 nop
<== NOT EXECUTED
4001b888: 01 00 00 00 nop
<== NOT EXECUTED
4001b88c: ae 75 40 03 udiv %l5, %g3, %l7
<== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001b890: 86 5d c0 03 smul %l7, %g3, %g3
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001b894: 82 05 e0 08 add %l7, 8, %g1
<== NOT EXECUTED
4001b898: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4001b89c: 82 06 40 01 add %i1, %g1, %g1
<== NOT EXECUTED
4001b8a0: d4 00 60 04 ld [ %g1 + 4 ], %o2
<== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001b8a4: aa 25 40 03 sub %l5, %g3, %l5
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001b8a8: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
4001b8ac: 40 00 01 82 call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001b8b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b8b4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b8b8: 14 80 00 36 bg 4001b990 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
4001b8bc: 85 2d 60 02 sll %l5, 2, %g2
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b8c0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
4001b8c4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
<== NOT EXECUTED
4001b8c8: e8 08 c0 02 ldub [ %g3 + %g2 ], %l4
<== NOT EXECUTED
4001b8cc: 82 00 c0 02 add %g3, %g2, %g1
<== NOT EXECUTED
4001b8d0: c6 08 60 03 ldub [ %g1 + 3 ], %g3
<== NOT EXECUTED
4001b8d4: c4 08 60 01 ldub [ %g1 + 1 ], %g2
<== NOT EXECUTED
4001b8d8: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
4001b8dc: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001b8e0: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001b8e4: a9 2d 20 18 sll %l4, 0x18, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b8e8: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b8ec: a8 15 00 03 or %l4, %g3, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b8f0: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b8f4: a8 15 00 02 or %l4, %g2, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b8f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001b8fc: a8 15 00 01 or %l4, %g1, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b900: 40 00 01 6d call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001b904: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
if (rc > 0)
4001b908: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b90c: 14 80 00 21 bg 4001b990 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
4001b910: 85 2d a0 02 sll %l6, 2, %g2
<== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001b914: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
<== NOT EXECUTED
4001b918: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
<== NOT EXECUTED
4001b91c: 82 00 c0 02 add %g3, %g2, %g1
<== NOT EXECUTED
4001b920: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
<== NOT EXECUTED
4001b924: c6 08 60 03 ldub [ %g1 + 3 ], %g3
<== NOT EXECUTED
4001b928: c4 08 60 01 ldub [ %g1 + 1 ], %g2
<== NOT EXECUTED
4001b92c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
4001b930: bb 2f 60 18 sll %i5, 0x18, %i5
<== NOT EXECUTED
4001b934: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001b938: ba 17 40 03 or %i5, %g3, %i5
<== NOT EXECUTED
4001b93c: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001b940: ba 17 40 02 or %i5, %g2, %i5
<== NOT EXECUTED
if (direct == 0)
4001b944: 80 a5 a0 00 cmp %l6, 0
<== NOT EXECUTED
4001b948: 12 bf ff ac bne 4001b7f8 <rtems_rfs_block_map_shrink+0x60>
<== NOT EXECUTED
4001b94c: ba 17 40 01 or %i5, %g1, %i5
<== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
4001b950: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
4001b954: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b958: 7f ff de de call 400134d0 <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
4001b95c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b960: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b964: 14 80 00 0b bg 4001b990 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
4001b968: 98 10 00 15 mov %l5, %o4
<== NOT EXECUTED
map->last_map_block = singly;
4001b96c: e8 26 60 1c st %l4, [ %i1 + 0x1c ]
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001b970: 96 10 00 17 mov %l7, %o3
<== NOT EXECUTED
4001b974: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4001b978: 92 10 00 19 mov %i1, %o1
4001b97c: 7f ff fc d7 call 4001acd8 <rtems_rfs_block_map_indirect_shrink.isra.12>
4001b980: 90 10 00 18 mov %i0, %o0
if (rc)
4001b984: 80 a2 20 00 cmp %o0, 0
4001b988: 02 bf ff 9d be 4001b7fc <rtems_rfs_block_map_shrink+0x64>
<== ALWAYS TAKEN
4001b98c: 94 10 00 1d mov %i5, %o2
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
4001b990: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b994: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001b998: 82 05 60 08 add %l5, 8, %g1
4001b99c: 83 28 60 02 sll %g1, 2, %g1
4001b9a0: 82 06 40 01 add %i1, %g1, %g1
4001b9a4: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001b9a8: 96 10 20 01 mov 1, %o3
4001b9ac: 92 10 00 10 mov %l0, %o1
4001b9b0: 40 00 01 41 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001b9b4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b9b8: 80 a2 20 00 cmp %o0, 0
4001b9bc: 14 bf ff f5 bg 4001b990 <rtems_rfs_block_map_shrink+0x1f8>
<== NEVER TAKEN
4001b9c0: 85 2d a0 02 sll %l6, 2, %g2
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001b9c4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001b9c8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
4001b9cc: 82 00 c0 02 add %g3, %g2, %g1
4001b9d0: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
4001b9d4: c6 08 60 03 ldub [ %g1 + 3 ], %g3
4001b9d8: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001b9dc: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001b9e0: bb 2f 60 18 sll %i5, 0x18, %i5
4001b9e4: 85 28 a0 10 sll %g2, 0x10, %g2
4001b9e8: ba 17 40 03 or %i5, %g3, %i5
4001b9ec: 83 28 60 08 sll %g1, 8, %g1
4001b9f0: ba 17 40 02 or %i5, %g2, %i5
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001b9f4: 98 10 00 16 mov %l6, %o4
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001b9f8: ba 17 40 01 or %i5, %g1, %i5
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001b9fc: 96 10 00 15 mov %l5, %o3
4001ba00: 10 bf ff de b 4001b978 <rtems_rfs_block_map_shrink+0x1e0>
4001ba04: 94 10 00 12 mov %l2, %o2
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
4001ba08: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
4001ba0c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4001ba10: 08 80 00 25 bleu 4001baa4 <rtems_rfs_block_map_shrink+0x30c>
<== NOT EXECUTED
4001ba14: 86 00 7f ff add %g1, -1, %g3
<== NOT EXECUTED
4001ba18: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
4001ba1c: 22 80 00 1c be,a 4001ba8c <rtems_rfs_block_map_shrink+0x2f4>
<== NOT EXECUTED
4001ba20: c4 06 60 0c ld [ %i1 + 0xc ], %g2
<== NOT EXECUTED
return 0;
4001ba24: 90 10 20 00 clr %o0
}
4001ba28: 81 c7 e0 08 ret
4001ba2c: 91 e8 00 08 restore %g0, %o0, %o0
4001ba30: 10 bf ff 67 b 4001b7cc <rtems_rfs_block_map_shrink+0x34>
<== NOT EXECUTED
4001ba34: b6 10 00 1a mov %i2, %i3
<== NOT EXECUTED
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
4001ba38: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001ba3c: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001ba40: 7f ff e6 0a call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ba44: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400328b0 <status_code_to_errno+0x16c>
<== NOT EXECUTED
if (map->size.count == 0)
4001ba48: 10 bf ff 5c b 4001b7b8 <rtems_rfs_block_map_shrink+0x20>
<== NOT EXECUTED
4001ba4c: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
if (map->size.count == 0)
4001ba50: 80 a0 60 00 cmp %g1, 0
4001ba54: 32 bf ff ee bne,a 4001ba0c <rtems_rfs_block_map_shrink+0x274>
<== NEVER TAKEN
4001ba58: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
map->last_map_block = 0;
4001ba5c: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
4001ba60: c0 26 60 20 clr [ %i1 + 0x20 ]
4001ba64: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
4001ba68: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
4001ba6c: 80 a0 a0 00 cmp %g2, 0
4001ba70: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
4001ba74: 02 bf ff ec be 4001ba24 <rtems_rfs_block_map_shrink+0x28c>
<== ALWAYS TAKEN
4001ba78: c0 26 60 18 clr [ %i1 + 0x18 ]
4001ba7c: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
return 0;
4001ba80: 90 10 20 00 clr %o0
<== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
4001ba84: 10 bf ff c3 b 4001b990 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
4001ba88: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
<== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
4001ba8c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
<== NOT EXECUTED
4001ba90: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
4001ba94: 38 bf ff f6 bgu,a 4001ba6c <rtems_rfs_block_map_shrink+0x2d4>
<== NOT EXECUTED
4001ba98: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
<== NOT EXECUTED
return 0;
4001ba9c: 10 bf ff e3 b 4001ba28 <rtems_rfs_block_map_shrink+0x290>
<== NOT EXECUTED
4001baa0: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001baa4: 10 bf ff f1 b 4001ba68 <rtems_rfs_block_map_shrink+0x2d0>
<== NOT EXECUTED
4001baa8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
<== NOT EXECUTED
400208e0 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
400208e0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
400208e4: 90 10 20 00 clr %o0
400208e8: 7f ff d1 d3 call 40015034 <rtems_rfs_trace>
400208ec: 92 10 20 40 mov 0x40, %o1
400208f0: 80 a2 20 00 cmp %o0, 0
400208f4: 02 80 00 0b be 40020920 <rtems_rfs_buffer_bdbuf_release+0x40>
<== ALWAYS TAKEN
400208f8: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
400208fc: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
40020900: 12 80 00 18 bne 40020960 <rtems_rfs_buffer_bdbuf_release+0x80>
<== NOT EXECUTED
40020904: d4 06 20 18 ld [ %i0 + 0x18 ], %o2
<== NOT EXECUTED
40020908: 17 10 00 ce sethi %hi(0x40033800), %o3
<== NOT EXECUTED
4002090c: 96 12 e0 48 or %o3, 0x48, %o3 ! 40033848 <status_code_to_errno+0x1104>
<== NOT EXECUTED
40020910: 11 10 00 d0 sethi %hi(0x40034000), %o0
<== NOT EXECUTED
40020914: 7f ff d2 55 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40020918: 90 12 22 40 or %o0, 0x240, %o0 ! 40034240 <CSWTCH.1+0x1c>
<== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
4002091c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40020920: 02 80 00 09 be 40020944 <rtems_rfs_buffer_bdbuf_release+0x64>
40020924: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
40020928: 7f ff dc 41 call 40017a2c <rtems_bdbuf_release_modified>
4002092c: 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;
40020930: 80 a0 00 08 cmp %g0, %o0
40020934: b0 40 3f ff addx %g0, -1, %i0
40020938: b0 0e 3f fb and %i0, -5, %i0
}
return rc;
}
4002093c: 81 c7 e0 08 ret
40020940: 91 ee 20 05 restore %i0, 5, %o0
sc = rtems_bdbuf_release (buffer);
40020944: 7f ff db f4 call 40017914 <rtems_bdbuf_release>
40020948: 01 00 00 00 nop
rc = EIO;
4002094c: 80 a0 00 08 cmp %g0, %o0
40020950: b0 40 3f ff addx %g0, -1, %i0
40020954: b0 0e 3f fb and %i0, -5, %i0
}
40020958: 81 c7 e0 08 ret
4002095c: 91 ee 20 05 restore %i0, 5, %o0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40020960: 17 10 00 d0 sethi %hi(0x40034000), %o3
<== NOT EXECUTED
40020964: 10 bf ff eb b 40020910 <rtems_rfs_buffer_bdbuf_release+0x30>
<== NOT EXECUTED
40020968: 96 12 e2 30 or %o3, 0x230, %o3 ! 40034230 <CSWTCH.1+0xc>
<== NOT EXECUTED
4001c5c0 <rtems_rfs_buffer_close>:
{
4001c5c0: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c5c4: 90 10 20 00 clr %o0
4001c5c8: 92 10 20 10 mov 0x10, %o1
4001c5cc: 7f ff e2 9a call 40015034 <rtems_rfs_trace>
4001c5d0: ba 10 00 18 mov %i0, %i5
4001c5d4: 80 a2 20 00 cmp %o0, 0
4001c5d8: 12 80 00 2f bne 4001c694 <rtems_rfs_buffer_close+0xd4>
<== NEVER TAKEN
4001c5dc: 11 10 00 cb sethi %hi(0x40032c00), %o0
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
4001c5e0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4001c5e4: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
4001c5e8: 7f ff ff b5 call 4001c4bc <rtems_rfs_buffer_setblksize>
4001c5ec: 90 10 00 1d mov %i5, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c5f0: b0 92 20 00 orcc %o0, 0, %i0
4001c5f4: 14 80 00 1b bg 4001c660 <rtems_rfs_buffer_close+0xa0>
<== NEVER TAKEN
4001c5f8: 90 10 20 00 clr %o0
if (close (fs->device) < 0)
4001c5fc: 7f ff b3 26 call 40009294 <close>
4001c600: d0 07 60 0c ld [ %i5 + 0xc ], %o0
4001c604: 80 a2 20 00 cmp %o0, 0
4001c608: 06 80 00 04 bl 4001c618 <rtems_rfs_buffer_close+0x58>
<== NEVER TAKEN
4001c60c: 01 00 00 00 nop
}
4001c610: 81 c7 e0 08 ret
4001c614: 81 e8 00 00 restore
rc = errno;
4001c618: 40 00 11 94 call 40020c68 <__errno>
<== NOT EXECUTED
4001c61c: 01 00 00 00 nop
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c620: 92 10 20 10 mov 0x10, %o1 ! 10 <_TLS_Alignment+0xf>
<== NOT EXECUTED
rc = errno;
4001c624: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c628: 7f ff e2 83 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c62c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c630: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c634: 02 80 00 09 be 4001c658 <rtems_rfs_buffer_close+0x98>
<== NOT EXECUTED
4001c638: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
4001c63c: 40 00 19 d4 call 40022d8c <strerror>
<== NOT EXECUTED
4001c640: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001c644: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001c648: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c64c: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c650: 7f ff e3 06 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c654: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 40032df8 <status_code_to_errno+0x6b4>
<== NOT EXECUTED
}
4001c658: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c65c: 81 e8 00 00 restore
<== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001c660: 7f ff e2 75 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c664: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
4001c668: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c66c: 02 bf ff e4 be 4001c5fc <rtems_rfs_buffer_close+0x3c>
<== NOT EXECUTED
4001c670: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
4001c674: 40 00 19 c6 call 40022d8c <strerror>
<== NOT EXECUTED
4001c678: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001c67c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001c680: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c684: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c688: 7f ff e2 f8 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c68c: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 40032db8 <status_code_to_errno+0x674>
<== NOT EXECUTED
4001c690: 30 bf ff db b,a 4001c5fc <rtems_rfs_buffer_close+0x3c>
<== NOT EXECUTED
printf ("rtems-rfs: buffer-close: closing\n");
4001c694: 7f ff e3 04 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001c698: 90 12 21 90 or %o0, 0x190, %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
4001c69c: 10 bf ff d2 b 4001c5e4 <rtems_rfs_buffer_close+0x24>
<== NOT EXECUTED
4001c6a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4001beb4 <rtems_rfs_buffer_handle_request>:
{
4001beb4: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_buffer_handle_has_block (handle))
4001beb8: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bebc: 80 a0 60 00 cmp %g1, 0
4001bec0: 02 80 00 1b be 4001bf2c <rtems_rfs_buffer_handle_request+0x78>
4001bec4: ba 10 00 18 mov %i0, %i5
if (block && (rtems_rfs_buffer_bnum (handle) == block))
4001bec8: 80 a6 a0 00 cmp %i2, 0
4001becc: 02 80 00 06 be 4001bee4 <rtems_rfs_buffer_handle_request+0x30>
<== NEVER TAKEN
4001bed0: 90 10 20 00 clr %o0
4001bed4: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001bed8: 80 a0 40 1a cmp %g1, %i2
4001bedc: 02 80 00 7a be 4001c0c4 <rtems_rfs_buffer_handle_request+0x210>
4001bee0: 01 00 00 00 nop
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bee4: 7f ff e4 54 call 40015034 <rtems_rfs_trace>
4001bee8: 92 10 21 00 mov 0x100, %o1 ! 100 <_TLS_Alignment+0xff>
4001beec: 80 a2 20 00 cmp %o0, 0
4001bef0: 32 80 00 4f bne,a 4001c02c <rtems_rfs_buffer_handle_request+0x178>
<== NEVER TAKEN
4001bef4: d2 06 60 04 ld [ %i1 + 4 ], %o1
<== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
4001bef8: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001befc: 80 a0 60 00 cmp %g1, 0
4001bf00: 22 80 00 0a be,a 4001bf28 <rtems_rfs_buffer_handle_request+0x74>
<== NEVER TAKEN
4001bf04: c0 2e 40 00 clrb [ %i1 ]
<== NOT EXECUTED
4001bf08: 92 10 00 19 mov %i1, %o1
4001bf0c: 7f ff ff 5b call 4001bc78 <rtems_rfs_buffer_handle_release.part.2>
4001bf10: 90 10 00 1d mov %i5, %o0
if (rc > 0)
4001bf14: b0 92 20 00 orcc %o0, 0, %i0
4001bf18: 24 80 00 04 ble,a 4001bf28 <rtems_rfs_buffer_handle_request+0x74>
<== ALWAYS TAKEN
4001bf1c: c0 2e 40 00 clrb [ %i1 ]
}
4001bf20: 81 c7 e0 08 ret
<== NOT EXECUTED
4001bf24: 81 e8 00 00 restore
<== NOT EXECUTED
handle->bnum = 0;
4001bf28: c0 26 60 04 clr [ %i1 + 4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bf2c: 90 10 20 00 clr %o0
4001bf30: 7f ff e4 41 call 40015034 <rtems_rfs_trace>
4001bf34: 92 10 21 00 mov 0x100, %o1
4001bf38: 80 a2 20 00 cmp %o0, 0
4001bf3c: 32 80 00 59 bne,a 4001c0a0 <rtems_rfs_buffer_handle_request+0x1ec>
<== NEVER TAKEN
4001bf40: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
if (fs->buffers_count)
4001bf44: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4001bf48: 80 a0 60 00 cmp %g1, 0
4001bf4c: 12 80 00 41 bne 4001c050 <rtems_rfs_buffer_handle_request+0x19c>
4001bf50: 94 10 00 1a mov %i2, %o2
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001bf54: c4 07 40 00 ld [ %i5 ], %g2
4001bf58: 80 88 a0 02 btst 2, %g2
4001bf5c: 12 80 00 26 bne 4001bff4 <rtems_rfs_buffer_handle_request+0x140>
4001bf60: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001bf64: 80 a0 60 00 cmp %g1, 0
4001bf68: 22 80 00 69 be,a 4001c10c <rtems_rfs_buffer_handle_request+0x258>
4001bf6c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
rtems_rfs_buffer_refs_up (handle);
4001bf70: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
old_last = tail->previous;
4001bf74: c6 07 60 4c ld [ %i5 + 0x4c ], %g3
return &the_chain->Tail.Node;
4001bf78: 88 07 60 48 add %i5, 0x48, %g4
4001bf7c: 84 00 a0 01 inc %g2
the_node->next = tail;
4001bf80: c8 20 40 00 st %g4, [ %g1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bf84: 90 10 20 00 clr %o0
rtems_rfs_buffer_refs_up (handle);
4001bf88: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bf8c: 92 10 21 00 mov 0x100, %o1
tail->previous = the_node;
4001bf90: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
old_last->next = the_node;
4001bf94: c2 20 c0 00 st %g1, [ %g3 ]
fs->buffers_count++;
4001bf98: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
the_node->previous = old_last;
4001bf9c: c6 20 60 04 st %g3, [ %g1 + 4 ]
4001bfa0: 84 00 a0 01 inc %g2
4001bfa4: c4 27 60 50 st %g2, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
4001bfa8: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001bfac: 7f ff e4 22 call 40015034 <rtems_rfs_trace>
4001bfb0: f4 26 60 04 st %i2, [ %i1 + 4 ]
4001bfb4: 80 a2 20 00 cmp %o0, 0
4001bfb8: 02 80 00 43 be 4001c0c4 <rtems_rfs_buffer_handle_request+0x210>
<== ALWAYS TAKEN
4001bfbc: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001bfc0: 12 80 00 43 bne 4001c0cc <rtems_rfs_buffer_handle_request+0x218>
<== NOT EXECUTED
4001bfc4: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4001bfc8: d8 00 60 30 ld [ %g1 + 0x30 ], %o4
<== NOT EXECUTED
4001bfcc: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
<== NOT EXECUTED
return 0;
4001bfd0: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001bfd4: 15 10 00 ca sethi %hi(0x40032800), %o2
<== NOT EXECUTED
4001bfd8: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001bfdc: 94 12 a2 08 or %o2, 0x208, %o2
<== NOT EXECUTED
4001bfe0: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001bfe4: 7f ff e4 a1 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001bfe8: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40032ae0 <status_code_to_errno+0x39c>
<== NOT EXECUTED
4001bfec: 81 c7 e0 08 ret
<== NOT EXECUTED
4001bff0: 81 e8 00 00 restore
<== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (handle))
4001bff4: 80 a0 60 00 cmp %g1, 0
4001bff8: 32 bf ff df bne,a 4001bf74 <rtems_rfs_buffer_handle_request+0xc0>
<== NEVER TAKEN
4001bffc: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
<== NOT EXECUTED
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4001c000: 96 06 60 08 add %i1, 8, %o3
4001c004: 94 10 00 1b mov %i3, %o2
4001c008: 92 10 00 1a mov %i2, %o1
4001c00c: 40 00 12 21 call 40020890 <rtems_rfs_buffer_bdbuf_request>
4001c010: 90 10 00 1d mov %i5, %o0
if (rc > 0)
4001c014: b0 92 20 00 orcc %o0, 0, %i0
4001c018: 14 80 00 4f bg 4001c154 <rtems_rfs_buffer_handle_request+0x2a0>
<== NEVER TAKEN
4001c01c: 90 10 20 00 clr %o0
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
4001c020: c2 06 60 08 ld [ %i1 + 8 ], %g1
node->next = NULL;
4001c024: 10 bf ff d3 b 4001bf70 <rtems_rfs_buffer_handle_request+0xbc>
4001c028: c0 20 40 00 clr [ %g1 ]
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
4001c02c: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c030: 7f ff e4 8e call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c034: 90 12 22 10 or %o0, 0x210, %o0 ! 40032a10 <status_code_to_errno+0x2cc>
<== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
4001c038: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4001c03c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001c040: 32 bf ff b3 bne,a 4001bf0c <rtems_rfs_buffer_handle_request+0x58>
<== NOT EXECUTED
4001c044: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001c048: 10 bf ff b8 b 4001bf28 <rtems_rfs_buffer_handle_request+0x74>
<== NOT EXECUTED
4001c04c: c0 2e 40 00 clrb [ %i1 ]
<== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4001c050: 92 07 60 50 add %i5, 0x50, %o1
4001c054: 7f ff fe 9a call 4001babc <rtems_rfs_scan_chain>
4001c058: 90 07 60 44 add %i5, 0x44, %o0
if (rtems_rfs_buffer_handle_has_block (handle) &&
4001c05c: 80 a2 20 00 cmp %o0, 0
4001c060: 02 80 00 26 be 4001c0f8 <rtems_rfs_buffer_handle_request+0x244>
4001c064: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c068: 90 10 20 00 clr %o0
4001c06c: 7f ff e3 f2 call 40015034 <rtems_rfs_trace>
4001c070: 92 10 21 00 mov 0x100, %o1
if (rtems_rfs_buffer_handle_has_block (handle) &&
4001c074: 80 a2 20 00 cmp %o0, 0
4001c078: 22 bf ff b8 be,a 4001bf58 <rtems_rfs_buffer_handle_request+0xa4>
<== ALWAYS TAKEN
4001c07c: c4 07 40 00 ld [ %i5 ], %g2
rtems_rfs_buffer_refs (handle) + 1);
4001c080: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
4001c084: d2 00 60 30 ld [ %g1 + 0x30 ], %o1
<== NOT EXECUTED
4001c088: 92 02 60 01 inc %o1
<== NOT EXECUTED
4001c08c: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c090: 7f ff e4 76 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c094: 90 12 22 70 or %o0, 0x270, %o0 ! 40032a70 <status_code_to_errno+0x32c>
<== NOT EXECUTED
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001c098: 10 bf ff b0 b 4001bf58 <rtems_rfs_buffer_handle_request+0xa4>
<== NOT EXECUTED
4001c09c: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
4001c0a0: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c0a4: 7f ff e4 71 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c0a8: 90 12 22 48 or %o0, 0x248, %o0 ! 40032a48 <status_code_to_errno+0x304>
<== NOT EXECUTED
if (fs->buffers_count)
4001c0ac: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
4001c0b0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001c0b4: 22 bf ff a9 be,a 4001bf58 <rtems_rfs_buffer_handle_request+0xa4>
<== NOT EXECUTED
4001c0b8: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4001c0bc: 10 bf ff e5 b 4001c050 <rtems_rfs_buffer_handle_request+0x19c>
<== NOT EXECUTED
4001c0c0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
return 0;
4001c0c4: 81 c7 e0 08 ret
4001c0c8: 91 e8 20 00 restore %g0, 0, %o0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001c0cc: d8 00 60 30 ld [ %g1 + 0x30 ], %o4
<== NOT EXECUTED
4001c0d0: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
<== NOT EXECUTED
return 0;
4001c0d4: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001c0d8: 15 10 00 ca sethi %hi(0x40032800), %o2
<== NOT EXECUTED
4001c0dc: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001c0e0: 94 12 a2 00 or %o2, 0x200, %o2
<== NOT EXECUTED
4001c0e4: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c0e8: 7f ff e4 60 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c0ec: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40032ae0 <status_code_to_errno+0x39c>
<== NOT EXECUTED
4001c0f0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c0f4: 81 e8 00 00 restore
<== NOT EXECUTED
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001c0f8: c2 07 40 00 ld [ %i5 ], %g1
4001c0fc: 80 88 60 02 btst 2, %g1
4001c100: 12 bf ff c1 bne 4001c004 <rtems_rfs_buffer_handle_request+0x150>
4001c104: 96 06 60 08 add %i1, 8, %o3
if (fs->release_count)
4001c108: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001c10c: 80 a0 60 00 cmp %g1, 0
4001c110: 12 80 00 25 bne 4001c1a4 <rtems_rfs_buffer_handle_request+0x2f0>
4001c114: 94 10 00 1a mov %i2, %o2
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001c118: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001c11c: 80 a0 60 00 cmp %g1, 0
4001c120: 02 bf ff b9 be 4001c004 <rtems_rfs_buffer_handle_request+0x150>
4001c124: 96 06 60 08 add %i1, 8, %o3
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
4001c128: 94 10 00 1a mov %i2, %o2
4001c12c: 92 07 60 70 add %i5, 0x70, %o1
4001c130: 7f ff fe 63 call 4001babc <rtems_rfs_scan_chain>
4001c134: 90 07 60 64 add %i5, 0x64, %o0
4001c138: d0 26 60 08 st %o0, [ %i1 + 8 ]
if (rtems_rfs_buffer_handle_has_block (handle))
4001c13c: 80 a2 20 00 cmp %o0, 0
4001c140: 02 bf ff b0 be 4001c000 <rtems_rfs_buffer_handle_request+0x14c>
4001c144: 82 10 00 08 mov %o0, %g1
rtems_rfs_buffer_mark_dirty (handle);
4001c148: 84 10 20 01 mov 1, %g2
4001c14c: 10 bf ff 89 b 4001bf70 <rtems_rfs_buffer_handle_request+0xbc>
4001c150: c4 2e 40 00 stb %g2, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c154: 7f ff e3 b8 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c158: 92 10 21 00 mov 0x100, %o1
<== NOT EXECUTED
4001c15c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c160: 02 bf ff 70 be 4001bf20 <rtems_rfs_buffer_handle_request+0x6c>
<== NOT EXECUTED
4001c164: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001c168: 12 80 00 18 bne 4001c1c8 <rtems_rfs_buffer_handle_request+0x314>
<== NOT EXECUTED
4001c16c: 3b 10 00 ca sethi %hi(0x40032800), %i5
<== NOT EXECUTED
4001c170: 3b 10 00 ca sethi %hi(0x40032800), %i5
<== NOT EXECUTED
4001c174: ba 17 62 08 or %i5, 0x208, %i5 ! 40032a08 <status_code_to_errno+0x2c4>
<== NOT EXECUTED
4001c178: 40 00 1b 05 call 40022d8c <strerror>
<== NOT EXECUTED
4001c17c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001c180: 96 10 00 18 mov %i0, %o3
<== NOT EXECUTED
4001c184: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001c188: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001c18c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001c190: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c194: 7f ff e4 35 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c198: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 40032aa8 <status_code_to_errno+0x364>
<== NOT EXECUTED
4001c19c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c1a0: 81 e8 00 00 restore
<== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
4001c1a4: 92 07 60 60 add %i5, 0x60, %o1
4001c1a8: 7f ff fe 45 call 4001babc <rtems_rfs_scan_chain>
4001c1ac: 90 07 60 54 add %i5, 0x54, %o0
4001c1b0: d0 26 60 08 st %o0, [ %i1 + 8 ]
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001c1b4: 80 a2 20 00 cmp %o0, 0
4001c1b8: 12 bf ff 6e bne 4001bf70 <rtems_rfs_buffer_handle_request+0xbc>
4001c1bc: 82 10 00 08 mov %o0, %g1
4001c1c0: 10 bf ff d7 b 4001c11c <rtems_rfs_buffer_handle_request+0x268>
4001c1c4: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001c1c8: 10 bf ff ec b 4001c178 <rtems_rfs_buffer_handle_request+0x2c4>
<== NOT EXECUTED
4001c1cc: ba 17 62 00 or %i5, 0x200, %i5
<== NOT EXECUTED
4001c1f4 <rtems_rfs_buffer_open>:
{
4001c1f4: 9d e3 bf 40 save %sp, -192, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001c1f8: 90 10 20 00 clr %o0
4001c1fc: 7f ff e3 8e call 40015034 <rtems_rfs_trace>
4001c200: 92 10 20 20 mov 0x20, %o1
4001c204: 80 a2 20 00 cmp %o0, 0
4001c208: 12 80 00 26 bne 4001c2a0 <rtems_rfs_buffer_open+0xac>
<== NEVER TAKEN
4001c20c: 92 10 00 18 mov %i0, %o1
fs->device = open (name, O_RDWR);
4001c210: 92 10 20 02 mov 2, %o1
4001c214: 7f ff b7 f6 call 4000a1ec <open>
4001c218: 90 10 00 18 mov %i0, %o0
if (fs->device < 0)
4001c21c: 80 a2 20 00 cmp %o0, 0
4001c220: 06 80 00 15 bl 4001c274 <rtems_rfs_buffer_open+0x80>
<== NEVER TAKEN
4001c224: d0 26 60 0c st %o0, [ %i1 + 0xc ]
if (fstat (fs->device, &st) < 0)
4001c228: 7f ff b4 91 call 4000946c <fstat>
4001c22c: 92 07 bf a0 add %fp, -96, %o1
4001c230: 80 a2 20 00 cmp %o0, 0
4001c234: 06 80 00 32 bl 4001c2fc <rtems_rfs_buffer_open+0x108>
<== NEVER TAKEN
4001c238: 05 00 00 3c sethi %hi(0xf000), %g2
if (!S_ISBLK (st.st_mode))
4001c23c: c2 07 bf ac ld [ %fp + -84 ], %g1
4001c240: 82 08 40 02 and %g1, %g2, %g1
4001c244: 05 00 00 18 sethi %hi(0x6000), %g2
4001c248: 80 a0 40 02 cmp %g1, %g2
4001c24c: 22 80 00 1a be,a 4001c2b4 <rtems_rfs_buffer_open+0xc0>
<== ALWAYS TAKEN
4001c250: d0 06 60 0c ld [ %i1 + 0xc ], %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c254: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c258: 7f ff e3 77 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c25c: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4001c260: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c264: 12 80 00 38 bne 4001c344 <rtems_rfs_buffer_open+0x150>
<== NOT EXECUTED
4001c268: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
return ENXIO;
4001c26c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c270: 91 e8 20 06 restore %g0, 6, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c274: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c278: 7f ff e3 6f call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c27c: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4001c280: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c284: 02 bf ff fa be 4001c26c <rtems_rfs_buffer_open+0x78>
<== NOT EXECUTED
4001c288: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
return ENXIO;
4001c28c: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
4001c290: 7f ff e4 05 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001c294: 90 12 23 48 or %o0, 0x348, %o0
<== NOT EXECUTED
4001c298: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c29c: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
4001c2a0: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c2a4: 7f ff e3 f1 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c2a8: 90 12 23 20 or %o0, 0x320, %o0 ! 40032b20 <status_code_to_errno+0x3dc>
<== NOT EXECUTED
fs->device = open (name, O_RDWR);
4001c2ac: 10 bf ff da b 4001c214 <rtems_rfs_buffer_open+0x20>
<== NOT EXECUTED
4001c2b0: 92 10 20 02 mov 2, %o1
<== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4001c2b4: 94 06 60 10 add %i1, 0x10, %o2
4001c2b8: 13 10 01 10 sethi %hi(0x40044000), %o1
4001c2bc: 7f ff b4 df call 40009638 <ioctl>
4001c2c0: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <flashdisk_data+0x5e09>
4001c2c4: b0 10 00 08 mov %o0, %i0
if (rv != 0)
4001c2c8: 80 a6 20 00 cmp %i0, 0
4001c2cc: 02 80 00 24 be 4001c35c <rtems_rfs_buffer_open+0x168>
<== ALWAYS TAKEN
4001c2d0: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c2d4: 7f ff e3 58 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c2d8: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4001c2dc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c2e0: 02 bf ff e3 be 4001c26c <rtems_rfs_buffer_open+0x78>
<== NOT EXECUTED
4001c2e4: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
return ENXIO;
4001c2e8: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
4001c2ec: 7f ff e3 ee call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001c2f0: 90 12 23 e0 or %o0, 0x3e0, %o0
<== NOT EXECUTED
4001c2f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c2f8: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c2fc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c300: 7f ff e3 4d call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c304: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4001c308: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c30c: 02 bf ff d8 be 4001c26c <rtems_rfs_buffer_open+0x78>
<== NOT EXECUTED
4001c310: 01 00 00 00 nop
<== NOT EXECUTED
name, strerror (errno));
4001c314: 40 00 12 55 call 40020c68 <__errno>
<== NOT EXECUTED
4001c318: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
4001c31c: 40 00 1a 9c call 40022d8c <strerror>
<== NOT EXECUTED
4001c320: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4001c324: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001c328: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return ENXIO;
4001c32c: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
4001c330: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
4001c334: 7f ff e3 cd call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c338: 90 12 23 78 or %o0, 0x378, %o0 ! 40032b78 <status_code_to_errno+0x434>
<== NOT EXECUTED
4001c33c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c340: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4001c344: 11 10 00 ca sethi %hi(0x40032800), %o0
<== NOT EXECUTED
return ENXIO;
4001c348: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4001c34c: 7f ff e3 c7 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c350: 90 12 23 a8 or %o0, 0x3a8, %o0
<== NOT EXECUTED
4001c354: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c358: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001c35c: 7f ff e3 36 call 40015034 <rtems_rfs_trace>
4001c360: 92 10 20 20 mov 0x20, %o1
4001c364: 80 a2 20 00 cmp %o0, 0
4001c368: 32 80 00 04 bne,a 4001c378 <rtems_rfs_buffer_open+0x184>
<== NEVER TAKEN
4001c36c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
}
4001c370: 81 c7 e0 08 ret
4001c374: 81 e8 00 00 restore
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
4001c378: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
<== NOT EXECUTED
4001c37c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
<== NOT EXECUTED
4001c380: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c384: 7f ff e3 b9 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c388: 90 12 20 10 or %o0, 0x10, %o0 ! 40032c10 <status_code_to_errno+0x4cc>
<== NOT EXECUTED
}
4001c38c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c390: 81 e8 00 00 restore
<== NOT EXECUTED
4001c4bc <rtems_rfs_buffer_setblksize>:
{
4001c4bc: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c4c0: 90 10 20 00 clr %o0
{
4001c4c4: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c4c8: 7f ff e2 db call 40015034 <rtems_rfs_trace>
4001c4cc: 92 10 24 00 mov 0x400, %o1
4001c4d0: 80 a2 20 00 cmp %o0, 0
4001c4d4: 12 80 00 37 bne 4001c5b0 <rtems_rfs_buffer_setblksize+0xf4>
<== NEVER TAKEN
4001c4d8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
rc = rtems_rfs_buffers_release (fs);
4001c4dc: 7f ff ff d4 call 4001c42c <rtems_rfs_buffers_release>
4001c4e0: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c4e4: ba 92 20 00 orcc %o0, 0, %i5
4001c4e8: 14 80 00 25 bg 4001c57c <rtems_rfs_buffer_setblksize+0xc0>
<== NEVER TAKEN
4001c4ec: 90 10 20 00 clr %o0
rc = rtems_rfs_buffer_sync (fs);
4001c4f0: 7f ff ff a9 call 4001c394 <rtems_rfs_buffer_sync>
4001c4f4: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c4f8: ba 92 20 00 orcc %o0, 0, %i5
4001c4fc: 14 80 00 12 bg 4001c544 <rtems_rfs_buffer_setblksize+0x88>
<== NEVER TAKEN
4001c500: 90 10 20 00 clr %o0
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001c504: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001c508: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4001c50c: 94 07 a0 48 add %fp, 0x48, %o2
4001c510: 13 20 01 10 sethi %hi(0x80044000), %o1
4001c514: 9f c0 40 00 call %g1
4001c518: 92 12 62 04 or %o1, 0x204, %o1 ! 80044204 <RAM_END+0x3fc44204>
if (rc < 0)
4001c51c: b0 92 20 00 orcc %o0, 0, %i0
4001c520: 06 80 00 04 bl 4001c530 <rtems_rfs_buffer_setblksize+0x74>
<== NEVER TAKEN
4001c524: 01 00 00 00 nop
}
4001c528: 81 c7 e0 08 ret
4001c52c: 81 e8 00 00 restore
rc = errno;
4001c530: 40 00 11 ce call 40020c68 <__errno>
<== NOT EXECUTED
4001c534: 01 00 00 00 nop
<== NOT EXECUTED
4001c538: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
}
4001c53c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c540: 81 e8 00 00 restore
<== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c544: 7f ff e2 bc call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c548: 92 10 24 00 mov 0x400, %o1
<== NOT EXECUTED
4001c54c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c550: 22 bf ff ee be,a 4001c508 <rtems_rfs_buffer_setblksize+0x4c>
<== NOT EXECUTED
4001c554: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
4001c558: 40 00 1a 0d call 40022d8c <strerror>
<== NOT EXECUTED
4001c55c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c560: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c564: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c568: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c56c: 7f ff e3 3f call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c570: 90 12 21 50 or %o0, 0x150, %o0 ! 40032d50 <status_code_to_errno+0x60c>
<== NOT EXECUTED
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001c574: 10 bf ff e5 b 4001c508 <rtems_rfs_buffer_setblksize+0x4c>
<== NOT EXECUTED
4001c578: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
<== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001c57c: 7f ff e2 ae call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c580: 92 10 24 00 mov 0x400, %o1
<== NOT EXECUTED
4001c584: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c588: 02 bf ff da be 4001c4f0 <rtems_rfs_buffer_setblksize+0x34>
<== NOT EXECUTED
4001c58c: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
4001c590: 40 00 19 ff call 40022d8c <strerror>
<== NOT EXECUTED
4001c594: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c598: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c59c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c5a0: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c5a4: 7f ff e3 31 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c5a8: 90 12 21 10 or %o0, 0x110, %o0 ! 40032d10 <status_code_to_errno+0x5cc>
<== NOT EXECUTED
4001c5ac: 30 bf ff d1 b,a 4001c4f0 <rtems_rfs_buffer_setblksize+0x34>
<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size);
4001c5b0: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c5b4: 7f ff e3 2d call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c5b8: 90 12 20 e0 or %o0, 0xe0, %o0 ! 40032ce0 <status_code_to_errno+0x59c>
<== NOT EXECUTED
4001c5bc: 30 bf ff c8 b,a 4001c4dc <rtems_rfs_buffer_setblksize+0x20>
<== NOT EXECUTED
4001c394 <rtems_rfs_buffer_sync>:
{
4001c394: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001c398: 90 10 20 00 clr %o0
4001c39c: 92 10 20 20 mov 0x20, %o1
4001c3a0: 7f ff e3 25 call 40015034 <rtems_rfs_trace>
4001c3a4: ba 10 00 18 mov %i0, %i5
4001c3a8: 80 a2 20 00 cmp %o0, 0
4001c3ac: 12 80 00 1d bne 4001c420 <rtems_rfs_buffer_sync+0x8c>
<== NEVER TAKEN
4001c3b0: 11 10 00 cb sethi %hi(0x40032c00), %o0
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
4001c3b4: 7f ff ed c0 call 40017ab4 <rtems_bdbuf_syncdev>
4001c3b8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
int result = 0;
4001c3bc: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001c3c0: 80 a2 20 00 cmp %o0, 0
4001c3c4: 12 80 00 06 bne 4001c3dc <rtems_rfs_buffer_sync+0x48>
<== NEVER TAKEN
4001c3c8: b8 10 00 08 mov %o0, %i4
rtems_disk_release (fs->disk);
4001c3cc: 7f ff a0 e8 call 4000476c <rtems_disk_release>
4001c3d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
}
4001c3d4: 81 c7 e0 08 ret
4001c3d8: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001c3dc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c3e0: 92 10 20 20 mov 0x20, %o1
<== NOT EXECUTED
4001c3e4: 7f ff e3 14 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c3e8: b0 10 20 05 mov 5, %i0
<== NOT EXECUTED
4001c3ec: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c3f0: 02 bf ff f7 be 4001c3cc <rtems_rfs_buffer_sync+0x38>
<== NOT EXECUTED
4001c3f4: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
4001c3f8: 40 00 11 12 call 40020840 <rtems_status_text>
<== NOT EXECUTED
4001c3fc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4001c400: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4001c404: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c408: 7f ff e3 98 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c40c: 90 12 20 60 or %o0, 0x60, %o0 ! 40032c60 <status_code_to_errno+0x51c>
<== NOT EXECUTED
rtems_disk_release (fs->disk);
4001c410: 7f ff a0 d7 call 4000476c <rtems_disk_release>
<== NOT EXECUTED
4001c414: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
<== NOT EXECUTED
}
4001c418: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c41c: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: syncing\n");
4001c420: 7f ff e3 a1 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001c424: 90 12 20 40 or %o0, 0x40, %o0
<== NOT EXECUTED
4001c428: 30 bf ff e3 b,a 4001c3b4 <rtems_rfs_buffer_sync+0x20>
<== NOT EXECUTED
4001c42c <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
4001c42c: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4001c430: 90 10 20 00 clr %o0
4001c434: 92 10 20 40 mov 0x40, %o1
4001c438: 7f ff e2 ff call 40015034 <rtems_rfs_trace>
4001c43c: ba 10 00 18 mov %i0, %i5
4001c440: 80 a2 20 00 cmp %o0, 0
4001c444: 32 80 00 17 bne,a 4001c4a0 <rtems_rfs_buffers_release+0x74>
<== NEVER TAKEN
4001c448: 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,
4001c44c: 94 10 20 00 clr %o2
4001c450: 92 07 60 60 add %i5, 0x60, %o1
4001c454: 7f ff fd e1 call 4001bbd8 <rtems_rfs_release_chain>
4001c458: 90 07 60 54 add %i5, 0x54, %o0
4001c45c: 92 07 60 70 add %i5, 0x70, %o1
4001c460: b0 10 00 08 mov %o0, %i0
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
4001c464: 94 10 20 01 mov 1, %o2
if ((rc > 0) && (rrc == 0))
4001c468: 80 a6 20 00 cmp %i0, 0
4001c46c: 04 80 00 06 ble 4001c484 <rtems_rfs_buffers_release+0x58>
<== ALWAYS TAKEN
4001c470: 90 07 60 64 add %i5, 0x64, %o0
rc = rtems_rfs_release_chain (&fs->release_modified,
4001c474: 7f ff fd d9 call 4001bbd8 <rtems_rfs_release_chain>
<== NOT EXECUTED
4001c478: 01 00 00 00 nop
<== NOT EXECUTED
true);
if ((rc > 0) && (rrc == 0))
rrc = rc;
return rrc;
}
4001c47c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c480: 81 e8 00 00 restore
<== NOT EXECUTED
rc = rtems_rfs_release_chain (&fs->release_modified,
4001c484: 7f ff fd d5 call 4001bbd8 <rtems_rfs_release_chain>
4001c488: 01 00 00 00 nop
4001c48c: 82 38 00 08 xnor %g0, %o0, %g1
4001c490: 83 38 60 1f sra %g1, 0x1f, %g1
4001c494: b0 0a 00 01 and %o0, %g1, %i0
4001c498: 81 c7 e0 08 ret
4001c49c: 81 e8 00 00 restore
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
4001c4a0: d4 06 20 60 ld [ %i0 + 0x60 ], %o2
<== NOT EXECUTED
4001c4a4: d2 06 20 50 ld [ %i0 + 0x50 ], %o1
<== NOT EXECUTED
4001c4a8: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c4ac: 7f ff e3 6f call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c4b0: 90 12 20 90 or %o0, 0x90, %o0 ! 40032c90 <status_code_to_errno+0x54c>
<== NOT EXECUTED
rc = rtems_rfs_release_chain (&fs->release,
4001c4b4: 10 bf ff e7 b 4001c450 <rtems_rfs_buffers_release+0x24>
<== NOT EXECUTED
4001c4b8: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001cbe4 <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)
{
4001cbe4: 9d e3 bf 30 save %sp, -208, %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))
4001cbe8: 90 10 20 00 clr %o0
4001cbec: 7f ff e1 12 call 40015034 <rtems_rfs_trace>
4001cbf0: 13 08 00 00 sethi %hi(0x20000000), %o1
4001cbf4: 80 a2 20 00 cmp %o0, 0
4001cbf8: 12 80 00 3e bne 4001ccf0 <rtems_rfs_dir_add_entry+0x10c>
<== NEVER TAKEN
4001cbfc: 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);
4001cc00: 94 07 bf b0 add %fp, -80, %o2
4001cc04: 7f ff f8 92 call 4001ae4c <rtems_rfs_block_map_open>
4001cc08: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001cc0c: a0 92 20 00 orcc %o0, 0, %l0
4001cc10: 24 80 00 04 ble,a 4001cc20 <rtems_rfs_dir_add_entry+0x3c>
<== ALWAYS TAKEN
4001cc14: c0 2f bf a4 clrb [ %fp + -92 ]
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001cc18: 81 c7 e0 08 ret
4001cc1c: 91 e8 00 10 restore %g0, %l0, %o0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001cc20: 27 00 00 3f sethi %hi(0xfc00), %l3
handle->bnum = 0;
4001cc24: c0 27 bf a8 clr [ %fp + -88 ]
4001cc28: a6 14 e3 ff or %l3, 0x3ff, %l3
handle->buffer = NULL;
4001cc2c: c0 27 bf ac clr [ %fp + -84 ]
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001cc30: a4 06 e0 0a add %i3, 0xa, %l2
bpos->bno = 0;
4001cc34: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
4001cc38: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
4001cc3c: c0 27 bf a0 clr [ %fp + -96 ]
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
4001cc40: 96 07 bf 94 add %fp, -108, %o3
4001cc44: 94 07 bf 98 add %fp, -104, %o2
4001cc48: 92 07 bf b0 add %fp, -80, %o1
4001cc4c: 7f ff f9 52 call 4001b194 <rtems_rfs_block_map_find>
4001cc50: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001cc54: a0 92 20 00 orcc %o0, 0, %l0
4001cc58: 04 80 00 88 ble 4001ce78 <rtems_rfs_dir_add_entry+0x294>
4001cc5c: 80 a4 20 06 cmp %l0, 6
if (rc != ENXIO)
4001cc60: 12 80 00 d9 bne 4001cfc4 <rtems_rfs_dir_add_entry+0x3e0>
<== NEVER TAKEN
4001cc64: 96 07 bf 94 add %fp, -108, %o3
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001cc68: 94 10 20 01 mov 1, %o2
4001cc6c: 92 07 bf b0 add %fp, -80, %o1
4001cc70: 7f ff f9 cd call 4001b3a4 <rtems_rfs_block_map_grow>
4001cc74: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001cc78: a0 92 20 00 orcc %o0, 0, %l0
4001cc7c: 14 80 00 c1 bg 4001cf80 <rtems_rfs_dir_add_entry+0x39c>
<== NEVER TAKEN
4001cc80: c2 07 bf 98 ld [ %fp + -104 ], %g1
bpos.bno++;
4001cc84: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001cc88: d4 07 bf 94 ld [ %fp + -108 ], %o2
4001cc8c: 96 10 20 00 clr %o3
bpos.bno++;
4001cc90: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001cc94: 92 07 bf a4 add %fp, -92, %o1
4001cc98: 7f ff fc 87 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001cc9c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001cca0: a0 92 20 00 orcc %o0, 0, %l0
4001cca4: 04 80 00 27 ble 4001cd40 <rtems_rfs_dir_add_entry+0x15c>
<== ALWAYS TAKEN
4001cca8: c2 07 bf ac ld [ %fp + -84 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001ccac: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ccb0: 7f ff e0 e1 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ccb4: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001ccb8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ccbc: 32 80 00 a7 bne,a 4001cf58 <rtems_rfs_dir_add_entry+0x374>
<== NOT EXECUTED
4001ccc0: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001ccc4: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001ccc8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001cccc: 7f ff fd 41 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001ccd0: 01 00 00 00 nop
rtems_rfs_block_map_close (fs, &map);
4001ccd4: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001ccd8: c0 2f bf a4 clrb [ %fp + -92 ]
4001ccdc: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001cce0: c0 27 bf a8 clr [ %fp + -88 ]
4001cce4: 7f ff f8 b9 call 4001afc8 <rtems_rfs_block_map_close>
4001cce8: c0 27 bf ac clr [ %fp + -84 ]
return rc;
4001ccec: 30 bf ff cb b,a 4001cc18 <rtems_rfs_dir_add_entry+0x34>
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
4001ccf0: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001ccf4: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001ccf8: 7f ff e1 5c call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ccfc: 90 12 21 00 or %o0, 0x100, %o0 ! 40033100 <status_code_to_errno+0x9bc>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001cd00: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4001cd04: 02 80 00 09 be 4001cd28 <rtems_rfs_dir_add_entry+0x144>
<== NOT EXECUTED
4001cd08: a0 06 c0 1a add %i3, %i2, %l0
<== NOT EXECUTED
4001cd0c: ba 10 00 1a mov %i2, %i5
<== NOT EXECUTED
printf ("%c", name[c]);
4001cd10: 7f ff e1 6b call 400152bc <__wrap_putchar>
<== NOT EXECUTED
4001cd14: d0 4f 40 00 ldsb [ %i5 ], %o0
<== NOT EXECUTED
4001cd18: ba 07 60 01 inc %i5
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001cd1c: 80 a4 00 1d cmp %l0, %i5
<== NOT EXECUTED
4001cd20: 12 bf ff fc bne 4001cd10 <rtems_rfs_dir_add_entry+0x12c>
<== NOT EXECUTED
4001cd24: 01 00 00 00 nop
<== NOT EXECUTED
printf (", len=%zd\n", length);
4001cd28: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001cd2c: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cd30: 7f ff e1 4e call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cd34: 90 12 21 30 or %o0, 0x130, %o0 ! 40033130 <status_code_to_errno+0x9ec>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001cd38: 10 bf ff b2 b 4001cc00 <rtems_rfs_dir_add_entry+0x1c>
<== NOT EXECUTED
4001cd3c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
entry = rtems_rfs_buffer_data (&buffer);
4001cd40: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
4001cd44: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001cd48: 92 10 20 ff mov 0xff, %o1
4001cd4c: 40 00 13 6a call 40021af4 <memset>
4001cd50: 90 10 00 1d mov %i5, %o0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001cd54: c8 06 20 08 ld [ %i0 + 8 ], %g4
4001cd58: 86 81 3f f6 addcc %g4, -10, %g3
4001cd5c: 02 bf ff ba be 4001cc44 <rtems_rfs_dir_add_entry+0x60>
<== NEVER TAKEN
4001cd60: 96 07 bf 94 add %fp, -108, %o3
elength = rtems_rfs_dir_entry_length (entry);
4001cd64: d4 0f 60 08 ldub [ %i5 + 8 ], %o2
4001cd68: e0 0f 60 09 ldub [ %i5 + 9 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001cd6c: c4 0f 40 00 ldub [ %i5 ], %g2
4001cd70: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001cd74: e2 0f 60 02 ldub [ %i5 + 2 ], %l1
4001cd78: d6 0f 60 03 ldub [ %i5 + 3 ], %o3
elength = rtems_rfs_dir_entry_length (entry);
4001cd7c: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001cd80: 85 28 a0 18 sll %g2, 0x18, %g2
elength = rtems_rfs_dir_entry_length (entry);
4001cd84: a0 14 00 0a or %l0, %o2, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001cd88: 83 28 60 10 sll %g1, 0x10, %g1
4001cd8c: a3 2c 60 08 sll %l1, 8, %l1
4001cd90: 82 10 40 02 or %g1, %g2, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001cd94: 80 a4 00 13 cmp %l0, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001cd98: a2 14 40 01 or %l1, %g1, %l1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001cd9c: 02 80 00 4d be 4001ced0 <rtems_rfs_dir_add_entry+0x2ec>
4001cda0: a2 12 c0 11 or %o3, %l1, %l1
offset = 0;
4001cda4: 10 80 00 1f b 4001ce20 <rtems_rfs_dir_add_entry+0x23c>
4001cda8: a8 10 20 00 clr %l4
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001cdac: 80 a0 40 10 cmp %g1, %l0
4001cdb0: 08 80 00 1f bleu 4001ce2c <rtems_rfs_dir_add_entry+0x248>
<== NEVER TAKEN
4001cdb4: 80 a4 60 00 cmp %l1, 0
4001cdb8: 02 80 00 1e be 4001ce30 <rtems_rfs_dir_add_entry+0x24c>
<== NEVER TAKEN
4001cdbc: 90 10 20 00 clr %o0
4001cdc0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001cdc4: 80 a0 40 11 cmp %g1, %l1
4001cdc8: 0a 80 00 1a bcs 4001ce30 <rtems_rfs_dir_add_entry+0x24c>
<== NEVER TAKEN
4001cdcc: 01 00 00 00 nop
offset += elength;
4001cdd0: a8 05 00 10 add %l4, %l0, %l4
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001cdd4: 80 a0 c0 14 cmp %g3, %l4
4001cdd8: 08 bf ff 9a bleu 4001cc40 <rtems_rfs_dir_add_entry+0x5c>
<== NEVER TAKEN
4001cddc: ba 07 40 10 add %i5, %l0, %i5
elength = rtems_rfs_dir_entry_length (entry);
4001cde0: d4 0f 60 08 ldub [ %i5 + 8 ], %o2
4001cde4: e0 0f 60 09 ldub [ %i5 + 9 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001cde8: c4 0f 40 00 ldub [ %i5 ], %g2
4001cdec: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001cdf0: d6 0f 60 02 ldub [ %i5 + 2 ], %o3
4001cdf4: e2 0f 60 03 ldub [ %i5 + 3 ], %l1
elength = rtems_rfs_dir_entry_length (entry);
4001cdf8: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001cdfc: 85 28 a0 18 sll %g2, 0x18, %g2
elength = rtems_rfs_dir_entry_length (entry);
4001ce00: a0 14 00 0a or %l0, %o2, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001ce04: 83 28 60 10 sll %g1, 0x10, %g1
4001ce08: 97 2a e0 08 sll %o3, 8, %o3
4001ce0c: 82 10 40 02 or %g1, %g2, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001ce10: 80 a4 00 13 cmp %l0, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001ce14: 96 12 c0 01 or %o3, %g1, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001ce18: 02 80 00 2d be 4001cecc <rtems_rfs_dir_add_entry+0x2e8>
4001ce1c: a2 14 40 0b or %l1, %o3, %l1
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001ce20: 80 a4 20 0a cmp %l0, 0xa
4001ce24: 34 bf ff e2 bg,a 4001cdac <rtems_rfs_dir_add_entry+0x1c8>
<== ALWAYS TAKEN
4001ce28: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001ce2c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ce30: 7f ff e0 81 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ce34: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001ce38: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ce3c: 32 80 00 1c bne,a 4001ceac <rtems_rfs_dir_add_entry+0x2c8>
<== NOT EXECUTED
4001ce40: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001ce44: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001ce48: 7f ff fc e2 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001ce4c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001ce50: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001ce54: c0 2f bf a4 clrb [ %fp + -92 ]
<== NOT EXECUTED
4001ce58: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001ce5c: c0 27 bf a8 clr [ %fp + -88 ]
<== NOT EXECUTED
return EIO;
4001ce60: a0 10 20 05 mov 5, %l0
<== NOT EXECUTED
handle->buffer = NULL;
4001ce64: c0 27 bf ac clr [ %fp + -84 ]
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001ce68: 7f ff f8 58 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001ce6c: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
}
4001ce70: 81 c7 e0 08 ret
<== NOT EXECUTED
4001ce74: 81 e8 00 00 restore
<== NOT EXECUTED
bpos.bno++;
4001ce78: c2 07 bf 98 ld [ %fp + -104 ], %g1
4001ce7c: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001ce80: d4 07 bf 94 ld [ %fp + -108 ], %o2
4001ce84: 96 10 20 01 mov 1, %o3
bpos.bno++;
4001ce88: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001ce8c: 92 07 bf a4 add %fp, -92, %o1
4001ce90: 7f ff fc 09 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001ce94: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001ce98: a0 92 20 00 orcc %o0, 0, %l0
4001ce9c: 14 bf ff 84 bg 4001ccac <rtems_rfs_dir_add_entry+0xc8>
<== NEVER TAKEN
4001cea0: c2 07 bf ac ld [ %fp + -84 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
4001cea4: 10 bf ff ac b 4001cd54 <rtems_rfs_dir_add_entry+0x170>
4001cea8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
printf ("rtems-rfs: dir-add-entry: "
4001ceac: 98 10 00 14 mov %l4, %o4
<== NOT EXECUTED
4001ceb0: 96 10 00 11 mov %l1, %o3
<== NOT EXECUTED
4001ceb4: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001ceb8: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cebc: 7f ff e0 eb call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cec0: 90 12 22 18 or %o0, 0x218, %o0 ! 40033218 <status_code_to_errno+0xad4>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001cec4: 10 bf ff e1 b 4001ce48 <rtems_rfs_dir_add_entry+0x264>
<== NOT EXECUTED
4001cec8: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001cecc: 88 21 00 14 sub %g4, %l4, %g4
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001ced0: 80 a4 80 04 cmp %l2, %g4
4001ced4: 1a bf ff 5c bcc 4001cc44 <rtems_rfs_dir_add_entry+0x60>
<== NEVER TAKEN
4001ced8: 96 07 bf 94 add %fp, -108, %o3
hash = rtems_rfs_dir_hash (name, length);
4001cedc: 92 10 00 1b mov %i3, %o1
4001cee0: 40 00 0e b0 call 400209a0 <rtems_rfs_dir_hash>
4001cee4: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
4001cee8: 87 32 20 18 srl %o0, 0x18, %g3
4001ceec: 85 32 20 10 srl %o0, 0x10, %g2
4001cef0: 83 32 20 08 srl %o0, 8, %g1
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cef4: 89 37 20 18 srl %i4, 0x18, %g4
rtems_rfs_dir_set_entry_hash (entry, hash);
4001cef8: c6 2f 60 04 stb %g3, [ %i5 + 4 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cefc: 87 37 20 10 srl %i4, 0x10, %g3
rtems_rfs_dir_set_entry_hash (entry, hash);
4001cf00: c4 2f 60 05 stb %g2, [ %i5 + 5 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cf04: 85 37 20 08 srl %i4, 8, %g2
rtems_rfs_dir_set_entry_hash (entry, hash);
4001cf08: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_length (entry,
4001cf0c: 83 2c a0 10 sll %l2, 0x10, %g1
rtems_rfs_dir_set_entry_hash (entry, hash);
4001cf10: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_length (entry,
4001cf14: 83 30 60 18 srl %g1, 0x18, %g1
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cf18: c8 2f 40 00 stb %g4, [ %i5 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001cf1c: 92 10 00 1a mov %i2, %o1
rtems_rfs_dir_set_entry_length (entry,
4001cf20: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001cf24: 94 10 00 1b mov %i3, %o2
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cf28: c6 2f 60 01 stb %g3, [ %i5 + 1 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001cf2c: 90 07 60 0a add %i5, 0xa, %o0
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cf30: c4 2f 60 02 stb %g2, [ %i5 + 2 ]
return 0;
4001cf34: a0 10 20 00 clr %l0
rtems_rfs_dir_set_entry_ino (entry, ino);
4001cf38: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001cf3c: 40 00 12 64 call 400218cc <memcpy>
4001cf40: e4 2f 60 09 stb %l2, [ %i5 + 9 ]
rtems_rfs_buffer_mark_dirty (&buffer);
4001cf44: 82 10 20 01 mov 1, %g1
4001cf48: 92 07 bf a4 add %fp, -92, %o1
4001cf4c: 90 10 00 18 mov %i0, %o0
4001cf50: 10 bf ff 5f b 4001cccc <rtems_rfs_dir_add_entry+0xe8>
4001cf54: c2 2f bf a4 stb %g1, [ %fp + -92 ]
printf ("rtems-rfs: dir-add-entry: "
4001cf58: 40 00 17 8d call 40022d8c <strerror>
<== NOT EXECUTED
4001cf5c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4001cf60: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001cf64: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001cf68: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cf6c: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cf70: 7f ff e0 be call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cf74: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400331d0 <status_code_to_errno+0xa8c>
<== NOT EXECUTED
4001cf78: 10 bf ff 54 b 4001ccc8 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001cf7c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001cf80: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001cf84: 7f ff e0 2c call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001cf88: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001cf8c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cf90: 22 bf ff 4e be,a 4001ccc8 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001cf94: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001cf98: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001cf9c: 40 00 17 7c call 40022d8c <strerror>
<== NOT EXECUTED
4001cfa0: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4001cfa4: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001cfa8: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001cfac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cfb0: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cfb4: 7f ff e0 ad call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cfb8: 90 12 21 88 or %o0, 0x188, %o0 ! 40033188 <status_code_to_errno+0xa44>
<== NOT EXECUTED
4001cfbc: 10 bf ff 43 b 4001ccc8 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001cfc0: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001cfc4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001cfc8: 7f ff e0 1b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001cfcc: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001cfd0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cfd4: 22 bf ff 3d be,a 4001ccc8 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001cfd8: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001cfdc: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001cfe0: 40 00 17 6b call 40022d8c <strerror>
<== NOT EXECUTED
4001cfe4: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4001cfe8: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001cfec: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001cff0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cff4: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cff8: 7f ff e0 9c call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cffc: 90 12 21 40 or %o0, 0x140, %o0 ! 40033140 <status_code_to_errno+0x9fc>
<== NOT EXECUTED
4001d000: 10 bf ff 32 b 4001ccc8 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001d004: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001d008 <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)
{
4001d008: 9d e3 bf 40 save %sp, -192, %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))
4001d00c: 90 10 20 00 clr %o0
4001d010: 7f ff e0 09 call 40015034 <rtems_rfs_trace>
4001d014: 13 10 00 00 sethi %hi(0x40000000), %o1
4001d018: 80 a2 20 00 cmp %o0, 0
4001d01c: 12 80 00 0a bne 4001d044 <rtems_rfs_dir_del_entry+0x3c>
<== NEVER TAKEN
4001d020: 92 10 00 19 mov %i1, %o1
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);
4001d024: 94 07 bf b0 add %fp, -80, %o2
4001d028: 7f ff f7 89 call 4001ae4c <rtems_rfs_block_map_open>
4001d02c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d030: a4 92 20 00 orcc %o0, 0, %l2
4001d034: 04 80 00 11 ble 4001d078 <rtems_rfs_dir_del_entry+0x70>
<== ALWAYS TAKEN
4001d038: 94 10 20 00 clr %o2
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001d03c: 81 c7 e0 08 ret
4001d040: 91 e8 00 12 restore %g0, %l2, %o0
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
4001d044: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001d048: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4001d04c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001d050: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001d054: 7f ff e0 85 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d058: 90 12 22 60 or %o0, 0x260, %o0 ! 40033260 <status_code_to_errno+0xb1c>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d05c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001d060: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001d064: 7f ff f7 7a call 4001ae4c <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001d068: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d06c: a4 92 20 00 orcc %o0, 0, %l2
<== NOT EXECUTED
4001d070: 14 bf ff f3 bg 4001d03c <rtems_rfs_dir_del_entry+0x34>
<== NOT EXECUTED
4001d074: 94 10 20 00 clr %o2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001d078: 98 07 bf a0 add %fp, -96, %o4
4001d07c: 96 10 00 1b mov %i3, %o3
4001d080: 92 07 bf b0 add %fp, -80, %o1
4001d084: 7f ff f8 9d call 4001b2f8 <rtems_rfs_block_map_seek>
4001d088: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d08c: a4 92 20 00 orcc %o0, 0, %l2
4001d090: 04 80 00 0a ble 4001d0b8 <rtems_rfs_dir_del_entry+0xb0>
<== ALWAYS TAKEN
4001d094: 80 a4 a0 06 cmp %l2, 6
if (rc == ENXIO)
4001d098: 22 80 00 02 be,a 4001d0a0 <rtems_rfs_dir_del_entry+0x98>
<== NOT EXECUTED
4001d09c: a4 10 20 02 mov 2, %l2
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001d0a0: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d0a4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001d0a8: 7f ff f7 c8 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d0ac: b0 10 00 12 mov %l2, %i0
<== NOT EXECUTED
}
4001d0b0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001d0b4: 81 e8 00 00 restore
<== NOT EXECUTED
handle->dirty = false;
4001d0b8: c0 2f bf a4 clrb [ %fp + -92 ]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d0bc: 27 00 00 3f sethi %hi(0xfc00), %l3
handle->bnum = 0;
4001d0c0: c0 27 bf a8 clr [ %fp + -88 ]
4001d0c4: a6 14 e3 ff or %l3, 0x3ff, %l3
handle->buffer = NULL;
4001d0c8: c0 27 bf ac clr [ %fp + -84 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001d0cc: 96 10 20 01 mov 1, %o3
4001d0d0: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001d0d4: 92 07 bf a4 add %fp, -92, %o1
4001d0d8: 7f ff fb 77 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001d0dc: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d0e0: a4 92 20 00 orcc %o0, 0, %l2
4001d0e4: 14 80 00 c5 bg 4001d3f8 <rtems_rfs_dir_del_entry+0x3f0>
<== NEVER TAKEN
4001d0e8: 80 a6 e0 00 cmp %i3, 0
if (search)
4001d0ec: 02 80 00 46 be 4001d204 <rtems_rfs_dir_del_entry+0x1fc>
<== NEVER TAKEN
4001d0f0: c8 06 20 08 ld [ %i0 + 8 ], %g4
eoffset = offset % rtems_rfs_fs_block_size (fs);
4001d0f4: 81 80 20 00 wr %g0, %y
4001d0f8: 01 00 00 00 nop
4001d0fc: 01 00 00 00 nop
4001d100: 01 00 00 00 nop
4001d104: 82 76 c0 04 udiv %i3, %g4, %g1
4001d108: 82 58 40 04 smul %g1, %g4, %g1
4001d10c: 82 26 c0 01 sub %i3, %g1, %g1
4001d110: a2 10 00 01 mov %g1, %l1
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001d114: c4 07 bf ac ld [ %fp + -84 ], %g2
4001d118: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d11c: 9e 01 3f f6 add %g4, -10, %o7
4001d120: 80 a3 c0 01 cmp %o7, %g1
4001d124: 08 80 00 2b bleu 4001d1d0 <rtems_rfs_dir_del_entry+0x1c8>
<== NEVER TAKEN
4001d128: ba 00 80 01 add %g2, %g1, %i5
elength = rtems_rfs_dir_entry_length (entry);
4001d12c: c6 0f 60 08 ldub [ %i5 + 8 ], %g3
4001d130: f8 0f 60 09 ldub [ %i5 + 9 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001d134: 10 80 00 1a b 4001d19c <rtems_rfs_dir_del_entry+0x194>
4001d138: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d13c: 80 a7 20 0a cmp %i4, 0xa
4001d140: 04 80 00 34 ble 4001d210 <rtems_rfs_dir_del_entry+0x208>
<== NEVER TAKEN
4001d144: 90 10 20 00 clr %o0
4001d148: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001d14c: 80 a0 40 1c cmp %g1, %i4
4001d150: 08 80 00 30 bleu 4001d210 <rtems_rfs_dir_del_entry+0x208>
<== NEVER TAKEN
4001d154: 80 a4 20 00 cmp %l0, 0
4001d158: 02 80 00 2f be 4001d214 <rtems_rfs_dir_del_entry+0x20c>
<== NEVER TAKEN
4001d15c: 13 10 00 00 sethi %hi(0x40000000), %o1
4001d160: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001d164: 80 a0 40 10 cmp %g1, %l0
4001d168: 0a 80 00 2a bcs 4001d210 <rtems_rfs_dir_del_entry+0x208>
<== NEVER TAKEN
4001d16c: 80 a6 80 10 cmp %i2, %l0
if (ino == rtems_rfs_dir_entry_ino (entry))
4001d170: 02 80 00 43 be 4001d27c <rtems_rfs_dir_del_entry+0x274>
<== ALWAYS TAKEN
4001d174: 80 a6 e0 00 cmp %i3, 0
if (!search)
4001d178: 32 80 00 19 bne,a 4001d1dc <rtems_rfs_dir_del_entry+0x1d4>
<== NOT EXECUTED
4001d17c: a4 10 20 05 mov 5, %l2
<== NOT EXECUTED
eoffset += elength;
4001d180: a2 04 40 1c add %l1, %i4, %l1
<== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d184: 80 a4 40 0f cmp %l1, %o7
<== NOT EXECUTED
4001d188: 1a 80 00 12 bcc 4001d1d0 <rtems_rfs_dir_del_entry+0x1c8>
<== NOT EXECUTED
4001d18c: ba 07 40 1c add %i5, %i4, %i5
<== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
4001d190: c6 0f 60 08 ldub [ %i5 + 8 ], %g3
<== NOT EXECUTED
4001d194: f8 0f 60 09 ldub [ %i5 + 9 ], %i4
<== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001d198: c4 0f 40 00 ldub [ %i5 ], %g2
<== NOT EXECUTED
4001d19c: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001d1a0: d6 0f 60 02 ldub [ %i5 + 2 ], %o3
4001d1a4: e0 0f 60 03 ldub [ %i5 + 3 ], %l0
elength = rtems_rfs_dir_entry_length (entry);
4001d1a8: 87 28 e0 08 sll %g3, 8, %g3
eino = rtems_rfs_dir_entry_ino (entry);
4001d1ac: 85 28 a0 18 sll %g2, 0x18, %g2
elength = rtems_rfs_dir_entry_length (entry);
4001d1b0: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001d1b4: 83 28 60 10 sll %g1, 0x10, %g1
4001d1b8: 97 2a e0 08 sll %o3, 8, %o3
4001d1bc: 82 10 40 02 or %g1, %g2, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d1c0: 80 a7 00 13 cmp %i4, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001d1c4: 96 12 c0 01 or %o3, %g1, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d1c8: 12 bf ff dd bne 4001d13c <rtems_rfs_dir_del_entry+0x134>
<== ALWAYS TAKEN
4001d1cc: a0 14 00 0b or %l0, %o3, %l0
if (rc == 0)
4001d1d0: 80 a4 a0 00 cmp %l2, 0
<== NOT EXECUTED
4001d1d4: 02 80 00 1f be 4001d250 <rtems_rfs_dir_del_entry+0x248>
<== NOT EXECUTED
4001d1d8: 94 07 bf a0 add %fp, -96, %o2
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d1dc: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001d1e0: 7f ff fb fc call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001d1e4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001d1e8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001d1ec: c0 2f bf a4 clrb [ %fp + -92 ]
<== NOT EXECUTED
4001d1f0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001d1f4: c0 27 bf a8 clr [ %fp + -88 ]
<== NOT EXECUTED
4001d1f8: 7f ff f7 74 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d1fc: c0 27 bf ac clr [ %fp + -84 ]
<== NOT EXECUTED
return rc;
4001d200: 30 bf ff 8f b,a 4001d03c <rtems_rfs_dir_del_entry+0x34>
<== NOT EXECUTED
4001d204: 82 10 20 00 clr %g1
<== NOT EXECUTED
eoffset = 0;
4001d208: 10 bf ff c3 b 4001d114 <rtems_rfs_dir_del_entry+0x10c>
<== NOT EXECUTED
4001d20c: a2 10 20 00 clr %l1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001d210: 13 10 00 00 sethi %hi(0x40000000), %o1
<== NOT EXECUTED
4001d214: 7f ff df 88 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001d218: a4 10 20 05 mov 5, %l2
<== NOT EXECUTED
4001d21c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d220: 22 bf ff f0 be,a 4001d1e0 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001d224: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001d228: d8 07 bf a0 ld [ %fp + -96 ], %o4
<== NOT EXECUTED
4001d22c: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001d230: 9a 10 00 11 mov %l1, %o5
<== NOT EXECUTED
4001d234: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
4001d238: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001d23c: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001d240: 7f ff e0 0a call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d244: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 400332e8 <status_code_to_errno+0xba4>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d248: 10 bf ff e6 b 4001d1e0 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001d24c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d250: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d254: 7f ff f8 47 call 4001b370 <rtems_rfs_block_map_next_block>
<== NOT EXECUTED
4001d258: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc == ENXIO)
4001d25c: 80 a2 20 06 cmp %o0, 6
<== NOT EXECUTED
4001d260: 02 80 00 77 be 4001d43c <rtems_rfs_dir_del_entry+0x434>
<== NOT EXECUTED
4001d264: a4 10 00 08 mov %o0, %l2
<== NOT EXECUTED
while (rc == 0)
4001d268: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d26c: 02 bf ff 99 be 4001d0d0 <rtems_rfs_dir_del_entry+0xc8>
<== NOT EXECUTED
4001d270: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001d274: 10 bf ff db b 4001d1e0 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001d278: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
memmove (entry, entry + elength, remaining);
4001d27c: 92 07 40 1c add %i5, %i4, %o1
4001d280: 90 10 00 1d mov %i5, %o0
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001d284: b6 04 40 1c add %l1, %i4, %i3
4001d288: b6 21 00 1b sub %g4, %i3, %i3
memmove (entry, entry + elength, remaining);
4001d28c: 40 00 11 cc call 400219bc <memmove>
4001d290: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
4001d294: 94 10 00 1c mov %i4, %o2
4001d298: 92 10 20 ff mov 0xff, %o1
4001d29c: 40 00 12 16 call 40021af4 <memset>
4001d2a0: 90 07 40 1b add %i5, %i3, %o0
elength = rtems_rfs_dir_entry_length (entry);
4001d2a4: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
4001d2a8: 83 28 60 08 sll %g1, 8, %g1
4001d2ac: fa 0f 60 09 ldub [ %i5 + 9 ], %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001d2b0: 90 10 20 00 clr %o0
4001d2b4: 13 10 00 00 sethi %hi(0x40000000), %o1
4001d2b8: 7f ff df 5f call 40015034 <rtems_rfs_trace>
4001d2bc: ba 17 40 01 or %i5, %g1, %i5
4001d2c0: 80 a2 20 00 cmp %o0, 0
4001d2c4: 22 80 00 17 be,a 4001d320 <rtems_rfs_dir_del_entry+0x318>
<== ALWAYS TAKEN
4001d2c8: 03 3f ff c0 sethi %hi(0xffff0000), %g1
rtems_rfs_block_map_last (&map) ? "yes" : "no");
4001d2cc: c4 07 bf c0 ld [ %fp + -64 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001d2d0: d6 07 bf a0 ld [ %fp + -96 ], %o3
<== NOT EXECUTED
4001d2d4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001d2d8: 12 80 00 05 bne 4001d2ec <rtems_rfs_dir_del_entry+0x2e4>
<== NOT EXECUTED
4001d2dc: c2 07 bf b8 ld [ %fp + -72 ], %g1
<== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
4001d2e0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001d2e4: 02 80 00 3d be 4001d3d8 <rtems_rfs_dir_del_entry+0x3d0>
<== NOT EXECUTED
4001d2e8: 1b 10 00 c8 sethi %hi(0x40032000), %o5
<== NOT EXECUTED
4001d2ec: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001d2f0: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001d2f4: 02 80 00 39 be 4001d3d8 <rtems_rfs_dir_del_entry+0x3d0>
<== NOT EXECUTED
4001d2f8: 1b 10 00 c8 sethi %hi(0x40032000), %o5
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001d2fc: 1b 10 00 c2 sethi %hi(0x40030800), %o5
<== NOT EXECUTED
4001d300: 9a 13 60 d8 or %o5, 0xd8, %o5 ! 400308d8 <__func__.8600+0x1c0>
<== NOT EXECUTED
4001d304: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001d308: 98 10 00 11 mov %l1, %o4
<== NOT EXECUTED
4001d30c: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001d310: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001d314: 7f ff df d5 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d318: 90 12 23 38 or %o0, 0x338, %o0
<== NOT EXECUTED
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
4001d31c: 03 3f ff c0 sethi %hi(0xffff0000), %g1
<== NOT EXECUTED
4001d320: ba 38 40 1d xnor %g1, %i5, %i5
4001d324: 80 a7 60 00 cmp %i5, 0
4001d328: 12 80 00 1f bne 4001d3a4 <rtems_rfs_dir_del_entry+0x39c>
4001d32c: 80 a4 60 00 cmp %l1, 0
4001d330: 12 80 00 1d bne 4001d3a4 <rtems_rfs_dir_del_entry+0x39c>
<== ALWAYS TAKEN
4001d334: c4 07 bf c0 ld [ %fp + -64 ], %g2
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001d338: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001d33c: 12 80 00 29 bne 4001d3e0 <rtems_rfs_dir_del_entry+0x3d8>
<== NOT EXECUTED
4001d340: c2 07 bf b8 ld [ %fp + -72 ], %g1
<== NOT EXECUTED
4001d344: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001d348: 12 80 00 27 bne 4001d3e4 <rtems_rfs_dir_del_entry+0x3dc>
<== NOT EXECUTED
4001d34c: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001d350: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4001d354: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d358: 7f ff f9 10 call 4001b798 <rtems_rfs_block_map_shrink>
<== NOT EXECUTED
4001d35c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d360: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001d364: 04 80 00 10 ble 4001d3a4 <rtems_rfs_dir_del_entry+0x39c>
<== NOT EXECUTED
4001d368: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001d36c: 7f ff df 32 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001d370: 13 10 00 00 sethi %hi(0x40000000), %o1
<== NOT EXECUTED
4001d374: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d378: 02 80 00 0c be 4001d3a8 <rtems_rfs_dir_del_entry+0x3a0>
<== NOT EXECUTED
4001d37c: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001d380: f8 06 60 08 ld [ %i1 + 8 ], %i4
<== NOT EXECUTED
4001d384: 40 00 16 82 call 40022d8c <strerror>
<== NOT EXECUTED
4001d388: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001d38c: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001d390: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001d394: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001d398: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001d39c: 7f ff df b3 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d3a0: 90 12 23 98 or %o0, 0x398, %o0 ! 40033398 <status_code_to_errno+0xc54>
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
4001d3a4: 82 10 20 01 mov 1, %g1
4001d3a8: 92 07 bf a4 add %fp, -92, %o1
4001d3ac: 90 10 00 18 mov %i0, %o0
4001d3b0: 7f ff fb 88 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001d3b4: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_block_map_close (fs, &map);
4001d3b8: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001d3bc: c0 2f bf a4 clrb [ %fp + -92 ]
4001d3c0: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001d3c4: c0 27 bf a8 clr [ %fp + -88 ]
return 0;
4001d3c8: a4 10 20 00 clr %l2
rtems_rfs_block_map_close (fs, &map);
4001d3cc: 7f ff f6 ff call 4001afc8 <rtems_rfs_block_map_close>
4001d3d0: c0 27 bf ac clr [ %fp + -84 ]
return 0;
4001d3d4: 30 bf ff 1a b,a 4001d03c <rtems_rfs_dir_del_entry+0x34>
printf ("rtems-rfs: dir-del-entry: "
4001d3d8: 10 bf ff cb b 4001d304 <rtems_rfs_dir_del_entry+0x2fc>
<== NOT EXECUTED
4001d3dc: 9a 13 62 70 or %o5, 0x270, %o5
<== NOT EXECUTED
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001d3e0: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001d3e4: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001d3e8: 12 bf ff f0 bne 4001d3a8 <rtems_rfs_dir_del_entry+0x3a0>
<== NOT EXECUTED
4001d3ec: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001d3f0: 10 bf ff d9 b 4001d354 <rtems_rfs_dir_del_entry+0x34c>
<== NOT EXECUTED
4001d3f4: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001d3f8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001d3fc: 7f ff df 0e call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001d400: 13 10 00 00 sethi %hi(0x40000000), %o1
<== NOT EXECUTED
4001d404: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d408: 22 bf ff 76 be,a 4001d1e0 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001d40c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001d410: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001d414: 40 00 16 5e call 40022d8c <strerror>
<== NOT EXECUTED
4001d418: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
4001d41c: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001d420: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001d424: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001d428: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001d42c: 7f ff df 8f call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d430: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 400332a0 <status_code_to_errno+0xb5c>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d434: 10 bf ff 6b b 4001d1e0 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001d438: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = ENOENT;
4001d43c: 10 bf ff 68 b 4001d1dc <rtems_rfs_dir_del_entry+0x1d4>
<== NOT EXECUTED
4001d440: a4 10 20 02 mov 2, %l2
<== NOT EXECUTED
4001d804 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
4001d804: 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))
4001d808: 90 10 20 00 clr %o0
4001d80c: 7f ff de 0a call 40015034 <rtems_rfs_trace>
4001d810: 13 20 00 00 sethi %hi(0x80000000), %o1
4001d814: 80 a2 20 00 cmp %o0, 0
4001d818: 12 80 00 0a bne 4001d840 <rtems_rfs_dir_empty+0x3c>
<== NEVER TAKEN
4001d81c: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d820: 94 07 bf b0 add %fp, -80, %o2
4001d824: 7f ff f5 8a call 4001ae4c <rtems_rfs_block_map_open>
4001d828: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d82c: a4 92 20 00 orcc %o0, 0, %l2
4001d830: 04 80 00 0f ble 4001d86c <rtems_rfs_dir_empty+0x68>
<== ALWAYS TAKEN
4001d834: 94 10 20 00 clr %o2
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001d838: 81 c7 e0 08 ret
<== NOT EXECUTED
4001d83c: 91 e8 00 12 restore %g0, %l2, %o0
<== NOT EXECUTED
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
4001d840: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001d844: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001d848: 7f ff de 88 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d84c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400334c8 <status_code_to_errno+0xd84>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d850: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001d854: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001d858: 7f ff f5 7d call 4001ae4c <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001d85c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d860: a4 92 20 00 orcc %o0, 0, %l2
<== NOT EXECUTED
4001d864: 14 bf ff f5 bg 4001d838 <rtems_rfs_dir_empty+0x34>
<== NOT EXECUTED
4001d868: 94 10 20 00 clr %o2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001d86c: 96 10 20 00 clr %o3
4001d870: 98 07 bf a0 add %fp, -96, %o4
4001d874: 92 07 bf b0 add %fp, -80, %o1
4001d878: 7f ff f6 a0 call 4001b2f8 <rtems_rfs_block_map_seek>
4001d87c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d880: a4 92 20 00 orcc %o0, 0, %l2
4001d884: 14 80 00 67 bg 4001da20 <rtems_rfs_dir_empty+0x21c>
<== NEVER TAKEN
4001d888: 23 00 00 3f sethi %hi(0xfc00), %l1
handle->dirty = false;
4001d88c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001d890: c0 27 bf a8 clr [ %fp + -88 ]
printf ("rtems-rfs: dir-empty: "
4001d894: 21 10 00 cd sethi %hi(0x40033400), %l0
handle->buffer = NULL;
4001d898: c0 27 bf ac clr [ %fp + -84 ]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d89c: a2 14 63 ff or %l1, 0x3ff, %l1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001d8a0: b4 10 20 01 mov 1, %i2
4001d8a4: b6 10 20 00 clr %i3
printf ("rtems-rfs: dir-empty: "
4001d8a8: a0 14 20 e8 or %l0, 0xe8, %l0
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001d8ac: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001d8b0: 96 10 20 01 mov 1, %o3
4001d8b4: 92 07 bf a4 add %fp, -92, %o1
4001d8b8: 7f ff f9 7f call 4001beb4 <rtems_rfs_buffer_handle_request>
4001d8bc: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d8c0: a4 92 20 00 orcc %o0, 0, %l2
4001d8c4: 14 80 00 4b bg 4001d9f0 <rtems_rfs_dir_empty+0x1ec>
<== NEVER TAKEN
4001d8c8: c2 07 bf ac ld [ %fp + -84 ], %g1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d8cc: c8 06 20 08 ld [ %i0 + 8 ], %g4
4001d8d0: 88 81 3f f6 addcc %g4, -10, %g4
4001d8d4: 02 80 00 63 be 4001da60 <rtems_rfs_dir_empty+0x25c>
<== NEVER TAKEN
4001d8d8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
elength = rtems_rfs_dir_entry_length (entry);
4001d8dc: d4 08 60 08 ldub [ %g1 + 8 ], %o2
4001d8e0: fa 08 60 09 ldub [ %g1 + 9 ], %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001d8e4: c6 08 40 00 ldub [ %g1 ], %g3
4001d8e8: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001d8ec: f8 08 60 02 ldub [ %g1 + 2 ], %i4
4001d8f0: d6 08 60 03 ldub [ %g1 + 3 ], %o3
elength = rtems_rfs_dir_entry_length (entry);
4001d8f4: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001d8f8: 87 28 e0 18 sll %g3, 0x18, %g3
elength = rtems_rfs_dir_entry_length (entry);
4001d8fc: ba 17 40 0a or %i5, %o2, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001d900: 85 28 a0 10 sll %g2, 0x10, %g2
4001d904: b9 2f 20 08 sll %i4, 8, %i4
4001d908: 84 10 80 03 or %g2, %g3, %g2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d90c: 80 a7 40 11 cmp %i5, %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001d910: b8 17 00 02 or %i4, %g2, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d914: 02 80 00 53 be 4001da60 <rtems_rfs_dir_empty+0x25c>
<== NEVER TAKEN
4001d918: b8 12 c0 1c or %o3, %i4, %i4
offset = 0;
4001d91c: 10 80 00 20 b 4001d99c <rtems_rfs_dir_empty+0x198>
4001d920: a6 10 20 00 clr %l3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
4001d924: 12 80 00 31 bne 4001d9e8 <rtems_rfs_dir_empty+0x1e4>
4001d928: 80 a4 a0 00 cmp %l2, 0
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
4001d92c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001d930: 80 a0 a0 2e cmp %g2, 0x2e
4001d934: 12 80 00 2d bne 4001d9e8 <rtems_rfs_dir_empty+0x1e4>
<== NEVER TAKEN
4001d938: 80 a4 a0 00 cmp %l2, 0
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001d93c: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
4001d940: 80 a0 a0 2e cmp %g2, 0x2e
4001d944: 12 80 00 29 bne 4001d9e8 <rtems_rfs_dir_empty+0x1e4>
<== NEVER TAKEN
4001d948: 80 a4 a0 00 cmp %l2, 0
offset += elength;
4001d94c: a6 04 c0 1d add %l3, %i5, %l3
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d950: 80 a4 c0 04 cmp %l3, %g4
4001d954: 1a 80 00 43 bcc 4001da60 <rtems_rfs_dir_empty+0x25c>
<== NEVER TAKEN
4001d958: 82 00 40 1d add %g1, %i5, %g1
elength = rtems_rfs_dir_entry_length (entry);
4001d95c: d4 08 60 08 ldub [ %g1 + 8 ], %o2
4001d960: fa 08 60 09 ldub [ %g1 + 9 ], %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001d964: c6 08 40 00 ldub [ %g1 ], %g3
4001d968: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001d96c: d6 08 60 02 ldub [ %g1 + 2 ], %o3
4001d970: f8 08 60 03 ldub [ %g1 + 3 ], %i4
elength = rtems_rfs_dir_entry_length (entry);
4001d974: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001d978: 87 28 e0 18 sll %g3, 0x18, %g3
elength = rtems_rfs_dir_entry_length (entry);
4001d97c: ba 17 40 0a or %i5, %o2, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001d980: 85 28 a0 10 sll %g2, 0x10, %g2
4001d984: 97 2a e0 08 sll %o3, 8, %o3
4001d988: 84 10 80 03 or %g2, %g3, %g2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d98c: 80 a7 40 11 cmp %i5, %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001d990: 96 12 c0 02 or %o3, %g2, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d994: 02 80 00 33 be 4001da60 <rtems_rfs_dir_empty+0x25c>
4001d998: b8 17 00 0b or %i4, %o3, %i4
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d99c: 80 a7 60 0a cmp %i5, 0xa
4001d9a0: 04 80 00 26 ble 4001da38 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001d9a4: 90 10 00 1a mov %i2, %o0
4001d9a8: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4001d9ac: 80 a0 80 1d cmp %g2, %i5
4001d9b0: 08 80 00 22 bleu 4001da38 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001d9b4: 80 a7 20 00 cmp %i4, 0
4001d9b8: 02 80 00 20 be 4001da38 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001d9bc: 01 00 00 00 nop
4001d9c0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4001d9c4: 80 a0 80 1c cmp %g2, %i4
4001d9c8: 0a 80 00 1c bcs 4001da38 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001d9cc: 80 a7 60 0b cmp %i5, 0xb
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
4001d9d0: 12 bf ff d5 bne 4001d924 <rtems_rfs_dir_empty+0x120>
4001d9d4: 80 a7 60 0c cmp %i5, 0xc
4001d9d8: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001d9dc: 80 a0 a0 2e cmp %g2, 0x2e
4001d9e0: 02 bf ff db be 4001d94c <rtems_rfs_dir_empty+0x148>
<== ALWAYS TAKEN
4001d9e4: 80 a4 a0 00 cmp %l2, 0
if ((rc == 0) && !empty)
4001d9e8: 22 80 00 02 be,a 4001d9f0 <rtems_rfs_dir_empty+0x1ec>
<== ALWAYS TAKEN
4001d9ec: a4 10 20 5a mov 0x5a, %l2
rtems_rfs_buffer_handle_release (fs, handle);
4001d9f0: 92 07 bf a4 add %fp, -92, %o1
4001d9f4: 7f ff f9 f7 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001d9f8: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001d9fc: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001da00: c0 2f bf a4 clrb [ %fp + -92 ]
4001da04: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001da08: c0 27 bf a8 clr [ %fp + -88 ]
}
4001da0c: b0 10 00 12 mov %l2, %i0
rtems_rfs_block_map_close (fs, &map);
4001da10: 7f ff f5 6e call 4001afc8 <rtems_rfs_block_map_close>
4001da14: c0 27 bf ac clr [ %fp + -84 ]
}
4001da18: 81 c7 e0 08 ret
4001da1c: 81 e8 00 00 restore
rtems_rfs_block_map_close (fs, &map);
4001da20: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001da24: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001da28: 7f ff f5 68 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001da2c: b0 10 00 12 mov %l2, %i0
<== NOT EXECUTED
}
4001da30: 81 c7 e0 08 ret
<== NOT EXECUTED
4001da34: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001da38: 7f ff dd 7f call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001da3c: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001da40: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001da44: 02 80 00 07 be 4001da60 <rtems_rfs_dir_empty+0x25c>
<== NOT EXECUTED
4001da48: 98 10 00 13 mov %l3, %o4
<== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
4001da4c: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001da50: 96 10 00 1c mov %i4, %o3
<== NOT EXECUTED
4001da54: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001da58: 7f ff de 04 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001da5c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001da60: 94 07 bf a0 add %fp, -96, %o2
4001da64: 92 07 bf b0 add %fp, -80, %o1
4001da68: 7f ff f6 42 call 4001b370 <rtems_rfs_block_map_next_block>
4001da6c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001da70: a4 92 20 00 orcc %o0, 0, %l2
4001da74: 04 bf ff 8f ble 4001d8b0 <rtems_rfs_dir_empty+0xac>
<== NEVER TAKEN
4001da78: d4 07 bf a0 ld [ %fp + -96 ], %o2
rc = 0;
4001da7c: 82 1c a0 06 xor %l2, 6, %g1
4001da80: 80 a0 00 01 cmp %g0, %g1
4001da84: 82 60 20 00 subx %g0, 0, %g1
4001da88: 10 bf ff da b 4001d9f0 <rtems_rfs_dir_empty+0x1ec>
4001da8c: a4 0c 80 01 and %l2, %g1, %l2
400209a0 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
400209a0: 9d e3 bf a0 save %sp, -96, %sp
400209a4: 82 10 00 18 mov %i0, %g1
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
400209a8: 31 37 f7 c5 sethi %hi(0xdfdf1400), %i0
400209ac: b0 16 22 9f or %i0, 0x29f, %i0 ! dfdf169f <RAM_END+0x9f9f169f>
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
400209b0: 80 a6 60 0c cmp %i1, 0xc
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
400209b4: b6 06 40 18 add %i1, %i0, %i3
400209b8: b0 10 00 1b mov %i3, %i0
while (length > 12)
400209bc: 08 80 00 4b bleu 40020ae8 <rtems_rfs_dir_hash+0x148>
<== ALWAYS TAKEN
400209c0: b8 10 00 1b mov %i3, %i4
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
400209c4: fa 08 60 05 ldub [ %g1 + 5 ], %i5
<== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
400209c8: c4 08 60 06 ldub [ %g1 + 6 ], %g2
<== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
400209cc: d6 08 60 0a ldub [ %g1 + 0xa ], %o3
<== NOT EXECUTED
b += ((uint32_t)k[5])<<8;
400209d0: bb 2f 60 08 sll %i5, 8, %i5
<== NOT EXECUTED
c += ((uint32_t)k[9])<<8;
400209d4: c6 08 60 09 ldub [ %g1 + 9 ], %g3
<== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
400209d8: d8 08 60 0b ldub [ %g1 + 0xb ], %o4
<== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
400209dc: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
400209e0: 84 07 40 02 add %i5, %g2, %g2
<== NOT EXECUTED
c += ((uint32_t)k[10])<<16;
400209e4: bb 2a e0 10 sll %o3, 0x10, %i5
<== NOT EXECUTED
c += k[8];
400209e8: d2 08 60 08 ldub [ %g1 + 8 ], %o1
<== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
400209ec: de 08 60 02 ldub [ %g1 + 2 ], %o7
<== NOT EXECUTED
c += ((uint32_t)k[9])<<8;
400209f0: 87 28 e0 08 sll %g3, 8, %g3
<== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
400209f4: 86 00 c0 1d add %g3, %i5, %g3
<== NOT EXECUTED
400209f8: bb 2b 20 18 sll %o4, 0x18, %i5
<== NOT EXECUTED
a += ((uint32_t)k[1])<<8;
400209fc: c8 08 60 01 ldub [ %g1 + 1 ], %g4
<== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
40020a00: f4 08 60 03 ldub [ %g1 + 3 ], %i2
<== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
40020a04: 86 00 c0 09 add %g3, %o1, %g3
<== NOT EXECUTED
40020a08: 86 00 c0 1d add %g3, %i5, %g3
<== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
40020a0c: bb 2b e0 10 sll %o7, 0x10, %i5
<== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
40020a10: b0 00 c0 18 add %g3, %i0, %i0
<== NOT EXECUTED
a += k[0];
40020a14: da 08 40 00 ldub [ %g1 ], %o5
<== NOT EXECUTED
a += ((uint32_t)k[1])<<8;
40020a18: 89 29 20 08 sll %g4, 8, %g4
<== NOT EXECUTED
mix(a,b,c);
40020a1c: 86 01 00 1d add %g4, %i5, %g3
<== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
40020a20: bb 2e a0 18 sll %i2, 0x18, %i5
<== NOT EXECUTED
b += k[4];
40020a24: d0 08 60 04 ldub [ %g1 + 4 ], %o0
<== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
40020a28: d4 08 60 07 ldub [ %g1 + 7 ], %o2
<== NOT EXECUTED
mix(a,b,c);
40020a2c: 89 2e 20 04 sll %i0, 4, %g4
<== NOT EXECUTED
40020a30: 86 00 c0 0d add %g3, %o5, %g3
<== NOT EXECUTED
40020a34: 86 00 c0 1d add %g3, %i5, %g3
<== NOT EXECUTED
40020a38: bb 36 20 1c srl %i0, 0x1c, %i5
<== NOT EXECUTED
40020a3c: 88 11 00 1d or %g4, %i5, %g4
<== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
40020a40: 95 2a a0 18 sll %o2, 0x18, %o2
<== NOT EXECUTED
40020a44: 84 00 80 08 add %g2, %o0, %g2
<== NOT EXECUTED
40020a48: 84 00 80 0a add %g2, %o2, %g2
<== NOT EXECUTED
40020a4c: 84 00 80 1c add %g2, %i4, %g2
<== NOT EXECUTED
mix(a,b,c);
40020a50: b8 06 00 02 add %i0, %g2, %i4
<== NOT EXECUTED
40020a54: b0 20 c0 18 sub %g3, %i0, %i0
<== NOT EXECUTED
40020a58: b0 06 00 1b add %i0, %i3, %i0
<== NOT EXECUTED
40020a5c: b0 19 00 18 xor %g4, %i0, %i0
<== NOT EXECUTED
40020a60: b6 06 00 1c add %i0, %i4, %i3
<== NOT EXECUTED
40020a64: 89 2e 20 06 sll %i0, 6, %g4
<== NOT EXECUTED
40020a68: 84 20 80 18 sub %g2, %i0, %g2
<== NOT EXECUTED
40020a6c: b1 36 20 1a srl %i0, 0x1a, %i0
<== NOT EXECUTED
40020a70: b0 11 00 18 or %g4, %i0, %i0
<== NOT EXECUTED
40020a74: 84 1e 00 02 xor %i0, %g2, %g2
<== NOT EXECUTED
40020a78: ba 00 80 1b add %g2, %i3, %i5
<== NOT EXECUTED
40020a7c: b8 27 00 02 sub %i4, %g2, %i4
<== NOT EXECUTED
40020a80: 87 28 a0 08 sll %g2, 8, %g3
<== NOT EXECUTED
40020a84: 85 30 a0 18 srl %g2, 0x18, %g2
<== NOT EXECUTED
40020a88: 86 10 c0 02 or %g3, %g2, %g3
<== NOT EXECUTED
40020a8c: 86 18 c0 1c xor %g3, %i4, %g3
<== NOT EXECUTED
40020a90: 88 00 c0 1d add %g3, %i5, %g4
<== NOT EXECUTED
40020a94: b6 26 c0 03 sub %i3, %g3, %i3
<== NOT EXECUTED
40020a98: b1 28 e0 10 sll %g3, 0x10, %i0
<== NOT EXECUTED
40020a9c: 87 30 e0 10 srl %g3, 0x10, %g3
<== NOT EXECUTED
40020aa0: 86 16 00 03 or %i0, %g3, %g3
<== NOT EXECUTED
40020aa4: b0 18 c0 1b xor %g3, %i3, %i0
<== NOT EXECUTED
40020aa8: 87 2e 20 13 sll %i0, 0x13, %g3
<== NOT EXECUTED
40020aac: b6 06 00 04 add %i0, %g4, %i3
<== NOT EXECUTED
40020ab0: ba 27 40 18 sub %i5, %i0, %i5
<== NOT EXECUTED
40020ab4: 85 36 20 0d srl %i0, 0xd, %g2
<== NOT EXECUTED
length -= 12;
40020ab8: b2 06 7f f4 add %i1, -12, %i1
<== NOT EXECUTED
mix(a,b,c);
40020abc: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
k += 12;
40020ac0: 82 00 60 0c add %g1, 0xc, %g1
<== NOT EXECUTED
mix(a,b,c);
40020ac4: 84 18 80 1d xor %g2, %i5, %g2
<== NOT EXECUTED
while (length > 12)
40020ac8: 80 a6 60 0c cmp %i1, 0xc
<== NOT EXECUTED
mix(a,b,c);
40020acc: 88 21 00 02 sub %g4, %g2, %g4
<== NOT EXECUTED
40020ad0: b1 28 a0 04 sll %g2, 4, %i0
<== NOT EXECUTED
40020ad4: 87 30 a0 1c srl %g2, 0x1c, %g3
<== NOT EXECUTED
40020ad8: b8 00 80 1b add %g2, %i3, %i4
<== NOT EXECUTED
40020adc: b0 16 00 03 or %i0, %g3, %i0
<== NOT EXECUTED
while (length > 12)
40020ae0: 18 bf ff b9 bgu 400209c4 <rtems_rfs_dir_hash+0x24>
<== NOT EXECUTED
40020ae4: b0 1e 00 04 xor %i0, %g4, %i0
<== NOT EXECUTED
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
40020ae8: b3 2e 60 02 sll %i1, 2, %i1
40020aec: 05 10 00 82 sethi %hi(0x40020800), %g2
40020af0: 84 10 a1 6c or %g2, 0x16c, %g2 ! 4002096c <rtems_rfs_buffer_bdbuf_release+0x8c>
40020af4: c4 00 80 19 ld [ %g2 + %i1 ], %g2
40020af8: 81 c0 80 00 jmp %g2
40020afc: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
40020b00: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
<== NOT EXECUTED
40020b04: 85 28 a0 18 sll %g2, 0x18, %g2
<== NOT EXECUTED
40020b08: b0 06 00 02 add %i0, %g2, %i0
<== NOT EXECUTED
case 11: c+=((uint32_t)k[10])<<16;
40020b0c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
<== NOT EXECUTED
40020b10: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
40020b14: b0 06 00 02 add %i0, %g2, %i0
<== NOT EXECUTED
case 10: c+=((uint32_t)k[9])<<8;
40020b18: c4 08 60 09 ldub [ %g1 + 9 ], %g2
40020b1c: 85 28 a0 08 sll %g2, 8, %g2
40020b20: b0 06 00 02 add %i0, %g2, %i0
case 9 : c+=k[8];
40020b24: c4 08 60 08 ldub [ %g1 + 8 ], %g2
40020b28: b0 06 00 02 add %i0, %g2, %i0
case 8 : b+=((uint32_t)k[7])<<24;
40020b2c: c4 08 60 07 ldub [ %g1 + 7 ], %g2
40020b30: 85 28 a0 18 sll %g2, 0x18, %g2
40020b34: b8 07 00 02 add %i4, %g2, %i4
case 7 : b+=((uint32_t)k[6])<<16;
40020b38: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40020b3c: 85 28 a0 10 sll %g2, 0x10, %g2
40020b40: b8 07 00 02 add %i4, %g2, %i4
case 6 : b+=((uint32_t)k[5])<<8;
40020b44: c4 08 60 05 ldub [ %g1 + 5 ], %g2
40020b48: 85 28 a0 08 sll %g2, 8, %g2
40020b4c: b8 07 00 02 add %i4, %g2, %i4
case 5 : b+=k[4];
40020b50: c4 08 60 04 ldub [ %g1 + 4 ], %g2
40020b54: b8 07 00 02 add %i4, %g2, %i4
case 4 : a+=((uint32_t)k[3])<<24;
40020b58: c4 08 60 03 ldub [ %g1 + 3 ], %g2
40020b5c: 85 28 a0 18 sll %g2, 0x18, %g2
40020b60: b6 06 c0 02 add %i3, %g2, %i3
case 3 : a+=((uint32_t)k[2])<<16;
40020b64: c4 08 60 02 ldub [ %g1 + 2 ], %g2
40020b68: 85 28 a0 10 sll %g2, 0x10, %g2
40020b6c: b6 06 c0 02 add %i3, %g2, %i3
case 2 : a+=((uint32_t)k[1])<<8;
40020b70: c4 08 60 01 ldub [ %g1 + 1 ], %g2
40020b74: 85 28 a0 08 sll %g2, 8, %g2
40020b78: b6 06 c0 02 add %i3, %g2, %i3
case 1 : a+=k[0];
40020b7c: c2 08 40 00 ldub [ %g1 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
40020b80: 85 37 20 12 srl %i4, 0x12, %g2
case 1 : a+=k[0];
40020b84: b6 00 40 1b add %g1, %i3, %i3
final(a,b,c);
40020b88: 83 2f 20 0e sll %i4, 0xe, %g1
40020b8c: 82 10 40 02 or %g1, %g2, %g1
40020b90: b0 1f 00 18 xor %i4, %i0, %i0
40020b94: b0 26 00 01 sub %i0, %g1, %i0
40020b98: 85 36 20 15 srl %i0, 0x15, %g2
40020b9c: 83 2e 20 0b sll %i0, 0xb, %g1
40020ba0: 82 10 40 02 or %g1, %g2, %g1
40020ba4: b6 1e c0 18 xor %i3, %i0, %i3
40020ba8: b6 26 c0 01 sub %i3, %g1, %i3
40020bac: 83 2e e0 19 sll %i3, 0x19, %g1
40020bb0: 84 1f 00 1b xor %i4, %i3, %g2
40020bb4: b9 36 e0 07 srl %i3, 7, %i4
40020bb8: b8 17 00 01 or %i4, %g1, %i4
40020bbc: 84 20 80 1c sub %g2, %i4, %g2
40020bc0: 87 30 a0 10 srl %g2, 0x10, %g3
40020bc4: 83 28 a0 10 sll %g2, 0x10, %g1
40020bc8: 82 10 40 03 or %g1, %g3, %g1
40020bcc: b0 1e 00 02 xor %i0, %g2, %i0
40020bd0: b0 26 00 01 sub %i0, %g1, %i0
40020bd4: 83 2e 20 04 sll %i0, 4, %g1
40020bd8: 87 36 20 1c srl %i0, 0x1c, %g3
40020bdc: 82 10 40 03 or %g1, %g3, %g1
40020be0: b6 1e 00 1b xor %i0, %i3, %i3
40020be4: b6 26 c0 01 sub %i3, %g1, %i3
40020be8: 83 2e e0 0e sll %i3, 0xe, %g1
40020bec: 84 1e c0 02 xor %i3, %g2, %g2
40020bf0: b7 36 e0 12 srl %i3, 0x12, %i3
40020bf4: b6 10 40 1b or %g1, %i3, %i3
40020bf8: 84 20 80 1b sub %g2, %i3, %g2
40020bfc: b0 18 80 18 xor %g2, %i0, %i0
40020c00: 83 30 a0 08 srl %g2, 8, %g1
40020c04: 85 28 a0 18 sll %g2, 0x18, %g2
40020c08: 84 10 40 02 or %g1, %g2, %g2
40020c0c: b0 26 00 02 sub %i0, %g2, %i0
return c;
}
40020c10: 81 c7 e0 08 ret
40020c14: 81 e8 00 00 restore
4001c6a4 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
4001c6a4: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c6a8: 90 10 20 00 clr %o0
4001c6ac: 7f ff e2 62 call 40015034 <rtems_rfs_trace>
4001c6b0: 13 01 00 00 sethi %hi(0x4000000), %o1
4001c6b4: 80 a2 20 00 cmp %o0, 0
4001c6b8: 32 80 00 ad bne,a 4001c96c <rtems_rfs_dir_lookup_ino+0x2c8>
<== NEVER TAKEN
4001c6bc: 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;
4001c6c0: c0 27 00 00 clr [ %i4 ]
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001c6c4: 94 07 bf b0 add %fp, -80, %o2
*offset = 0;
4001c6c8: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001c6cc: 92 10 00 19 mov %i1, %o1
4001c6d0: 7f ff f9 df call 4001ae4c <rtems_rfs_block_map_open>
4001c6d4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001c6d8: a6 92 20 00 orcc %o0, 0, %l3
4001c6dc: 24 80 00 15 ble,a 4001c730 <rtems_rfs_dir_lookup_ino+0x8c>
<== ALWAYS TAKEN
4001c6e0: 92 10 00 1b mov %i3, %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c6e4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c6e8: 7f ff e2 53 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c6ec: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001c6f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c6f4: 32 80 00 04 bne,a 4001c704 <rtems_rfs_dir_lookup_ino+0x60>
<== NOT EXECUTED
4001c6f8: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001c6fc: 81 c7 e0 08 ret
4001c700: 91 e8 00 13 restore %g0, %l3, %o0
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
4001c704: 40 00 19 a2 call 40022d8c <strerror>
<== NOT EXECUTED
4001c708: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001c70c: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4001c710: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001c714: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c718: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
}
4001c71c: b0 10 00 13 mov %l3, %i0
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
4001c720: 7f ff e2 d2 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c724: 90 12 22 78 or %o0, 0x278, %o0
<== NOT EXECUTED
}
4001c728: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c72c: 81 e8 00 00 restore
<== NOT EXECUTED
handle->dirty = false;
4001c730: c0 2f bf a4 clrb [ %fp + -92 ]
hash = rtems_rfs_dir_hash (name, length);
4001c734: 90 10 00 1a mov %i2, %o0
handle->bnum = 0;
4001c738: c0 27 bf a8 clr [ %fp + -88 ]
4001c73c: 40 00 10 99 call 400209a0 <rtems_rfs_dir_hash>
4001c740: c0 27 bf ac clr [ %fp + -84 ]
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001c744: 98 07 bf a0 add %fp, -96, %o4
hash = rtems_rfs_dir_hash (name, length);
4001c748: a4 10 00 08 mov %o0, %l2
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001c74c: 94 10 20 00 clr %o2
4001c750: 96 10 20 00 clr %o3
4001c754: 92 07 bf b0 add %fp, -80, %o1
4001c758: 7f ff fa e8 call 4001b2f8 <rtems_rfs_block_map_seek>
4001c75c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001c760: a6 92 20 00 orcc %o0, 0, %l3
4001c764: 14 80 00 95 bg 4001c9b8 <rtems_rfs_dir_lookup_ino+0x314>
<== NEVER TAKEN
4001c768: 2f 10 00 cb sethi %hi(0x40032c00), %l7
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001c76c: 82 15 e2 f8 or %l7, 0x2f8, %g1 ! 40032ef8 <status_code_to_errno+0x7b4>
4001c770: c2 27 bf 9c st %g1, [ %fp + -100 ]
printf ("rtems-rfs: dir-lookup-ino: "
4001c774: 03 10 00 cc sethi %hi(0x40033000), %g1
4001c778: 82 10 60 70 or %g1, 0x70, %g1 ! 40033070 <status_code_to_errno+0x92c>
4001c77c: c2 27 bf 98 st %g1, [ %fp + -104 ]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c780: 23 00 00 3f sethi %hi(0xfc00), %l1
printf ("rtems-rfs: dir-lookup-ino: "
4001c784: 2d 10 00 cb sethi %hi(0x40032c00), %l6
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c788: a2 14 63 ff or %l1, 0x3ff, %l1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001c78c: a8 10 20 00 clr %l4
4001c790: 2b 02 00 00 sethi %hi(0x8000000), %l5
printf ("rtems-rfs: dir-lookup-ino: "
4001c794: ac 15 a3 c8 or %l6, 0x3c8, %l6
while ((rc == 0) && block)
4001c798: 80 a4 e0 00 cmp %l3, 0
4001c79c: 12 80 00 90 bne 4001c9dc <rtems_rfs_dir_lookup_ino+0x338>
<== NEVER TAKEN
4001c7a0: c2 07 bf a0 ld [ %fp + -96 ], %g1
4001c7a4: 80 a0 60 00 cmp %g1, 0
4001c7a8: 02 80 00 fe be 4001cba0 <rtems_rfs_dir_lookup_ino+0x4fc>
<== NEVER TAKEN
4001c7ac: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c7b0: 7f ff e2 21 call 40015034 <rtems_rfs_trace>
4001c7b4: 13 01 00 00 sethi %hi(0x4000000), %o1
4001c7b8: 80 a2 20 00 cmp %o0, 0
4001c7bc: 12 80 00 b5 bne 4001ca90 <rtems_rfs_dir_lookup_ino+0x3ec>
<== NEVER TAKEN
4001c7c0: d4 07 bf c0 ld [ %fp + -64 ], %o2
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001c7c4: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001c7c8: 96 10 20 01 mov 1, %o3
4001c7cc: 92 07 bf a4 add %fp, -92, %o1
4001c7d0: 7f ff fd b9 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001c7d4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001c7d8: a6 92 20 00 orcc %o0, 0, %l3
4001c7dc: 14 80 00 c4 bg 4001caec <rtems_rfs_dir_lookup_ino+0x448>
<== NEVER TAKEN
4001c7e0: 90 10 20 00 clr %o0
map.bpos.boff = 0;
4001c7e4: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c7e8: d0 06 20 08 ld [ %i0 + 8 ], %o0
entry = rtems_rfs_buffer_data (&entries);
4001c7ec: c2 07 bf ac ld [ %fp + -84 ], %g1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c7f0: 80 a2 20 0a cmp %o0, 0xa
4001c7f4: 12 80 00 0a bne 4001c81c <rtems_rfs_dir_lookup_ino+0x178>
<== ALWAYS TAKEN
4001c7f8: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
if (rc == 0)
4001c7fc: 10 80 00 47 b 4001c918 <rtems_rfs_dir_lookup_ino+0x274>
<== NOT EXECUTED
4001c800: 80 a4 e0 00 cmp %l3, 0
<== NOT EXECUTED
map.bpos.boff += elength;
4001c804: 82 05 c0 01 add %l7, %g1, %g1
4001c808: c2 27 bf c4 st %g1, [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c80c: 86 02 3f f6 add %o0, -10, %g3
4001c810: 80 a0 40 03 cmp %g1, %g3
4001c814: 1a 80 00 40 bcc 4001c914 <rtems_rfs_dir_lookup_ino+0x270>
<== NEVER TAKEN
4001c818: a0 04 00 17 add %l0, %l7, %l0
*ino = rtems_rfs_dir_entry_ino (entry);
4001c81c: d8 0c 00 00 ldub [ %l0 ], %o4
4001c820: de 0c 20 01 ldub [ %l0 + 1 ], %o7
4001c824: c2 0c 20 02 ldub [ %l0 + 2 ], %g1
4001c828: d2 0c 20 03 ldub [ %l0 + 3 ], %o1
ehash = rtems_rfs_dir_entry_hash (entry);
4001c82c: da 0c 20 04 ldub [ %l0 + 4 ], %o5
4001c830: c8 0c 20 05 ldub [ %l0 + 5 ], %g4
4001c834: c6 0c 20 06 ldub [ %l0 + 6 ], %g3
4001c838: d6 0c 20 07 ldub [ %l0 + 7 ], %o3
4001c83c: c4 0c 20 08 ldub [ %l0 + 8 ], %g2
4001c840: d4 0c 20 09 ldub [ %l0 + 9 ], %o2
*ino = rtems_rfs_dir_entry_ino (entry);
4001c844: 99 2b 20 18 sll %o4, 0x18, %o4
4001c848: 9f 2b e0 10 sll %o7, 0x10, %o7
4001c84c: 83 28 60 08 sll %g1, 8, %g1
4001c850: 9e 13 c0 0c or %o7, %o4, %o7
4001c854: 82 10 40 0f or %g1, %o7, %g1
4001c858: 92 12 40 01 or %o1, %g1, %o1
4001c85c: d2 27 00 00 st %o1, [ %i4 ]
ehash = rtems_rfs_dir_entry_hash (entry);
4001c860: 9b 2b 60 18 sll %o5, 0x18, %o5
4001c864: 89 29 20 10 sll %g4, 0x10, %g4
4001c868: 87 28 e0 08 sll %g3, 8, %g3
4001c86c: 88 11 00 0d or %g4, %o5, %g4
4001c870: 85 28 a0 08 sll %g2, 8, %g2
4001c874: 86 10 c0 04 or %g3, %g4, %g3
elength = rtems_rfs_dir_entry_length (entry);
4001c878: ae 12 80 02 or %o2, %g2, %l7
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001c87c: 80 a5 c0 11 cmp %l7, %l1
4001c880: 02 80 00 25 be 4001c914 <rtems_rfs_dir_lookup_ino+0x270>
4001c884: 86 12 c0 03 or %o3, %g3, %g3
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
4001c888: 80 a5 e0 0a cmp %l7, 0xa
4001c88c: 24 80 00 61 ble,a 4001ca10 <rtems_rfs_dir_lookup_ino+0x36c>
<== NEVER TAKEN
4001c890: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c894: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001c898: 80 a5 c0 01 cmp %l7, %g1
4001c89c: 1a 80 00 5c bcc 4001ca0c <rtems_rfs_dir_lookup_ino+0x368>
<== NEVER TAKEN
4001c8a0: 80 a2 60 00 cmp %o1, 0
4001c8a4: 22 80 00 5b be,a 4001ca10 <rtems_rfs_dir_lookup_ino+0x36c>
<== NEVER TAKEN
4001c8a8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c8ac: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001c8b0: 80 a2 40 01 cmp %o1, %g1
4001c8b4: 18 80 00 56 bgu 4001ca0c <rtems_rfs_dir_lookup_ino+0x368>
<== NEVER TAKEN
4001c8b8: 80 a4 80 03 cmp %l2, %g3
if (ehash == hash)
4001c8bc: 12 bf ff d2 bne 4001c804 <rtems_rfs_dir_lookup_ino+0x160>
4001c8c0: c2 07 bf c4 ld [ %fp + -60 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001c8c4: 90 10 00 14 mov %l4, %o0
4001c8c8: 7f ff e1 db call 40015034 <rtems_rfs_trace>
4001c8cc: 92 10 00 15 mov %l5, %o1
4001c8d0: 80 a2 20 00 cmp %o0, 0
4001c8d4: 32 80 00 5f bne,a 4001ca50 <rtems_rfs_dir_lookup_ino+0x3ac>
<== NEVER TAKEN
4001c8d8: c8 0c 00 00 ldub [ %l0 ], %g4
<== NOT EXECUTED
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001c8dc: 94 10 00 1b mov %i3, %o2
4001c8e0: 92 10 00 1a mov %i2, %o1
4001c8e4: 40 00 13 d1 call 40021828 <memcmp>
4001c8e8: 90 04 20 0a add %l0, 0xa, %o0
4001c8ec: 80 a2 20 00 cmp %o0, 0
4001c8f0: 02 80 00 91 be 4001cb34 <rtems_rfs_dir_lookup_ino+0x490>
<== ALWAYS TAKEN
4001c8f4: c2 07 bf c4 ld [ %fp + -60 ], %g1
map.bpos.boff += elength;
4001c8f8: 82 05 c0 01 add %l7, %g1, %g1
<== NOT EXECUTED
4001c8fc: c2 27 bf c4 st %g1, [ %fp + -60 ]
<== NOT EXECUTED
4001c900: d0 06 20 08 ld [ %i0 + 8 ], %o0
<== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001c904: 86 02 3f f6 add %o0, -10, %g3
<== NOT EXECUTED
4001c908: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
4001c90c: 0a bf ff c4 bcs 4001c81c <rtems_rfs_dir_lookup_ino+0x178>
<== NOT EXECUTED
4001c910: a0 04 00 17 add %l0, %l7, %l0
<== NOT EXECUTED
if (rc == 0)
4001c914: 80 a4 e0 00 cmp %l3, 0
4001c918: 12 80 00 32 bne 4001c9e0 <rtems_rfs_dir_lookup_ino+0x33c>
<== NEVER TAKEN
4001c91c: 92 07 bf a4 add %fp, -92, %o1
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001c920: 94 07 bf a0 add %fp, -96, %o2
4001c924: 92 07 bf b0 add %fp, -80, %o1
4001c928: 7f ff fa 92 call 4001b370 <rtems_rfs_block_map_next_block>
4001c92c: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && (rc != ENXIO))
4001c930: a6 92 20 00 orcc %o0, 0, %l3
4001c934: 04 80 00 09 ble 4001c958 <rtems_rfs_dir_lookup_ino+0x2b4>
<== NEVER TAKEN
4001c938: 80 a4 e0 06 cmp %l3, 6
4001c93c: 02 80 00 08 be 4001c95c <rtems_rfs_dir_lookup_ino+0x2b8>
<== ALWAYS TAKEN
4001c940: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c944: 7f ff e1 bc call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c948: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001c94c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c950: 32 80 00 5e bne,a 4001cac8 <rtems_rfs_dir_lookup_ino+0x424>
<== NOT EXECUTED
4001c954: e0 06 60 08 ld [ %i1 + 8 ], %l0
<== NOT EXECUTED
if (rc == ENXIO)
4001c958: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
4001c95c: 12 bf ff 90 bne 4001c79c <rtems_rfs_dir_lookup_ino+0xf8>
<== NEVER TAKEN
4001c960: 80 a4 e0 00 cmp %l3, 0
rc = ENOENT;
4001c964: 10 80 00 1e b 4001c9dc <rtems_rfs_dir_lookup_ino+0x338>
4001c968: a6 10 20 02 mov 2, %l3
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001c96c: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c970: 7f ff e2 3e call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c974: 90 12 22 30 or %o0, 0x230, %o0 ! 40032e30 <status_code_to_errno+0x6ec>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001c978: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4001c97c: 04 80 00 0a ble 4001c9a4 <rtems_rfs_dir_lookup_ino+0x300>
<== NOT EXECUTED
4001c980: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001c984: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4001c988: a2 06 c0 1a add %i3, %i2, %l1
<== NOT EXECUTED
printf ("%c", name[c]);
4001c98c: 7f ff e2 4c call 400152bc <__wrap_putchar>
<== NOT EXECUTED
4001c990: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
4001c994: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001c998: 80 a4 40 10 cmp %l1, %l0
<== NOT EXECUTED
4001c99c: 12 bf ff fc bne 4001c98c <rtems_rfs_dir_lookup_ino+0x2e8>
<== NOT EXECUTED
4001c9a0: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
printf (", len=%d\n", length);
4001c9a4: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001c9a8: 7f ff e2 30 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001c9ac: 90 12 22 68 or %o0, 0x268, %o0 ! 40032e68 <status_code_to_errno+0x724>
<== NOT EXECUTED
*ino = RTEMS_RFS_EMPTY_INO;
4001c9b0: 10 bf ff 45 b 4001c6c4 <rtems_rfs_dir_lookup_ino+0x20>
<== NOT EXECUTED
4001c9b4: c0 27 00 00 clr [ %i4 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001c9b8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c9bc: 7f ff e1 9e call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001c9c0: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001c9c4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c9c8: 12 80 00 37 bne 4001caa4 <rtems_rfs_dir_lookup_ino+0x400>
<== NOT EXECUTED
4001c9cc: 01 00 00 00 nop
<== NOT EXECUTED
if (rc == ENXIO)
4001c9d0: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
4001c9d4: 22 80 00 02 be,a 4001c9dc <rtems_rfs_dir_lookup_ino+0x338>
<== NOT EXECUTED
4001c9d8: a6 10 20 02 mov 2, %l3
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001c9dc: 92 07 bf a4 add %fp, -92, %o1
4001c9e0: 7f ff fd fc call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001c9e4: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001c9e8: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001c9ec: c0 2f bf a4 clrb [ %fp + -92 ]
4001c9f0: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001c9f4: c0 27 bf a8 clr [ %fp + -88 ]
}
4001c9f8: b0 10 00 13 mov %l3, %i0
rtems_rfs_block_map_close (fs, &map);
4001c9fc: 7f ff f9 73 call 4001afc8 <rtems_rfs_block_map_close>
4001ca00: c0 27 bf ac clr [ %fp + -84 ]
}
4001ca04: 81 c7 e0 08 ret
4001ca08: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001ca0c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ca10: 7f ff e1 89 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ca14: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001ca18: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ca1c: 12 80 00 04 bne 4001ca2c <rtems_rfs_dir_lookup_ino+0x388>
<== NOT EXECUTED
4001ca20: d8 07 bf c4 ld [ %fp + -60 ], %o4
<== NOT EXECUTED
rc = EIO;
4001ca24: 10 bf ff ee b 4001c9dc <rtems_rfs_dir_lookup_ino+0x338>
<== NOT EXECUTED
4001ca28: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001ca2c: d6 07 00 00 ld [ %i4 ], %o3
<== NOT EXECUTED
4001ca30: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001ca34: 94 10 00 17 mov %l7, %o2
<== NOT EXECUTED
rc = EIO;
4001ca38: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001ca3c: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001ca40: 7f ff e2 0a call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ca44: 90 12 23 78 or %o0, 0x378, %o0 ! 40032f78 <status_code_to_errno+0x834>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001ca48: 10 bf ff e6 b 4001c9e0 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001ca4c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001ca50: c6 0c 20 01 ldub [ %l0 + 1 ], %g3
<== NOT EXECUTED
4001ca54: c2 0c 20 02 ldub [ %l0 + 2 ], %g1
<== NOT EXECUTED
4001ca58: da 0c 20 03 ldub [ %l0 + 3 ], %o5
<== NOT EXECUTED
4001ca5c: 89 29 20 18 sll %g4, 0x18, %g4
<== NOT EXECUTED
4001ca60: d4 1f bf c0 ldd [ %fp + -64 ], %o2
<== NOT EXECUTED
4001ca64: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001ca68: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
4001ca6c: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001ca70: 86 10 c0 04 or %g3, %g4, %g3
<== NOT EXECUTED
4001ca74: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
4001ca78: 98 10 00 17 mov %l7, %o4
<== NOT EXECUTED
4001ca7c: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
4001ca80: 7f ff e1 fa call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ca84: 9a 13 40 01 or %o5, %g1, %o5
<== NOT EXECUTED
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001ca88: 10 bf ff 96 b 4001c8e0 <rtems_rfs_dir_lookup_ino+0x23c>
<== NOT EXECUTED
4001ca8c: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001ca90: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001ca94: 7f ff e1 f5 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ca98: d0 07 bf 9c ld [ %fp + -100 ], %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001ca9c: 10 bf ff 4b b 4001c7c8 <rtems_rfs_dir_lookup_ino+0x124>
<== NOT EXECUTED
4001caa0: d4 07 bf a0 ld [ %fp + -96 ], %o2
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
4001caa4: 40 00 18 ba call 40022d8c <strerror>
<== NOT EXECUTED
4001caa8: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001caac: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
4001cab0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001cab4: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001cab8: 7f ff e1 ec call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cabc: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40032eb8 <status_code_to_errno+0x774>
<== NOT EXECUTED
if (rc == ENXIO)
4001cac0: 10 bf ff c5 b 4001c9d4 <rtems_rfs_dir_lookup_ino+0x330>
<== NOT EXECUTED
4001cac4: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001cac8: 40 00 18 b1 call 40022d8c <strerror>
<== NOT EXECUTED
4001cacc: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001cad0: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001cad4: d0 07 bf 98 ld [ %fp + -104 ], %o0
<== NOT EXECUTED
4001cad8: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4001cadc: 7f ff e1 e3 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cae0: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
if (rc == ENXIO)
4001cae4: 10 bf ff 9e b 4001c95c <rtems_rfs_dir_lookup_ino+0x2b8>
<== NOT EXECUTED
4001cae8: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001caec: 7f ff e1 52 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001caf0: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001caf4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001caf8: 22 bf ff ba be,a 4001c9e0 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001cafc: 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",
4001cb00: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001cb04: f8 07 bf a0 ld [ %fp + -96 ], %i4
<== NOT EXECUTED
4001cb08: 40 00 18 a1 call 40022d8c <strerror>
<== NOT EXECUTED
4001cb0c: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001cb10: 96 10 00 13 mov %l3, %o3
<== NOT EXECUTED
4001cb14: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001cb18: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001cb1c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cb20: 11 10 00 cb sethi %hi(0x40032c00), %o0
<== NOT EXECUTED
4001cb24: 7f ff e1 d1 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cb28: 90 12 23 30 or %o0, 0x330, %o0 ! 40032f30 <status_code_to_errno+0x7ec>
<== NOT EXECUTED
4001cb2c: 10 bf ff ad b 4001c9e0 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001cb30: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
*offset = rtems_rfs_block_map_pos (fs, &map);
4001cb34: 92 07 bf c0 add %fp, -64, %o1
4001cb38: 7f ff f8 ab call 4001ade4 <rtems_rfs_block_get_pos>
4001cb3c: 90 10 00 18 mov %i0, %o0
4001cb40: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001cb44: 90 10 20 00 clr %o0
4001cb48: 7f ff e1 3b call 40015034 <rtems_rfs_trace>
4001cb4c: 13 04 00 00 sethi %hi(0x10000000), %o1
4001cb50: 80 a2 20 00 cmp %o0, 0
4001cb54: 02 80 00 09 be 4001cb78 <rtems_rfs_dir_lookup_ino+0x4d4>
<== ALWAYS TAKEN
4001cb58: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
4001cb5c: d6 07 40 00 ld [ %i5 ], %o3
<== NOT EXECUTED
4001cb60: d4 07 00 00 ld [ %i4 ], %o2
<== NOT EXECUTED
4001cb64: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001cb68: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cb6c: 7f ff e1 bf call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cb70: 90 12 20 28 or %o0, 0x28, %o0 ! 40033028 <status_code_to_errno+0x8e4>
<== NOT EXECUTED
4001cb74: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001cb78: 7f ff fd 96 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001cb7c: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001cb80: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001cb84: c0 2f bf a4 clrb [ %fp + -92 ]
4001cb88: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001cb8c: c0 27 bf a8 clr [ %fp + -88 ]
return 0;
4001cb90: a6 10 20 00 clr %l3
rtems_rfs_block_map_close (fs, &map);
4001cb94: 7f ff f9 0d call 4001afc8 <rtems_rfs_block_map_close>
4001cb98: c0 27 bf ac clr [ %fp + -84 ]
return 0;
4001cb9c: 30 bf fe d8 b,a 4001c6fc <rtems_rfs_dir_lookup_ino+0x58>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001cba0: 7f ff e1 25 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001cba4: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001cba8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cbac: 22 bf ff 8c be,a 4001c9dc <rtems_rfs_dir_lookup_ino+0x338>
<== NOT EXECUTED
4001cbb0: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001cbb4: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001cbb8: 40 00 18 75 call 40022d8c <strerror>
<== NOT EXECUTED
4001cbbc: 90 10 20 05 mov 5, %o0
<== NOT EXECUTED
4001cbc0: 94 10 20 05 mov 5, %o2
<== NOT EXECUTED
4001cbc4: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001cbc8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
rc = EIO;
4001cbcc: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001cbd0: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001cbd4: 7f ff e1 a5 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001cbd8: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400330c0 <status_code_to_errno+0x97c>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001cbdc: 10 bf ff 81 b 4001c9e0 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001cbe0: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001d444 <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)
{
4001d444: 9d e3 bf 40 save %sp, -192, %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))
4001d448: 90 10 20 00 clr %o0
4001d44c: 13 20 00 00 sethi %hi(0x80000000), %o1
4001d450: 7f ff de f9 call 40015034 <rtems_rfs_trace>
4001d454: a4 10 00 1a mov %i2, %l2
4001d458: 80 a2 20 00 cmp %o0, 0
4001d45c: 12 80 00 29 bne 4001d500 <rtems_rfs_dir_read+0xbc>
<== NEVER TAKEN
4001d460: 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;
4001d464: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d468: 92 10 00 19 mov %i1, %o1
4001d46c: 94 07 bf b0 add %fp, -80, %o2
4001d470: 7f ff f6 77 call 4001ae4c <rtems_rfs_block_map_open>
4001d474: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d478: b6 92 20 00 orcc %o0, 0, %i3
4001d47c: 24 80 00 04 ble,a 4001d48c <rtems_rfs_dir_read+0x48>
<== ALWAYS TAKEN
4001d480: e0 06 20 08 ld [ %i0 + 8 ], %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001d484: 81 c7 e0 08 ret
<== NOT EXECUTED
4001d488: 91 e8 00 1b restore %g0, %i3, %o0
<== NOT EXECUTED
if (((rtems_rfs_fs_block_size (fs) -
4001d48c: b4 10 20 00 clr %i2
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
4001d490: 90 10 00 12 mov %l2, %o0
4001d494: 92 10 00 13 mov %l3, %o1
4001d498: 94 10 00 1a mov %i2, %o2
4001d49c: 40 00 47 2c call 4002f14c <__moddi3>
4001d4a0: 96 10 00 10 mov %l0, %o3
if (((rtems_rfs_fs_block_size (fs) -
4001d4a4: 86 a4 00 09 subcc %l0, %o1, %g3
4001d4a8: 84 66 80 08 subx %i2, %o0, %g2
4001d4ac: 80 a0 a0 00 cmp %g2, 0
4001d4b0: 04 80 00 1c ble 4001d520 <rtems_rfs_dir_read+0xdc>
<== ALWAYS TAKEN
4001d4b4: b6 10 00 10 mov %l0, %i3
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001d4b8: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001d4bc: 96 10 00 13 mov %l3, %o3
4001d4c0: 98 07 bf a0 add %fp, -96, %o4
4001d4c4: 92 07 bf b0 add %fp, -80, %o1
4001d4c8: 7f ff f7 8c call 4001b2f8 <rtems_rfs_block_map_seek>
4001d4cc: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d4d0: b6 92 20 00 orcc %o0, 0, %i3
4001d4d4: 24 80 00 2d ble,a 4001d588 <rtems_rfs_dir_read+0x144>
<== ALWAYS TAKEN
4001d4d8: 35 00 00 3f sethi %hi(0xfc00), %i2
if (rc == ENXIO)
4001d4dc: 80 a6 e0 06 cmp %i3, 6
<== NOT EXECUTED
4001d4e0: 22 80 00 02 be,a 4001d4e8 <rtems_rfs_dir_read+0xa4>
<== NOT EXECUTED
4001d4e4: b6 10 20 02 mov 2, %i3
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001d4e8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d4ec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001d4f0: 7f ff f6 b6 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d4f4: b0 10 00 1b mov %i3, %i0
<== NOT EXECUTED
}
4001d4f8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001d4fc: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
4001d500: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001d504: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001d508: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4001d50c: 11 10 00 cc sethi %hi(0x40033000), %o0
<== NOT EXECUTED
4001d510: 7f ff df 56 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d514: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 400333e0 <status_code_to_errno+0xc9c>
<== NOT EXECUTED
*length = 0;
4001d518: 10 bf ff d4 b 4001d468 <rtems_rfs_dir_read+0x24>
<== NOT EXECUTED
4001d51c: c0 27 40 00 clr [ %i5 ]
<== NOT EXECUTED
if (((rtems_rfs_fs_block_size (fs) -
4001d520: 12 80 00 06 bne 4001d538 <rtems_rfs_dir_read+0xf4>
<== NEVER TAKEN
4001d524: 96 10 00 1b mov %i3, %o3
4001d528: 80 a0 e0 0a cmp %g3, 0xa
4001d52c: 38 bf ff e4 bgu,a 4001d4bc <rtems_rfs_dir_read+0x78>
<== ALWAYS TAKEN
4001d530: 94 10 00 12 mov %l2, %o2
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
4001d534: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4001d538: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
4001d53c: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
4001d540: 40 00 46 78 call 4002ef20 <__divdi3>
<== NOT EXECUTED
4001d544: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001d548: 86 82 60 01 addcc %o1, 1, %g3
<== NOT EXECUTED
4001d54c: 84 42 20 00 addx %o0, 0, %g2
<== NOT EXECUTED
4001d550: 82 58 80 10 smul %g2, %l0, %g1
<== NOT EXECUTED
4001d554: a6 54 00 03 umul %l0, %g3, %l3
<== NOT EXECUTED
4001d558: a5 40 00 00 rd %y, %l2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001d55c: 98 07 bf a0 add %fp, -96, %o4
<== NOT EXECUTED
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
4001d560: a4 00 40 12 add %g1, %l2, %l2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001d564: 96 10 00 13 mov %l3, %o3
<== NOT EXECUTED
4001d568: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001d56c: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d570: 7f ff f7 62 call 4001b2f8 <rtems_rfs_block_map_seek>
<== NOT EXECUTED
4001d574: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d578: b6 92 20 00 orcc %o0, 0, %i3
<== NOT EXECUTED
4001d57c: 14 bf ff d9 bg 4001d4e0 <rtems_rfs_dir_read+0x9c>
<== NOT EXECUTED
4001d580: 80 a6 e0 06 cmp %i3, 6
<== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d584: 35 00 00 3f sethi %hi(0xfc00), %i2
<== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001d588: 2d 10 00 cd sethi %hi(0x40033400), %l6
handle->dirty = false;
4001d58c: c0 2f bf a4 clrb [ %fp + -92 ]
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d590: b4 16 a3 ff or %i2, 0x3ff, %i2
handle->bnum = 0;
4001d594: c0 27 bf a8 clr [ %fp + -88 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d598: a8 10 20 00 clr %l4
handle->buffer = NULL;
4001d59c: c0 27 bf ac clr [ %fp + -84 ]
4001d5a0: 2b 20 00 00 sethi %hi(0x80000000), %l5
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001d5a4: 10 80 00 0b b 4001d5d0 <rtems_rfs_dir_read+0x18c>
4001d5a8: ac 15 a0 90 or %l6, 0x90, %l6
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d5ac: 92 07 bf b0 add %fp, -80, %o1
4001d5b0: 7f ff f7 70 call 4001b370 <rtems_rfs_block_map_next_block>
4001d5b4: 90 10 00 18 mov %i0, %o0
if (rc == ENXIO)
4001d5b8: 80 a2 20 06 cmp %o0, 6
4001d5bc: 02 80 00 90 be 4001d7fc <rtems_rfs_dir_read+0x3b8>
<== ALWAYS TAKEN
4001d5c0: b6 10 00 08 mov %o0, %i3
while (rc == 0)
4001d5c4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d5c8: 12 80 00 60 bne 4001d748 <rtems_rfs_dir_read+0x304>
<== NOT EXECUTED
4001d5cc: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001d5d0: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001d5d4: 96 10 20 01 mov 1, %o3
4001d5d8: 92 07 bf a4 add %fp, -92, %o1
4001d5dc: 7f ff fa 36 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001d5e0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d5e4: b6 92 20 00 orcc %o0, 0, %i3
4001d5e8: 14 80 00 57 bg 4001d744 <rtems_rfs_dir_read+0x300>
<== NEVER TAKEN
4001d5ec: c2 07 bf ac ld [ %fp + -84 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
4001d5f0: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
entry += map.bpos.boff;
4001d5f4: c6 07 bf c4 ld [ %fp + -60 ], %g3
4001d5f8: a0 04 00 03 add %l0, %g3, %l0
4001d5fc: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
4001d600: e2 0c 20 09 ldub [ %l0 + 9 ], %l1
4001d604: 83 28 60 08 sll %g1, 8, %g1
elength = rtems_rfs_dir_entry_length (entry);
4001d608: a2 14 40 01 or %l1, %g1, %l1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d60c: 80 a4 40 1a cmp %l1, %i2
4001d610: 12 80 00 59 bne 4001d774 <rtems_rfs_dir_read+0x330>
4001d614: 90 10 00 14 mov %l4, %o0
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
4001d618: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001d61c: c2 07 40 00 ld [ %i5 ], %g1
4001d620: 84 20 80 03 sub %g2, %g3, %g2
4001d624: 82 00 40 02 add %g1, %g2, %g1
4001d628: c2 27 40 00 st %g1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d62c: 7f ff de 82 call 40015034 <rtems_rfs_trace>
4001d630: 92 10 00 15 mov %l5, %o1
4001d634: 80 a2 20 00 cmp %o0, 0
4001d638: 22 bf ff dd be,a 4001d5ac <rtems_rfs_dir_read+0x168>
<== ALWAYS TAKEN
4001d63c: 94 07 bf a0 add %fp, -96, %o2
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001d640: d6 07 40 00 ld [ %i5 ], %o3
<== NOT EXECUTED
4001d644: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001d648: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4001d64c: 7f ff df 07 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d650: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d654: 10 bf ff d6 b 4001d5ac <rtems_rfs_dir_read+0x168>
<== NOT EXECUTED
4001d658: 94 07 bf a0 add %fp, -96, %o2
<== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d65c: 80 a0 40 1a cmp %g1, %i2
4001d660: 0a 80 00 58 bcs 4001d7c0 <rtems_rfs_dir_read+0x37c>
<== NEVER TAKEN
4001d664: 90 10 20 00 clr %o0
memset (dirent, 0, sizeof (struct dirent));
4001d668: 94 10 21 18 mov 0x118, %o2
4001d66c: 92 10 20 00 clr %o1
4001d670: 40 00 11 21 call 40021af4 <memset>
4001d674: 90 10 00 1c mov %i4, %o0
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
4001d678: 92 07 bf c0 add %fp, -64, %o1
4001d67c: 7f ff f5 da call 4001ade4 <rtems_rfs_block_get_pos>
4001d680: 90 10 00 18 mov %i0, %o0
*length += elength;
4001d684: c2 07 40 00 ld [ %i5 ], %g1
dirent->d_reclen = sizeof (struct dirent);
4001d688: 84 10 21 18 mov 0x118, %g2
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
4001d68c: d0 3f 20 08 std %o0, [ %i4 + 8 ]
*length += elength;
4001d690: 82 04 40 01 add %l1, %g1, %g1
dirent->d_reclen = sizeof (struct dirent);
4001d694: c4 37 20 10 sth %g2, [ %i4 + 0x10 ]
*length += elength;
4001d698: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001d69c: c6 07 bf c4 ld [ %fp + -60 ], %g3
4001d6a0: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001d6a4: 84 20 80 03 sub %g2, %g3, %g2
4001d6a8: 84 20 80 11 sub %g2, %l1, %g2
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
4001d6ac: 80 a0 a0 0a cmp %g2, 0xa
4001d6b0: 14 80 00 04 bg 4001d6c0 <rtems_rfs_dir_read+0x27c>
<== ALWAYS TAKEN
4001d6b4: a2 04 7f f6 add %l1, -10, %l1
*length += remaining;
4001d6b8: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4001d6bc: c2 27 40 00 st %g1, [ %i5 ]
<== NOT EXECUTED
4001d6c0: 80 a4 60 ff cmp %l1, 0xff
4001d6c4: 34 80 00 02 bg,a 4001d6cc <rtems_rfs_dir_read+0x288>
<== NEVER TAKEN
4001d6c8: a2 10 20 ff mov 0xff, %l1
<== NOT EXECUTED
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
4001d6cc: 94 10 00 11 mov %l1, %o2
4001d6d0: 92 04 20 0a add %l0, 0xa, %o1
4001d6d4: ba 07 20 14 add %i4, 0x14, %i5
4001d6d8: 40 00 10 7d call 400218cc <memcpy>
4001d6dc: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001d6e0: c8 0c 00 00 ldub [ %l0 ], %g4
4001d6e4: c4 0c 20 01 ldub [ %l0 + 1 ], %g2
4001d6e8: c2 0c 20 02 ldub [ %l0 + 2 ], %g1
4001d6ec: c6 0c 20 03 ldub [ %l0 + 3 ], %g3
4001d6f0: 89 29 20 18 sll %g4, 0x18, %g4
4001d6f4: 85 28 a0 10 sll %g2, 0x10, %g2
4001d6f8: 83 28 60 08 sll %g1, 8, %g1
4001d6fc: 84 10 80 04 or %g2, %g4, %g2
dirent->d_namlen = elength;
4001d700: e2 37 20 12 sth %l1, [ %i4 + 0x12 ]
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001d704: 82 10 40 02 or %g1, %g2, %g1
4001d708: 82 10 c0 01 or %g3, %g1, %g1
4001d70c: c2 27 00 00 st %g1, [ %i4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d710: 90 10 20 00 clr %o0
4001d714: 7f ff de 48 call 40015034 <rtems_rfs_trace>
4001d718: 13 20 00 00 sethi %hi(0x80000000), %o1
4001d71c: 80 a2 20 00 cmp %o0, 0
4001d720: 02 80 00 0a be 4001d748 <rtems_rfs_dir_read+0x304>
<== ALWAYS TAKEN
4001d724: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001d728: d6 07 00 00 ld [ %i4 ], %o3
<== NOT EXECUTED
4001d72c: d2 07 20 08 ld [ %i4 + 8 ], %o1
<== NOT EXECUTED
4001d730: d4 07 20 0c ld [ %i4 + 0xc ], %o2
<== NOT EXECUTED
4001d734: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001d738: 98 10 00 1d mov %i5, %o4
<== NOT EXECUTED
4001d73c: 7f ff de cb call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d740: 90 12 20 58 or %o0, 0x58, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d744: 92 07 bf a4 add %fp, -92, %o1
4001d748: 7f ff fa a2 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001d74c: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001d750: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001d754: c0 2f bf a4 clrb [ %fp + -92 ]
4001d758: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001d75c: c0 27 bf a8 clr [ %fp + -88 ]
}
4001d760: b0 10 00 1b mov %i3, %i0
rtems_rfs_block_map_close (fs, &map);
4001d764: 7f ff f6 19 call 4001afc8 <rtems_rfs_block_map_close>
4001d768: c0 27 bf ac clr [ %fp + -84 ]
}
4001d76c: 81 c7 e0 08 ret
4001d770: 81 e8 00 00 restore
eino = rtems_rfs_dir_entry_ino (entry);
4001d774: c4 0c 00 00 ldub [ %l0 ], %g2
4001d778: c2 0c 20 01 ldub [ %l0 + 1 ], %g1
4001d77c: d6 0c 20 02 ldub [ %l0 + 2 ], %o3
4001d780: c6 0c 20 03 ldub [ %l0 + 3 ], %g3
4001d784: 85 28 a0 18 sll %g2, 0x18, %g2
4001d788: 83 28 60 10 sll %g1, 0x10, %g1
4001d78c: 97 2a e0 08 sll %o3, 8, %o3
4001d790: 82 10 40 02 or %g1, %g2, %g1
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d794: 80 a4 60 0a cmp %l1, 0xa
eino = rtems_rfs_dir_entry_ino (entry);
4001d798: 96 12 c0 01 or %o3, %g1, %o3
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d79c: 04 80 00 08 ble 4001d7bc <rtems_rfs_dir_read+0x378>
<== NEVER TAKEN
4001d7a0: b4 10 c0 0b or %g3, %o3, %i2
4001d7a4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001d7a8: 80 a4 40 01 cmp %l1, %g1
4001d7ac: 1a 80 00 04 bcc 4001d7bc <rtems_rfs_dir_read+0x378>
<== NEVER TAKEN
4001d7b0: 80 a6 a0 00 cmp %i2, 0
4001d7b4: 32 bf ff aa bne,a 4001d65c <rtems_rfs_dir_read+0x218>
<== ALWAYS TAKEN
4001d7b8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001d7bc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001d7c0: 13 20 00 00 sethi %hi(0x80000000), %o1
<== NOT EXECUTED
4001d7c4: 7f ff de 1c call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001d7c8: b6 10 20 05 mov 5, %i3
<== NOT EXECUTED
4001d7cc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d7d0: 22 bf ff de be,a 4001d748 <rtems_rfs_dir_read+0x304>
<== NOT EXECUTED
4001d7d4: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
4001d7d8: d8 07 bf c4 ld [ %fp + -60 ], %o4
<== NOT EXECUTED
4001d7dc: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001d7e0: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4001d7e4: 94 10 00 11 mov %l1, %o2
<== NOT EXECUTED
4001d7e8: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001d7ec: 7f ff de 9f call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001d7f0: 90 12 20 10 or %o0, 0x10, %o0 ! 40033410 <status_code_to_errno+0xccc>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d7f4: 10 bf ff d5 b 4001d748 <rtems_rfs_dir_read+0x304>
<== NOT EXECUTED
4001d7f8: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = ENOENT;
4001d7fc: 10 bf ff d2 b 4001d744 <rtems_rfs_dir_read+0x300>
4001d800: b6 10 20 02 mov 2, %i3
4001ddb8 <rtems_rfs_file_close>:
{
4001ddb8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001ddbc: 90 10 20 10 mov 0x10, %o0
4001ddc0: 7f ff dc 9d call 40015034 <rtems_rfs_trace>
4001ddc4: 92 10 20 00 clr %o1
4001ddc8: 80 a2 20 00 cmp %o0, 0
4001ddcc: 32 80 00 79 bne,a 4001dfb0 <rtems_rfs_file_close+0x1f8>
<== NEVER TAKEN
4001ddd0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
if (handle->shared->references > 0)
4001ddd4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001ddd8: fa 02 60 08 ld [ %o1 + 8 ], %i5
4001dddc: 80 a7 60 00 cmp %i5, 0
4001dde0: 04 80 00 05 ble 4001ddf4 <rtems_rfs_file_close+0x3c>
<== NEVER TAKEN
4001dde4: 01 00 00 00 nop
handle->shared->references--;
4001dde8: ba 07 7f ff add %i5, -1, %i5
4001ddec: fa 22 60 08 st %i5, [ %o1 + 8 ]
if (handle->shared->references == 0)
4001ddf0: 80 a7 60 00 cmp %i5, 0
4001ddf4: 02 80 00 0b be 4001de20 <rtems_rfs_file_close+0x68>
<== ALWAYS TAKEN
4001ddf8: b8 06 60 04 add %i1, 4, %i4
4001ddfc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001de00: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001de04: 7f ff f8 f3 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001de08: ba 10 20 00 clr %i5
<== NOT EXECUTED
free (handle);
4001de0c: 90 10 00 19 mov %i1, %o0
4001de10: 7f ff ad 81 call 40009414 <free>
4001de14: b0 10 00 1d mov %i5, %i0
}
4001de18: 81 c7 e0 08 ret
4001de1c: 81 e8 00 00 restore
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
4001de20: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001de24: 80 a0 a0 00 cmp %g2, 0
4001de28: 22 80 00 87 be,a 4001e044 <rtems_rfs_file_close+0x28c>
<== ALWAYS TAKEN
4001de2c: 92 02 60 0c add %o1, 0xc, %o1
rtems_rfs_inode_set_atime (&handle->shared->inode,
4001de30: c2 02 60 8c ld [ %o1 + 0x8c ], %g1
rtems_rfs_write_u32 (&handle->node->atime, atime);
4001de34: 87 30 60 18 srl %g1, 0x18, %g3
4001de38: c6 28 a0 10 stb %g3, [ %g2 + 0x10 ]
4001de3c: 87 30 60 10 srl %g1, 0x10, %g3
4001de40: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001de44: c6 28 a0 11 stb %g3, [ %g2 + 0x11 ]
4001de48: 87 30 60 08 srl %g1, 8, %g3
4001de4c: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001de50: c6 28 a0 12 stb %g3, [ %g2 + 0x12 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001de54: 88 10 20 01 mov 1, %g4
rtems_rfs_write_u32 (&handle->node->atime, atime);
4001de58: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001de5c: c2 28 a0 13 stb %g1, [ %g2 + 0x13 ]
rtems_rfs_inode_set_mtime (&handle->shared->inode,
4001de60: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
4001de64: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001de68: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001de6c: c8 2a 60 1c stb %g4, [ %o1 + 0x1c ]
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001de70: b7 30 60 18 srl %g1, 0x18, %i3
4001de74: f6 28 e0 14 stb %i3, [ %g3 + 0x14 ]
4001de78: b7 30 60 10 srl %g1, 0x10, %i3
4001de7c: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4001de80: f6 28 e0 15 stb %i3, [ %g3 + 0x15 ]
4001de84: b7 30 60 08 srl %g1, 8, %i3
4001de88: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4001de8c: f6 28 e0 16 stb %i3, [ %g3 + 0x16 ]
4001de90: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4001de94: c2 28 e0 17 stb %g1, [ %g3 + 0x17 ]
rtems_rfs_inode_set_ctime (&handle->shared->inode,
4001de98: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001de9c: c6 00 60 94 ld [ %g1 + 0x94 ], %g3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001dea0: c8 28 a0 1c stb %g4, [ %g2 + 0x1c ]
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4001dea4: b7 30 e0 18 srl %g3, 0x18, %i3
4001dea8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001deac: f6 28 a0 18 stb %i3, [ %g2 + 0x18 ]
4001deb0: b7 30 e0 10 srl %g3, 0x10, %i3
4001deb4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001deb8: f6 28 a0 19 stb %i3, [ %g2 + 0x19 ]
4001debc: b7 30 e0 08 srl %g3, 8, %i3
4001dec0: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001dec4: f6 28 a0 1a stb %i3, [ %g2 + 0x1a ]
4001dec8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001decc: c6 28 a0 1b stb %g3, [ %g2 + 0x1b ]
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001ded0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ded4: c8 28 60 1c stb %g4, [ %g1 + 0x1c ]
4001ded8: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
4001dedc: c4 02 60 3c ld [ %o1 + 0x3c ], %g2
4001dee0: 80 a0 40 02 cmp %g1, %g2
4001dee4: 02 80 00 75 be 4001e0b8 <rtems_rfs_file_close+0x300>
<== ALWAYS TAKEN
4001dee8: 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);
4001deec: c2 22 60 3c st %g1, [ %o1 + 0x3c ]
<== NOT EXECUTED
map->dirty = true;
4001def0: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
rtems_rfs_block_copy_size (&map->size, size);
4001def4: c4 22 60 40 st %g2, [ %o1 + 0x40 ]
<== NOT EXECUTED
map->dirty = true;
4001def8: c2 2a 60 34 stb %g1, [ %o1 + 0x34 ]
<== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
4001defc: 92 02 60 34 add %o1, 0x34, %o1
<== NOT EXECUTED
4001df00: 7f ff f4 32 call 4001afc8 <rtems_rfs_block_map_close>
4001df04: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001df08: b6 92 20 00 orcc %o0, 0, %i3
4001df0c: 14 80 00 44 bg 4001e01c <rtems_rfs_file_close+0x264>
<== NEVER TAKEN
4001df10: 90 10 20 10 mov 0x10, %o0
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001df14: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001df18: 92 02 60 0c add %o1, 0xc, %o1
4001df1c: 7f ff d6 88 call 4001393c <rtems_rfs_inode_close>
4001df20: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001df24: b6 92 20 00 orcc %o0, 0, %i3
4001df28: 34 80 00 28 bg,a 4001dfc8 <rtems_rfs_file_close+0x210>
<== NEVER TAKEN
4001df2c: 90 10 20 10 mov 0x10, %o0
<== NOT EXECUTED
4001df30: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
4001df34: c4 02 00 00 ld [ %o0 ], %g2
4001df38: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
4001df3c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
free (handle->shared);
4001df40: 7f ff ad 35 call 40009414 <free>
4001df44: c4 20 40 00 st %g2, [ %g1 ]
4001df48: 92 10 00 1c mov %i4, %o1
4001df4c: 7f ff f8 a1 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001df50: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001df54: c0 2e 60 04 clrb [ %i1 + 4 ]
if (rrc > 0)
4001df58: 80 a7 60 00 cmp %i5, 0
handle->bnum = 0;
4001df5c: c0 26 60 08 clr [ %i1 + 8 ]
4001df60: 04 bf ff ab ble 4001de0c <rtems_rfs_file_close+0x54>
<== ALWAYS TAKEN
4001df64: c0 26 60 0c clr [ %i1 + 0xc ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001df68: 90 10 20 10 mov 0x10, %o0
<== NOT EXECUTED
4001df6c: 7f ff dc 32 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001df70: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001df74: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001df78: 22 bf ff a6 be,a 4001de10 <rtems_rfs_file_close+0x58>
<== NOT EXECUTED
4001df7c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001df80: 40 00 13 83 call 40022d8c <strerror>
<== NOT EXECUTED
4001df84: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001df88: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001df8c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001df90: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001df94: 7f ff dc b5 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001df98: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 400336c0 <status_code_to_errno+0xf7c>
<== NOT EXECUTED
free (handle);
4001df9c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4001dfa0: 7f ff ad 1d call 40009414 <free>
<== NOT EXECUTED
4001dfa4: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4001dfa8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001dfac: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
4001dfb0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1
<== NOT EXECUTED
4001dfb4: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001dfb8: 7f ff dc ac call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001dfbc: 90 12 22 18 or %o0, 0x218, %o0 ! 40033618 <status_code_to_errno+0xed4>
<== NOT EXECUTED
if (handle->shared->references > 0)
4001dfc0: 10 bf ff 86 b 4001ddd8 <rtems_rfs_file_close+0x20>
<== NOT EXECUTED
4001dfc4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001dfc8: 7f ff dc 1b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001dfcc: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001dfd0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001dfd4: 32 80 00 23 bne,a 4001e060 <rtems_rfs_file_close+0x2a8>
<== NOT EXECUTED
4001dfd8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
4001dfdc: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
<== NOT EXECUTED
4001dfe0: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
if (rrc == 0)
4001dfe4: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001dfe8: 12 bf ff d5 bne 4001df3c <rtems_rfs_file_close+0x184>
<== NOT EXECUTED
4001dfec: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
4001dff0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
handle->buffer = NULL;
4001dff4: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
free (handle->shared);
4001dff8: 7f ff ad 07 call 40009414 <free>
<== NOT EXECUTED
4001dffc: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001e000: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001e004: 7f ff f8 73 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001e008: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->dirty = false;
4001e00c: c0 2e 60 04 clrb [ %i1 + 4 ]
<== NOT EXECUTED
handle->bnum = 0;
4001e010: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
handle->buffer = NULL;
4001e014: 10 bf ff d5 b 4001df68 <rtems_rfs_file_close+0x1b0>
<== NOT EXECUTED
4001e018: c0 26 60 0c clr [ %i1 + 0xc ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001e01c: 7f ff dc 06 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001e020: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001e024: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001e028: 32 80 00 19 bne,a 4001e08c <rtems_rfs_file_close+0x2d4>
<== NOT EXECUTED
4001e02c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
if (rrc == 0)
4001e030: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001e034: 22 bf ff b8 be,a 4001df14 <rtems_rfs_file_close+0x15c>
<== NOT EXECUTED
4001e038: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001e03c: 10 bf ff b7 b 4001df18 <rtems_rfs_file_close+0x160>
<== NOT EXECUTED
4001e040: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
<== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
4001e044: 7f ff d5 9a call 400136ac <rtems_rfs_inode_load>
4001e048: 90 10 00 18 mov %i0, %o0
if (rrc == 0)
4001e04c: 80 a2 20 00 cmp %o0, 0
4001e050: 12 80 00 20 bne 4001e0d0 <rtems_rfs_file_close+0x318>
<== NEVER TAKEN
4001e054: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001e058: 10 bf ff 76 b 4001de30 <rtems_rfs_file_close+0x78>
4001e05c: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
4001e060: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
<== NOT EXECUTED
4001e064: 40 00 13 4a call 40022d8c <strerror>
<== NOT EXECUTED
4001e068: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4001e06c: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4001e070: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001e074: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001e078: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e07c: 7f ff dc 7b call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e080: 90 12 22 80 or %o0, 0x280, %o0 ! 40033680 <status_code_to_errno+0xf3c>
<== NOT EXECUTED
4001e084: 10 bf ff d7 b 4001dfe0 <rtems_rfs_file_close+0x228>
<== NOT EXECUTED
4001e088: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
<== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
4001e08c: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
<== NOT EXECUTED
4001e090: 40 00 13 3f call 40022d8c <strerror>
<== NOT EXECUTED
4001e094: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4001e098: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4001e09c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001e0a0: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001e0a4: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e0a8: 7f ff dc 70 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e0ac: 90 12 22 40 or %o0, 0x240, %o0 ! 40033640 <status_code_to_errno+0xefc>
<== NOT EXECUTED
if (rrc == 0)
4001e0b0: 10 bf ff e1 b 4001e034 <rtems_rfs_file_close+0x27c>
<== NOT EXECUTED
4001e0b4: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001e0b8: c6 02 60 40 ld [ %o1 + 0x40 ], %g3
4001e0bc: 80 a0 80 03 cmp %g2, %g3
4001e0c0: 32 bf ff 8c bne,a 4001def0 <rtems_rfs_file_close+0x138>
<== NEVER TAKEN
4001e0c4: c2 22 60 3c st %g1, [ %o1 + 0x3c ]
<== NOT EXECUTED
4001e0c8: 10 bf ff 8e b 4001df00 <rtems_rfs_file_close+0x148>
4001e0cc: 92 02 60 34 add %o1, 0x34, %o1
if (rrc == 0)
4001e0d0: 10 bf ff 8b b 4001defc <rtems_rfs_file_close+0x144>
<== NOT EXECUTED
4001e0d4: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
4001ea88 <rtems_rfs_file_get_shared>:
return _Chain_Immutable_head( the_chain )->next;
4001ea88: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
return &the_chain->Tail.Node;
4001ea8c: 90 02 20 78 add %o0, 0x78, %o0
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001ea90: 80 a0 40 08 cmp %g1, %o0
4001ea94: 22 80 00 10 be,a 4001ead4 <rtems_rfs_file_get_shared+0x4c>
4001ea98: 82 10 20 00 clr %g1
if (shared->inode.ino == ino)
4001ea9c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4001eaa0: 80 a2 40 02 cmp %o1, %g2
4001eaa4: 32 80 00 08 bne,a 4001eac4 <rtems_rfs_file_get_shared+0x3c>
<== NEVER TAKEN
4001eaa8: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
4001eaac: 81 c3 e0 08 retl
4001eab0: 90 10 00 01 mov %g1, %o0
if (shared->inode.ino == ino)
4001eab4: 80 a0 80 09 cmp %g2, %o1
<== NOT EXECUTED
4001eab8: 22 80 00 08 be,a 4001ead8 <rtems_rfs_file_get_shared+0x50>
<== NOT EXECUTED
4001eabc: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4001eac0: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001eac4: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4001eac8: 32 bf ff fb bne,a 4001eab4 <rtems_rfs_file_get_shared+0x2c>
<== NOT EXECUTED
4001eacc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
<== NOT EXECUTED
return NULL;
4001ead0: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4001ead4: 90 10 00 01 mov %g1, %o0
4001ead8: 81 c3 e0 08 retl
4001eadc: 01 00 00 00 nop
4001e364 <rtems_rfs_file_io_end>:
{
4001e364: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e368: 90 10 20 20 mov 0x20, %o0
4001e36c: 92 10 20 00 clr %o1
4001e370: 7f ff db 31 call 40015034 <rtems_rfs_trace>
4001e374: ba 10 00 18 mov %i0, %i5
4001e378: 80 a2 20 00 cmp %o0, 0
4001e37c: 22 80 00 0c be,a 4001e3ac <rtems_rfs_file_io_end+0x48>
<== ALWAYS TAKEN
4001e380: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001e384: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001e388: 12 80 00 35 bne 4001e45c <rtems_rfs_file_io_end+0xf8>
<== NOT EXECUTED
4001e38c: 13 10 00 ca sethi %hi(0x40032800), %o1
<== NOT EXECUTED
4001e390: 13 10 00 cd sethi %hi(0x40033400), %o1
<== NOT EXECUTED
4001e394: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 400336e8 <status_code_to_errno+0xfa4>
<== NOT EXECUTED
4001e398: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e39c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001e3a0: 7f ff db b2 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e3a4: 90 12 23 a8 or %o0, 0x3a8, %o0
<== NOT EXECUTED
4001e3a8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001e3ac: c4 07 60 0c ld [ %i5 + 0xc ], %g2
4001e3b0: 80 a0 a0 00 cmp %g2, 0
4001e3b4: 02 80 00 2c be 4001e464 <rtems_rfs_file_io_end+0x100>
<== NEVER TAKEN
4001e3b8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (!read)
4001e3bc: 80 a6 a0 00 cmp %i2, 0
4001e3c0: 02 80 00 14 be 4001e410 <rtems_rfs_file_io_end+0xac>
4001e3c4: 92 07 60 04 add %i5, 4, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001e3c8: 7f ff f7 82 call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001e3cc: 01 00 00 00 nop
if (rc > 0)
4001e3d0: b0 92 20 00 orcc %o0, 0, %i0
4001e3d4: 24 80 00 9b ble,a 4001e640 <rtems_rfs_file_io_end+0x2dc>
<== ALWAYS TAKEN
4001e3d8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
printf (
4001e3dc: 40 00 12 6c call 40022d8c <strerror>
<== NOT EXECUTED
4001e3e0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001e3e4: 3b 10 00 ca sethi %hi(0x40032800), %i5
<== NOT EXECUTED
4001e3e8: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001e3ec: ba 17 62 00 or %i5, 0x200, %i5
<== NOT EXECUTED
4001e3f0: 96 10 00 18 mov %i0, %o3
<== NOT EXECUTED
4001e3f4: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001e3f8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001e3fc: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e400: 7f ff db 9a call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e404: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 400337d0 <status_code_to_errno+0x108c>
<== NOT EXECUTED
return rc;
4001e408: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e40c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001e410: 82 10 20 01 mov 1, %g1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001e414: 7f ff f7 6f call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001e418: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
if (rc > 0)
4001e41c: b0 92 20 00 orcc %o0, 0, %i0
4001e420: 24 80 00 49 ble,a 4001e544 <rtems_rfs_file_io_end+0x1e0>
<== ALWAYS TAKEN
4001e424: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
printf (
4001e428: 40 00 12 59 call 40022d8c <strerror>
<== NOT EXECUTED
4001e42c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001e430: 3b 10 00 cd sethi %hi(0x40033400), %i5
<== NOT EXECUTED
4001e434: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001e438: ba 17 62 e8 or %i5, 0x2e8, %i5
<== NOT EXECUTED
4001e43c: 96 10 00 18 mov %i0, %o3
<== NOT EXECUTED
4001e440: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001e444: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001e448: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e44c: 7f ff db 87 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e450: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 400337d0 <status_code_to_errno+0x108c>
<== NOT EXECUTED
return rc;
4001e454: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e458: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001e45c: 10 bf ff cf b 4001e398 <rtems_rfs_file_io_end+0x34>
<== NOT EXECUTED
4001e460: 92 12 62 00 or %o1, 0x200, %o1
<== NOT EXECUTED
handle->bpos.boff += size;
4001e464: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
4001e468: b2 06 40 02 add %i1, %g2, %i1
<== NOT EXECUTED
4001e46c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
<== NOT EXECUTED
4001e470: 86 1e a0 01 xor %i2, 1, %g3
<== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e474: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
if (handle->bpos.boff >=
4001e478: 80 a6 40 02 cmp %i1, %g2
<== NOT EXECUTED
4001e47c: 1a 80 00 3a bcc 4001e564 <rtems_rfs_file_io_end+0x200>
<== NOT EXECUTED
4001e480: b0 10 20 00 clr %i0
<== NOT EXECUTED
if (!read &&
4001e484: 80 a6 a0 00 cmp %i2, 0
4001e488: 12 80 00 0e bne 4001e4c0 <rtems_rfs_file_io_end+0x15c>
<== NEVER TAKEN
4001e48c: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001e490: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if (!read &&
4001e494: 80 a7 20 00 cmp %i4, 0
4001e498: 02 80 00 39 be 4001e57c <rtems_rfs_file_io_end+0x218>
4001e49c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001e4a0: 80 a0 a0 00 cmp %g2, 0
4001e4a4: 12 80 00 37 bne 4001e580 <rtems_rfs_file_io_end+0x21c>
<== ALWAYS TAKEN
4001e4a8: 80 a7 00 02 cmp %i4, %g2
4001e4ac: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
<== NOT EXECUTED
map->size.offset = offset;
4001e4b0: c8 20 60 40 st %g4, [ %g1 + 0x40 ]
map->dirty = true;
4001e4b4: 88 10 20 01 mov 1, %g4
4001e4b8: c8 28 60 34 stb %g4, [ %g1 + 0x34 ]
length = true;
4001e4bc: 84 10 20 01 mov 1, %g2
atime = rtems_rfs_file_update_atime (handle);
4001e4c0: e0 07 40 00 ld [ %i5 ], %l0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e4c4: 90 10 20 20 mov 0x20, %o0
4001e4c8: 92 10 20 00 clr %o1
atime = rtems_rfs_file_update_atime (handle);
4001e4cc: b2 38 00 10 xnor %g0, %l0, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001e4d0: b9 34 20 01 srl %l0, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001e4d4: b7 34 20 02 srl %l0, 2, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001e4d8: b8 1f 20 01 xor %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001e4dc: b6 1e e0 01 xor %i3, 1, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001e4e0: b8 0f 20 01 and %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001e4e4: b6 0e e0 01 and %i3, 1, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001e4e8: b8 0f 00 03 and %i4, %g3, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001e4ec: b6 0e c0 02 and %i3, %g2, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e4f0: 7f ff da d1 call 40015034 <rtems_rfs_trace>
4001e4f4: b2 0e 60 01 and %i1, 1, %i1
4001e4f8: 80 a2 20 00 cmp %o0, 0
4001e4fc: 32 80 00 30 bne,a 4001e5bc <rtems_rfs_file_io_end+0x258>
<== NEVER TAKEN
4001e500: d4 07 60 14 ld [ %i5 + 0x14 ], %o2
<== NOT EXECUTED
4001e504: b8 0f 20 ff and %i4, 0xff, %i4
4001e508: b6 0e e0 ff and %i3, 0xff, %i3
if (atime || mtime)
4001e50c: b2 8e 60 ff andcc %i1, 0xff, %i1
4001e510: 12 80 00 3d bne 4001e604 <rtems_rfs_file_io_end+0x2a0>
<== ALWAYS TAKEN
4001e514: 80 a7 20 00 cmp %i4, 0
4001e518: 12 80 00 3b bne 4001e604 <rtems_rfs_file_io_end+0x2a0>
<== NOT EXECUTED
4001e51c: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
if (length)
4001e520: 02 80 00 25 be 4001e5b4 <rtems_rfs_file_io_end+0x250>
4001e524: 01 00 00 00 nop
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
4001e528: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->shared->size.count =
4001e52c: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
handle->shared->size.offset =
4001e530: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
handle->shared->size.count =
4001e534: c6 20 60 84 st %g3, [ %g1 + 0x84 ]
handle->shared->size.offset =
4001e538: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
4001e53c: 81 c7 e0 08 ret
4001e540: 81 e8 00 00 restore
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e544: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->bpos.boff += size;
4001e548: b2 06 40 02 add %i1, %g2, %i1
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e54c: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
handle->bpos.boff += size;
4001e550: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e554: c4 00 a0 08 ld [ %g2 + 8 ], %g2
if (handle->bpos.boff >=
4001e558: 80 a0 80 19 cmp %g2, %i1
4001e55c: 18 bf ff cd bgu 4001e490 <rtems_rfs_file_io_end+0x12c>
4001e560: 86 10 20 01 mov 1, %g3
handle->bpos.bno++;
4001e564: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
4001e568: 88 01 20 01 inc %g4
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001e56c: b2 26 40 02 sub %i1, %g2, %i1
handle->bpos.bno++;
4001e570: c8 27 60 10 st %g4, [ %i5 + 0x10 ]
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001e574: 10 bf ff c4 b 4001e484 <rtems_rfs_file_io_end+0x120>
4001e578: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001e57c: 80 a7 00 02 cmp %i4, %g2
4001e580: 3a bf ff cc bcc,a 4001e4b0 <rtems_rfs_file_io_end+0x14c>
4001e584: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
4001e588: 88 00 bf ff add %g2, -1, %g4
4001e58c: 80 a7 00 04 cmp %i4, %g4
4001e590: 12 bf ff cc bne 4001e4c0 <rtems_rfs_file_io_end+0x15c>
<== NEVER TAKEN
4001e594: 84 10 20 00 clr %g2
4001e598: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
4001e59c: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
4001e5a0: 80 a1 00 1c cmp %g4, %i4
4001e5a4: 28 bf ff c8 bleu,a 4001e4c4 <rtems_rfs_file_io_end+0x160>
<== NEVER TAKEN
4001e5a8: e0 07 40 00 ld [ %i5 ], %l0
<== NOT EXECUTED
4001e5ac: 10 bf ff c2 b 4001e4b4 <rtems_rfs_file_io_end+0x150>
4001e5b0: c8 20 60 40 st %g4, [ %g1 + 0x40 ]
}
4001e5b4: 81 c7 e0 08 ret
4001e5b8: 81 e8 00 00 restore
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
4001e5bc: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
<== NOT EXECUTED
4001e5c0: 96 0c 20 01 and %l0, 1, %o3
<== NOT EXECUTED
4001e5c4: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
4001e5c8: b6 0e e0 ff and %i3, 0xff, %i3
<== NOT EXECUTED
4001e5cc: 98 07 3f ff add %i4, -1, %o4
<== NOT EXECUTED
4001e5d0: 9a 06 ff ff add %i3, -1, %o5
<== NOT EXECUTED
4001e5d4: 96 20 00 0b neg %o3
<== NOT EXECUTED
4001e5d8: 98 0b 3f e0 and %o4, -32, %o4
<== NOT EXECUTED
4001e5dc: 96 0a ff ec and %o3, -20, %o3
<== NOT EXECUTED
4001e5e0: 98 03 20 4d add %o4, 0x4d, %o4
<== NOT EXECUTED
4001e5e4: 9a 0b 7f e1 and %o5, -31, %o5
<== NOT EXECUTED
4001e5e8: 96 02 e0 41 add %o3, 0x41, %o3
<== NOT EXECUTED
4001e5ec: 9a 03 60 4c add %o5, 0x4c, %o5
<== NOT EXECUTED
4001e5f0: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001e5f4: 7f ff db 1d call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e5f8: 90 12 20 18 or %o0, 0x18, %o0 ! 40033818 <status_code_to_errno+0x10d4>
<== NOT EXECUTED
if (atime || mtime)
4001e5fc: 10 bf ff c5 b 4001e510 <rtems_rfs_file_io_end+0x1ac>
<== NOT EXECUTED
4001e600: b2 8e 60 ff andcc %i1, 0xff, %i1
<== NOT EXECUTED
time_t now = time (NULL);
4001e604: 40 00 1e 01 call 40025e08 <time>
4001e608: 90 10 20 00 clr %o0
if (read && atime)
4001e60c: 80 a6 a0 00 cmp %i2, 0
4001e610: 02 80 00 06 be 4001e628 <rtems_rfs_file_io_end+0x2c4>
4001e614: 80 a6 60 00 cmp %i1, 0
4001e618: 02 80 00 05 be 4001e62c <rtems_rfs_file_io_end+0x2c8>
<== NEVER TAKEN
4001e61c: 80 a7 20 00 cmp %i4, 0
handle->shared->atime = now;
4001e620: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001e624: d2 20 60 8c st %o1, [ %g1 + 0x8c ]
if (!read && mtime)
4001e628: 80 a7 20 00 cmp %i4, 0
4001e62c: 02 bf ff bd be 4001e520 <rtems_rfs_file_io_end+0x1bc>
4001e630: 80 a6 e0 00 cmp %i3, 0
handle->shared->mtime = now;
4001e634: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001e638: 10 bf ff ba b 4001e520 <rtems_rfs_file_io_end+0x1bc>
4001e63c: d2 20 60 90 st %o1, [ %g1 + 0x90 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e640: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->bpos.boff += size;
4001e644: b2 06 40 02 add %i1, %g2, %i1
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e648: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
handle->bpos.boff += size;
4001e64c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001e650: c4 00 a0 08 ld [ %g2 + 8 ], %g2
if (handle->bpos.boff >=
4001e654: 80 a6 40 02 cmp %i1, %g2
4001e658: 1a bf ff c3 bcc 4001e564 <rtems_rfs_file_io_end+0x200>
<== NEVER TAKEN
4001e65c: 86 10 20 00 clr %g3
length = false;
4001e660: 10 bf ff 98 b 4001e4c0 <rtems_rfs_file_io_end+0x15c>
4001e664: 84 10 20 00 clr %g2
4001e0d8 <rtems_rfs_file_io_start>:
{
4001e0d8: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e0dc: 90 10 20 20 mov 0x20, %o0
4001e0e0: 92 10 20 00 clr %o1
4001e0e4: 7f ff db d4 call 40015034 <rtems_rfs_trace>
4001e0e8: ba 10 00 18 mov %i0, %i5
4001e0ec: 80 a2 20 00 cmp %o0, 0
4001e0f0: 22 80 00 0d be,a 4001e124 <rtems_rfs_file_io_start+0x4c>
<== ALWAYS TAKEN
4001e0f4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001e0f8: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001e0fc: 22 80 00 2f be,a 4001e1b8 <rtems_rfs_file_io_start+0xe0>
<== NOT EXECUTED
4001e100: 13 10 00 cd sethi %hi(0x40033400), %o1
<== NOT EXECUTED
4001e104: 13 10 00 ca sethi %hi(0x40032800), %o1
<== NOT EXECUTED
4001e108: 92 12 62 00 or %o1, 0x200, %o1 ! 40032a00 <status_code_to_errno+0x2bc>
<== NOT EXECUTED
4001e10c: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
<== NOT EXECUTED
4001e110: d4 07 60 10 ld [ %i5 + 0x10 ], %o2
<== NOT EXECUTED
4001e114: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e118: 7f ff dc 54 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e11c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 400336f0 <status_code_to_errno+0xfac>
<== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001e120: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4001e124: 80 a0 60 00 cmp %g1, 0
4001e128: 02 80 00 30 be 4001e1e8 <rtems_rfs_file_io_start+0x110>
<== ALWAYS TAKEN
4001e12c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
if (read
4001e130: 80 a6 a0 00 cmp %i2, 0
4001e134: 22 80 00 0e be,a 4001e16c <rtems_rfs_file_io_start+0x94>
4001e138: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001e13c: c4 02 60 44 ld [ %o1 + 0x44 ], %g2
4001e140: 80 a0 a0 00 cmp %g2, 0
4001e144: 12 80 00 1f bne 4001e1c0 <rtems_rfs_file_io_start+0xe8>
<== NEVER TAKEN
4001e148: c2 02 60 3c ld [ %o1 + 0x3c ], %g1
4001e14c: 80 a0 60 00 cmp %g1, 0
4001e150: 12 80 00 1d bne 4001e1c4 <rtems_rfs_file_io_start+0xec>
<== ALWAYS TAKEN
4001e154: 82 00 7f ff add %g1, -1, %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001e158: f8 02 60 40 ld [ %o1 + 0x40 ], %i4
<== NOT EXECUTED
4001e15c: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4001e160: 32 80 00 05 bne,a 4001e174 <rtems_rfs_file_io_start+0x9c>
<== NOT EXECUTED
4001e164: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001e168: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
<== NOT EXECUTED
4001e16c: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
4001e170: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001e174: 82 27 00 01 sub %i4, %g1, %g1
4001e178: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e17c: 90 10 20 20 mov 0x20, %o0
4001e180: 92 10 20 00 clr %o1
4001e184: 7f ff db ac call 40015034 <rtems_rfs_trace>
4001e188: b0 10 20 00 clr %i0
4001e18c: 80 a2 20 00 cmp %o0, 0
4001e190: 32 80 00 04 bne,a 4001e1a0 <rtems_rfs_file_io_start+0xc8>
<== NEVER TAKEN
4001e194: d2 06 40 00 ld [ %i1 ], %o1
<== NOT EXECUTED
}
4001e198: 81 c7 e0 08 ret
4001e19c: 81 e8 00 00 restore
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
4001e1a0: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001e1a4: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e1a8: 7f ff dc 30 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e1ac: 90 12 23 78 or %o0, 0x378, %o0 ! 40033778 <status_code_to_errno+0x1034>
<== NOT EXECUTED
}
4001e1b0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e1b4: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001e1b8: 10 bf ff d5 b 4001e10c <rtems_rfs_file_io_start+0x34>
<== NOT EXECUTED
4001e1bc: 92 12 62 e8 or %o1, 0x2e8, %o1
<== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001e1c0: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001e1c4: 80 a0 80 01 cmp %g2, %g1
4001e1c8: 32 bf ff e9 bne,a 4001e16c <rtems_rfs_file_io_start+0x94>
<== NEVER TAKEN
4001e1cc: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
<== NOT EXECUTED
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001e1d0: f8 02 60 40 ld [ %o1 + 0x40 ], %i4
4001e1d4: 80 a7 20 00 cmp %i4, 0
4001e1d8: 32 bf ff e7 bne,a 4001e174 <rtems_rfs_file_io_start+0x9c>
<== ALWAYS TAKEN
4001e1dc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001e1e0: 10 bf ff e3 b 4001e16c <rtems_rfs_file_io_start+0x94>
<== NOT EXECUTED
4001e1e4: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
<== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001e1e8: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001e1ec: 94 07 60 10 add %i5, 0x10, %o2
4001e1f0: 96 07 bf fc add %fp, -4, %o3
4001e1f4: 7f ff f3 e8 call 4001b194 <rtems_rfs_block_map_find>
4001e1f8: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001e1fc: b0 92 20 00 orcc %o0, 0, %i0
4001e200: 04 80 00 0b ble 4001e22c <rtems_rfs_file_io_start+0x154>
4001e204: 82 1e 20 06 xor %i0, 6, %g1
if (read && (rc == ENXIO))
4001e208: 80 a0 00 01 cmp %g0, %g1
4001e20c: 82 60 3f ff subx %g0, -1, %g1
4001e210: 82 0e 80 01 and %i2, %g1, %g1
4001e214: 80 a0 60 00 cmp %g1, 0
4001e218: 02 80 00 29 be 4001e2bc <rtems_rfs_file_io_start+0x1e4>
<== ALWAYS TAKEN
4001e21c: b8 10 00 01 mov %g1, %i4
*available = 0;
4001e220: c0 26 40 00 clr [ %i1 ]
<== NOT EXECUTED
return 0;
4001e224: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e228: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
if (!read &&
4001e22c: 80 a6 a0 00 cmp %i2, 0
4001e230: 12 80 00 3d bne 4001e324 <rtems_rfs_file_io_start+0x24c>
4001e234: 90 10 20 20 mov 0x20, %o0
4001e238: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001e23c: 80 a0 60 00 cmp %g1, 0
4001e240: 12 80 00 3a bne 4001e328 <rtems_rfs_file_io_start+0x250>
<== ALWAYS TAKEN
4001e244: 92 10 20 00 clr %o1
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001e248: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4001e24c: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
<== NOT EXECUTED
(rtems_rfs_file_block_offset (handle) ||
4001e250: c4 06 40 00 ld [ %i1 ], %g2
<== NOT EXECUTED
4001e254: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4001e258: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001e25c: 0a 80 00 33 bcs 4001e328 <rtems_rfs_file_io_start+0x250>
<== NOT EXECUTED
4001e260: 01 00 00 00 nop
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e264: 7f ff db 74 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001e268: 01 00 00 00 nop
<== NOT EXECUTED
4001e26c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001e270: 02 80 00 08 be 4001e290 <rtems_rfs_file_io_start+0x1b8>
<== NOT EXECUTED
4001e274: b8 10 20 00 clr %i4
<== NOT EXECUTED
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001e278: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4001e27c: 15 10 00 c2 sethi %hi(0x40030800), %o2
<== NOT EXECUTED
4001e280: 94 12 a0 d8 or %o2, 0xd8, %o2 ! 400308d8 <__func__.8600+0x1c0>
<== NOT EXECUTED
4001e284: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001e288: 7f ff db f8 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e28c: 90 12 23 40 or %o0, 0x340, %o0 ! 40033740 <status_code_to_errno+0xffc>
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001e290: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001e294: d4 07 bf fc ld [ %fp + -4 ], %o2
4001e298: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001e29c: 96 0f 20 ff and %i4, 0xff, %o3
4001e2a0: 7f ff f7 05 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001e2a4: 92 07 60 04 add %i5, 4, %o1
if (rc > 0)
4001e2a8: b0 92 20 00 orcc %o0, 0, %i0
4001e2ac: 14 bf ff c1 bg 4001e1b0 <rtems_rfs_file_io_start+0xd8>
<== NEVER TAKEN
4001e2b0: 01 00 00 00 nop
4001e2b4: 10 bf ff 9f b 4001e130 <rtems_rfs_file_io_start+0x58>
4001e2b8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
if (rc != ENXIO)
4001e2bc: 80 a6 20 06 cmp %i0, 6
4001e2c0: 12 bf ff b6 bne 4001e198 <rtems_rfs_file_io_start+0xc0>
<== NEVER TAKEN
4001e2c4: 90 10 20 20 mov 0x20, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e2c8: 7f ff db 5b call 40015034 <rtems_rfs_trace>
4001e2cc: 92 10 20 00 clr %o1
4001e2d0: 80 a2 20 00 cmp %o0, 0
4001e2d4: 12 80 00 20 bne 4001e354 <rtems_rfs_file_io_start+0x27c>
<== NEVER TAKEN
4001e2d8: 11 10 00 cd sethi %hi(0x40033400), %o0
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001e2dc: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001e2e0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001e2e4: 96 07 bf fc add %fp, -4, %o3
4001e2e8: 94 10 20 01 mov 1, %o2
4001e2ec: 7f ff f4 2e call 4001b3a4 <rtems_rfs_block_map_grow>
4001e2f0: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001e2f4: b0 92 20 00 orcc %o0, 0, %i0
4001e2f8: 14 bf ff a8 bg 4001e198 <rtems_rfs_file_io_start+0xc0>
4001e2fc: 90 10 20 20 mov 0x20, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e300: 7f ff db 4d call 40015034 <rtems_rfs_trace>
4001e304: 92 10 20 00 clr %o1
4001e308: 80 a2 20 00 cmp %o0, 0
4001e30c: 22 bf ff e1 be,a 4001e290 <rtems_rfs_file_io_start+0x1b8>
<== ALWAYS TAKEN
4001e310: b8 10 20 00 clr %i4
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001e314: 15 10 00 c2 sethi %hi(0x40030800), %o2
<== NOT EXECUTED
4001e318: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4001e31c: 10 bf ff da b 4001e284 <rtems_rfs_file_io_start+0x1ac>
<== NOT EXECUTED
4001e320: 94 12 a0 d8 or %o2, 0xd8, %o2
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e324: 92 10 20 00 clr %o1
4001e328: 7f ff db 43 call 40015034 <rtems_rfs_trace>
4001e32c: 01 00 00 00 nop
4001e330: 80 a2 20 00 cmp %o0, 0
4001e334: 02 80 00 06 be 4001e34c <rtems_rfs_file_io_start+0x274>
<== ALWAYS TAKEN
4001e338: b8 10 00 08 mov %o0, %i4
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001e33c: 15 10 00 c8 sethi %hi(0x40032000), %o2
<== NOT EXECUTED
4001e340: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4001e344: 10 bf ff d0 b 4001e284 <rtems_rfs_file_io_start+0x1ac>
<== NOT EXECUTED
4001e348: 94 12 a2 70 or %o2, 0x270, %o2
<== NOT EXECUTED
4001e34c: 10 bf ff d1 b 4001e290 <rtems_rfs_file_io_start+0x1b8>
4001e350: b8 10 20 01 mov 1, %i4
printf ("rtems-rfs: file-io: start: grow\n");
4001e354: 7f ff db d4 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001e358: 90 12 23 20 or %o0, 0x320, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001e35c: 10 bf ff e1 b 4001e2e0 <rtems_rfs_file_io_start+0x208>
<== NOT EXECUTED
4001e360: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
<== NOT EXECUTED
4001da90 <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)
{
4001da90: 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))
4001da94: 90 10 20 08 mov 8, %o0
4001da98: 92 10 20 00 clr %o1
4001da9c: 7f ff dd 66 call 40015034 <rtems_rfs_trace>
4001daa0: a2 10 00 18 mov %i0, %l1
4001daa4: 80 a2 20 00 cmp %o0, 0
4001daa8: 12 80 00 4d bne 4001dbdc <rtems_rfs_file_open+0x14c>
<== NEVER TAKEN
4001daac: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
4001dab0: 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));
4001dab4: 92 10 20 01 mov 1, %o1
4001dab8: 90 10 20 20 mov 0x20, %o0
4001dabc: 7f ff ad 87 call 400090d8 <calloc>
4001dac0: b0 10 20 0c mov 0xc, %i0
if (!handle)
4001dac4: 80 a2 20 00 cmp %o0, 0
4001dac8: 02 80 00 43 be 4001dbd4 <rtems_rfs_file_open+0x144>
<== NEVER TAKEN
4001dacc: b8 10 00 08 mov %o0, %i4
handle->dirty = false;
4001dad0: c0 2a 20 04 clrb [ %o0 + 4 ]
return &the_chain->Tail.Node;
4001dad4: a0 04 60 78 add %l1, 0x78, %l0
handle->bnum = 0;
4001dad8: c0 22 20 08 clr [ %o0 + 8 ]
handle->buffer = NULL;
4001dadc: c0 22 20 0c clr [ %o0 + 0xc ]
return _Chain_Immutable_head( the_chain )->next;
4001dae0: fa 04 60 74 ld [ %l1 + 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))
4001dae4: 80 a7 40 10 cmp %i5, %l0
4001dae8: 32 80 00 08 bne,a 4001db08 <rtems_rfs_file_open+0x78>
<== NEVER TAKEN
4001daec: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
4001daf0: 10 80 00 17 b 4001db4c <rtems_rfs_file_open+0xbc>
4001daf4: 92 10 20 01 mov 1, %o1
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001daf8: 80 a7 40 10 cmp %i5, %l0
<== NOT EXECUTED
4001dafc: 02 80 00 14 be 4001db4c <rtems_rfs_file_open+0xbc>
<== NOT EXECUTED
4001db00: 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)
4001db04: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4001db08: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
4001db0c: 32 bf ff fb bne,a 4001daf8 <rtems_rfs_file_open+0x68>
<== NOT EXECUTED
4001db10: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
shared->references++;
4001db14: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4001db18: 82 00 60 01 inc %g1
<== NOT EXECUTED
4001db1c: c2 27 60 08 st %g1, [ %i5 + 8 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001db20: 90 10 20 08 mov 8, %o0
<== NOT EXECUTED
4001db24: 7f ff dd 44 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001db28: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001db2c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001db30: 32 80 00 30 bne,a 4001dbf0 <rtems_rfs_file_open+0x160>
<== NOT EXECUTED
4001db34: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
handle->flags = oflag;
4001db38: f4 27 00 00 st %i2, [ %i4 ]
<== NOT EXECUTED
handle->shared = shared;
4001db3c: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
*file = handle;
4001db40: f8 26 c0 00 st %i4, [ %i3 ]
return 0;
4001db44: 81 c7 e0 08 ret
4001db48: 91 e8 20 00 restore %g0, 0, %o0
shared = malloc (sizeof (rtems_rfs_file_shared));
4001db4c: 90 10 20 9c mov 0x9c, %o0
4001db50: 7f ff ad 62 call 400090d8 <calloc>
4001db54: a4 07 20 04 add %i4, 4, %l2
if (!shared)
4001db58: 80 a2 20 00 cmp %o0, 0
4001db5c: 02 80 00 8f be 4001dd98 <rtems_rfs_file_open+0x308>
<== NEVER TAKEN
4001db60: ba 10 00 08 mov %o0, %i5
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4001db64: a6 07 60 0c add %i5, 0xc, %l3
4001db68: 96 10 20 01 mov 1, %o3
4001db6c: 94 10 00 13 mov %l3, %o2
4001db70: 92 10 00 19 mov %i1, %o1
4001db74: 7f ff d6 fb call 40013760 <rtems_rfs_inode_open>
4001db78: 90 10 00 11 mov %l1, %o0
if (rc > 0)
4001db7c: b0 92 20 00 orcc %o0, 0, %i0
4001db80: 04 80 00 25 ble 4001dc14 <rtems_rfs_file_open+0x184>
<== ALWAYS TAKEN
4001db84: 90 10 20 08 mov 8, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001db88: 7f ff dd 2b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001db8c: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001db90: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001db94: 02 80 00 09 be 4001dbb8 <rtems_rfs_file_open+0x128>
<== NOT EXECUTED
4001db98: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
4001db9c: 40 00 14 7c call 40022d8c <strerror>
<== NOT EXECUTED
4001dba0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001dba4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001dba8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001dbac: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001dbb0: 7f ff dd ae call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001dbb4: 90 12 21 78 or %o0, 0x178, %o0 ! 40033578 <status_code_to_errno+0xe34>
<== NOT EXECUTED
free (shared);
4001dbb8: 7f ff ae 17 call 40009414 <free>
<== NOT EXECUTED
4001dbbc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001dbc0: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001dbc4: 7f ff f9 83 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001dbc8: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
free (handle);
4001dbcc: 7f ff ae 12 call 40009414 <free>
<== NOT EXECUTED
4001dbd0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rc;
4001dbd4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001dbd8: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
4001dbdc: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001dbe0: 7f ff dd a2 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001dbe4: 90 12 21 30 or %o0, 0x130, %o0 ! 40033530 <status_code_to_errno+0xdec>
<== NOT EXECUTED
*file = NULL;
4001dbe8: 10 bf ff b3 b 4001dab4 <rtems_rfs_file_open+0x24>
<== NOT EXECUTED
4001dbec: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001dbf0: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
return 0;
4001dbf4: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001dbf8: 7f ff dd 9c call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001dbfc: 90 12 21 50 or %o0, 0x150, %o0
<== NOT EXECUTED
handle->flags = oflag;
4001dc00: f4 27 00 00 st %i2, [ %i4 ]
<== NOT EXECUTED
handle->shared = shared;
4001dc04: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
<== NOT EXECUTED
*file = handle;
4001dc08: f8 26 c0 00 st %i4, [ %i3 ]
<== NOT EXECUTED
return 0;
4001dc0c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001dc10: 81 e8 00 00 restore
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
4001dc14: 94 07 60 34 add %i5, 0x34, %o2
4001dc18: 92 10 00 13 mov %l3, %o1
4001dc1c: 7f ff f4 8c call 4001ae4c <rtems_rfs_block_map_open>
4001dc20: 90 10 00 11 mov %l1, %o0
if (rc > 0)
4001dc24: b0 92 20 00 orcc %o0, 0, %i0
4001dc28: 04 80 00 12 ble 4001dc70 <rtems_rfs_file_open+0x1e0>
<== ALWAYS TAKEN
4001dc2c: 90 10 20 08 mov 8, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001dc30: 7f ff dd 01 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001dc34: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001dc38: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001dc3c: 02 80 00 0a be 4001dc64 <rtems_rfs_file_open+0x1d4>
<== NOT EXECUTED
4001dc40: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001dc44: 40 00 14 52 call 40022d8c <strerror>
<== NOT EXECUTED
4001dc48: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001dc4c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001dc50: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001dc54: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001dc58: 7f ff dd 84 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001dc5c: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400335b0 <status_code_to_errno+0xe6c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
4001dc60: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
4001dc64: 7f ff d7 36 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001dc68: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4001dc6c: 30 bf ff d3 b,a 4001dbb8 <rtems_rfs_file_open+0x128>
<== NOT EXECUTED
shared->references = 1;
4001dc70: 82 10 20 01 mov 1, %g1
4001dc74: c2 27 60 08 st %g1, [ %i5 + 8 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001dc78: 94 10 20 00 clr %o2
4001dc7c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
return rtems_rfs_read_u32 (&handle->node->block_count);
4001dc80: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
4001dc84: f0 08 60 0c ldub [ %g1 + 0xc ], %i0
4001dc88: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4001dc8c: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
4001dc90: b1 2e 20 18 sll %i0, 0x18, %i0
4001dc94: 87 28 e0 10 sll %g3, 0x10, %g3
4001dc98: 85 28 a0 08 sll %g2, 8, %g2
4001dc9c: 86 10 c0 18 or %g3, %i0, %g3
4001dca0: 84 10 80 03 or %g2, %g3, %g2
4001dca4: 84 11 00 02 or %g4, %g2, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001dca8: c4 27 60 84 st %g2, [ %i5 + 0x84 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001dcac: 92 10 00 13 mov %l3, %o1
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001dcb0: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
4001dcb4: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001dcb8: 85 28 a0 08 sll %g2, 8, %g2
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001dcbc: 84 10 80 03 or %g2, %g3, %g2
4001dcc0: c4 27 60 88 st %g2, [ %i5 + 0x88 ]
return rtems_rfs_read_u32 (&handle->node->atime);
4001dcc4: c8 08 60 13 ldub [ %g1 + 0x13 ], %g4
4001dcc8: f0 08 60 10 ldub [ %g1 + 0x10 ], %i0
4001dccc: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
4001dcd0: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
4001dcd4: b1 2e 20 18 sll %i0, 0x18, %i0
4001dcd8: 87 28 e0 10 sll %g3, 0x10, %g3
4001dcdc: 85 28 a0 08 sll %g2, 8, %g2
4001dce0: 86 10 c0 18 or %g3, %i0, %g3
4001dce4: 84 10 80 03 or %g2, %g3, %g2
4001dce8: 84 11 00 02 or %g4, %g2, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001dcec: c4 27 60 8c st %g2, [ %i5 + 0x8c ]
return rtems_rfs_read_u32 (&handle->node->mtime);
4001dcf0: c8 08 60 17 ldub [ %g1 + 0x17 ], %g4
4001dcf4: f0 08 60 14 ldub [ %g1 + 0x14 ], %i0
4001dcf8: c6 08 60 15 ldub [ %g1 + 0x15 ], %g3
4001dcfc: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
4001dd00: b1 2e 20 18 sll %i0, 0x18, %i0
4001dd04: 87 28 e0 10 sll %g3, 0x10, %g3
4001dd08: 85 28 a0 08 sll %g2, 8, %g2
4001dd0c: 86 10 c0 18 or %g3, %i0, %g3
4001dd10: 84 10 80 03 or %g2, %g3, %g2
4001dd14: 84 11 00 02 or %g4, %g2, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
4001dd18: c4 27 60 90 st %g2, [ %i5 + 0x90 ]
return rtems_rfs_read_u32 (&handle->node->ctime);
4001dd1c: c8 08 60 1b ldub [ %g1 + 0x1b ], %g4
4001dd20: f0 08 60 18 ldub [ %g1 + 0x18 ], %i0
4001dd24: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
4001dd28: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
old_last = tail->previous;
4001dd2c: de 04 60 7c ld [ %l1 + 0x7c ], %o7
4001dd30: 87 28 e0 10 sll %g3, 0x10, %g3
4001dd34: 83 28 a0 08 sll %g2, 8, %g1
shared->fs = fs;
4001dd38: e2 27 60 98 st %l1, [ %i5 + 0x98 ]
4001dd3c: b1 2e 20 18 sll %i0, 0x18, %i0
the_node->next = tail;
4001dd40: e0 27 40 00 st %l0, [ %i5 ]
4001dd44: 84 10 c0 18 or %g3, %i0, %g2
tail->previous = the_node;
4001dd48: fa 24 60 7c st %i5, [ %l1 + 0x7c ]
4001dd4c: 82 10 40 02 or %g1, %g2, %g1
4001dd50: 82 11 00 01 or %g4, %g1, %g1
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
4001dd54: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
old_last->next = the_node;
4001dd58: fa 23 c0 00 st %i5, [ %o7 ]
the_node->previous = old_last;
4001dd5c: de 27 60 04 st %o7, [ %i5 + 4 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001dd60: 7f ff d6 b9 call 40013844 <rtems_rfs_inode_unload>
4001dd64: 90 10 00 11 mov %l1, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001dd68: 90 10 20 08 mov 8, %o0
4001dd6c: 7f ff dc b2 call 40015034 <rtems_rfs_trace>
4001dd70: 92 10 20 00 clr %o1
4001dd74: 80 a2 20 00 cmp %o0, 0
4001dd78: 22 bf ff 71 be,a 4001db3c <rtems_rfs_file_open+0xac>
<== ALWAYS TAKEN
4001dd7c: f4 27 00 00 st %i2, [ %i4 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001dd80: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001dd84: 11 10 00 cd sethi %hi(0x40033400), %o0
<== NOT EXECUTED
4001dd88: 7f ff dd 38 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001dd8c: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 400335e8 <status_code_to_errno+0xea4>
<== NOT EXECUTED
handle->flags = oflag;
4001dd90: 10 bf ff 6b b 4001db3c <rtems_rfs_file_open+0xac>
<== NOT EXECUTED
4001dd94: f4 27 00 00 st %i2, [ %i4 ]
<== NOT EXECUTED
4001dd98: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001dd9c: 7f ff f9 0d call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001dda0: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
return ENOMEM;
4001dda4: b0 10 20 0c mov 0xc, %i0
<== NOT EXECUTED
free (handle);
4001dda8: 7f ff ad 9b call 40009414 <free>
<== NOT EXECUTED
4001ddac: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return ENOMEM;
4001ddb0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001ddb4: 81 e8 00 00 restore
<== NOT EXECUTED
4001e668 <rtems_rfs_file_seek>:
{
4001e668: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e66c: 90 10 20 20 mov 0x20, %o0
4001e670: 92 10 20 00 clr %o1
4001e674: 7f ff da 70 call 40015034 <rtems_rfs_trace>
4001e678: ba 10 00 18 mov %i0, %i5
4001e67c: 80 a2 20 00 cmp %o0, 0
4001e680: 32 80 00 35 bne,a 4001e754 <rtems_rfs_file_seek+0xec>
<== NEVER TAKEN
4001e684: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001e688: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001e68c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001e690: 7f ff f1 dc call 4001ae00 <rtems_rfs_block_get_size>
4001e694: 92 02 60 84 add %o1, 0x84, %o1
4001e698: 80 a6 40 08 cmp %i1, %o0
4001e69c: 08 80 00 0f bleu 4001e6d8 <rtems_rfs_file_seek+0x70>
<== ALWAYS TAKEN
4001e6a0: 01 00 00 00 nop
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001e6a4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4001e6a8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001e6ac: 22 80 00 27 be,a 4001e748 <rtems_rfs_file_seek+0xe0>
<== NOT EXECUTED
4001e6b0: f2 26 c0 00 st %i1, [ %i3 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001e6b4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4001e6b8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
<== NOT EXECUTED
4001e6bc: 7f ff f6 c5 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001e6c0: 92 07 60 04 add %i5, 4, %o1
<== NOT EXECUTED
if (rc > 0)
4001e6c4: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4001e6c8: 24 80 00 20 ble,a 4001e748 <rtems_rfs_file_seek+0xe0>
<== NOT EXECUTED
4001e6cc: f2 26 c0 00 st %i1, [ %i3 ]
<== NOT EXECUTED
}
4001e6d0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e6d4: 81 e8 00 00 restore
<== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001e6d8: 12 80 00 04 bne 4001e6e8 <rtems_rfs_file_seek+0x80>
<== NEVER TAKEN
4001e6dc: 80 a6 80 09 cmp %i2, %o1
4001e6e0: 38 bf ff f2 bgu,a 4001e6a8 <rtems_rfs_file_seek+0x40>
<== NEVER TAKEN
4001e6e4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
rtems_rfs_file_set_bpos (handle, pos);
4001e6e8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001e6ec: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001e6f0: b8 07 60 10 add %i5, 0x10, %i4
4001e6f4: 92 10 00 19 mov %i1, %o1
4001e6f8: 96 10 00 1c mov %i4, %o3
4001e6fc: 7f ff f1 aa call 4001ada4 <rtems_rfs_block_get_bpos>
4001e700: 94 10 00 1a mov %i2, %o2
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001e704: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001e708: 80 a0 60 00 cmp %g1, 0
4001e70c: 02 80 00 0e be 4001e744 <rtems_rfs_file_seek+0xdc>
<== ALWAYS TAKEN
4001e710: 96 07 bf fc add %fp, -4, %o3
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001e714: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
<== NOT EXECUTED
4001e718: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
<== NOT EXECUTED
4001e71c: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001e720: 7f ff f2 9d call 4001b194 <rtems_rfs_block_map_find>
<== NOT EXECUTED
4001e724: 92 02 60 34 add %o1, 0x34, %o1
<== NOT EXECUTED
if (rc > 0)
4001e728: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4001e72c: 14 bf ff e9 bg 4001e6d0 <rtems_rfs_file_seek+0x68>
<== NOT EXECUTED
4001e730: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
4001e734: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001e738: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001e73c: 32 bf ff df bne,a 4001e6b8 <rtems_rfs_file_seek+0x50>
<== NOT EXECUTED
4001e740: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
*new_pos = pos;
4001e744: f2 26 c0 00 st %i1, [ %i3 ]
4001e748: f4 26 e0 04 st %i2, [ %i3 + 4 ]
}
4001e74c: 81 c7 e0 08 ret
4001e750: 91 e8 20 00 restore %g0, 0, %o0
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
4001e754: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001e758: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001e75c: 7f ff da c3 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e760: 90 12 20 50 or %o0, 0x50, %o0 ! 40033850 <status_code_to_errno+0x110c>
<== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001e764: 10 bf ff ca b 4001e68c <rtems_rfs_file_seek+0x24>
<== NOT EXECUTED
4001e768: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
<== NOT EXECUTED
4001e76c <rtems_rfs_file_set_size>:
{
4001e76c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e770: 90 10 20 20 mov 0x20, %o0
<== NOT EXECUTED
4001e774: 92 10 20 00 clr %o1
<== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001e778: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e77c: 7f ff da 2e call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001e780: a4 10 00 19 mov %i1, %l2
<== NOT EXECUTED
4001e784: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001e788: 12 80 00 54 bne 4001e8d8 <rtems_rfs_file_set_size+0x16c>
<== NOT EXECUTED
4001e78c: a6 10 00 1a mov %i2, %l3
<== NOT EXECUTED
size = rtems_rfs_file_size (handle);
4001e790: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
<== NOT EXECUTED
4001e794: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
<== NOT EXECUTED
4001e798: 7f ff f1 9a call 4001ae00 <rtems_rfs_block_get_size>
<== NOT EXECUTED
4001e79c: 92 02 60 84 add %o1, 0x84, %o1
<== NOT EXECUTED
if (size != new_size)
4001e7a0: 80 a4 80 08 cmp %l2, %o0
<== NOT EXECUTED
4001e7a4: 02 80 00 41 be 4001e8a8 <rtems_rfs_file_set_size+0x13c>
<== NOT EXECUTED
4001e7a8: 80 a4 c0 09 cmp %l3, %o1
<== NOT EXECUTED
4001e7ac: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
<== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001e7b0: a2 07 20 34 add %i4, 0x34, %l1
<== NOT EXECUTED
if (new_size == 0)
4001e7b4: 80 94 80 13 orcc %l2, %l3, %g0
<== NOT EXECUTED
4001e7b8: 02 80 00 33 be 4001e884 <rtems_rfs_file_set_size+0x118>
<== NOT EXECUTED
4001e7bc: e8 06 e0 98 ld [ %i3 + 0x98 ], %l4
<== NOT EXECUTED
4001e7c0: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
<== NOT EXECUTED
if (size < new_size)
4001e7c4: 80 a4 80 08 cmp %l2, %o0
<== NOT EXECUTED
4001e7c8: 18 80 00 4d bgu 4001e8fc <rtems_rfs_file_set_size+0x190>
<== NOT EXECUTED
4001e7cc: e0 05 20 08 ld [ %l4 + 8 ], %l0
<== NOT EXECUTED
4001e7d0: 02 80 00 49 be 4001e8f4 <rtems_rfs_file_set_size+0x188>
<== NOT EXECUTED
4001e7d4: 80 a4 c0 09 cmp %l3, %o1
<== NOT EXECUTED
(((new_size - 1) /
4001e7d8: 92 84 ff ff addcc %l3, -1, %o1
<== NOT EXECUTED
4001e7dc: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001e7e0: 90 44 bf ff addx %l2, -1, %o0
<== NOT EXECUTED
4001e7e4: 40 00 42 f2 call 4002f3ac <__udivdi3>
<== NOT EXECUTED
4001e7e8: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
blocks =
4001e7ec: b4 07 7f ff add %i5, -1, %i2
<== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001e7f0: 94 10 20 00 clr %o2
<== NOT EXECUTED
blocks =
4001e7f4: b4 26 80 09 sub %i2, %o1, %i2
<== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001e7f8: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
4001e7fc: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
4001e800: 40 00 43 64 call 4002f590 <__umoddi3>
<== NOT EXECUTED
4001e804: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
if (blocks)
4001e808: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001e80c: 12 80 00 89 bne 4001ea30 <rtems_rfs_file_set_size+0x2c4>
<== NOT EXECUTED
4001e810: b2 10 00 09 mov %o1, %i1
<== NOT EXECUTED
map->size.offset = offset;
4001e814: f2 27 20 40 st %i1, [ %i4 + 0x40 ]
<== NOT EXECUTED
map->dirty = true;
4001e818: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001e81c: c2 2f 20 34 stb %g1, [ %i4 + 0x34 ]
<== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001e820: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
4001e824: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001e828: 02 80 00 8c be 4001ea58 <rtems_rfs_file_set_size+0x2ec>
<== NOT EXECUTED
4001e82c: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
4001e830: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001e834: 12 80 00 89 bne 4001ea58 <rtems_rfs_file_set_size+0x2ec>
<== NOT EXECUTED
4001e838: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
4001e83c: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
<== NOT EXECUTED
4001e840: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001e844: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
<== NOT EXECUTED
4001e848: 02 80 00 04 be 4001e858 <rtems_rfs_file_set_size+0xec>
<== NOT EXECUTED
4001e84c: c0 26 20 18 clr [ %i0 + 0x18 ]
<== NOT EXECUTED
4001e850: 82 07 7f ff add %i5, -1, %g1
<== NOT EXECUTED
4001e854: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
<== NOT EXECUTED
4001e858: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
4001e85c: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
<== NOT EXECUTED
4001e860: c2 20 a0 88 st %g1, [ %g2 + 0x88 ]
<== NOT EXECUTED
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001e864: fa 20 a0 84 st %i5, [ %g2 + 0x84 ]
<== NOT EXECUTED
if (rtems_rfs_file_update_mtime (handle))
4001e868: fa 06 00 00 ld [ %i0 ], %i5
<== NOT EXECUTED
4001e86c: ba 8f 60 02 andcc %i5, 2, %i5
<== NOT EXECUTED
4001e870: 02 80 00 14 be 4001e8c0 <rtems_rfs_file_set_size+0x154>
<== NOT EXECUTED
4001e874: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4001e878: ba 10 20 00 clr %i5 ! 0 <PROM_START>
<== NOT EXECUTED
}
4001e87c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e880: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001e884: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
4001e888: 7f ff f4 89 call 4001baac <rtems_rfs_block_map_free_all>
<== NOT EXECUTED
4001e88c: 90 10 00 14 mov %l4, %o0
<== NOT EXECUTED
if (rc > 0)
4001e890: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001e894: 14 bf ff fa bg 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001e898: 01 00 00 00 nop
<== NOT EXECUTED
4001e89c: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
<== NOT EXECUTED
4001e8a0: 10 bf ff ef b 4001e85c <rtems_rfs_file_set_size+0xf0>
<== NOT EXECUTED
4001e8a4: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
<== NOT EXECUTED
if (size != new_size)
4001e8a8: 32 bf ff c2 bne,a 4001e7b0 <rtems_rfs_file_set_size+0x44>
<== NOT EXECUTED
4001e8ac: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
<== NOT EXECUTED
if (rtems_rfs_file_update_mtime (handle))
4001e8b0: fa 06 00 00 ld [ %i0 ], %i5
<== NOT EXECUTED
4001e8b4: ba 8f 60 02 andcc %i5, 2, %i5
<== NOT EXECUTED
4001e8b8: 32 bf ff f1 bne,a 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001e8bc: ba 10 20 00 clr %i5
<== NOT EXECUTED
handle->shared->mtime = time (NULL);
4001e8c0: 40 00 1d 52 call 40025e08 <time>
<== NOT EXECUTED
4001e8c4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001e8c8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
<== NOT EXECUTED
4001e8cc: d2 20 60 90 st %o1, [ %g1 + 0x90 ]
<== NOT EXECUTED
}
4001e8d0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001e8d4: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
4001e8d8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001e8dc: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001e8e0: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001e8e4: 7f ff da 61 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001e8e8: 90 12 20 70 or %o0, 0x70, %o0 ! 40033870 <status_code_to_errno+0x112c>
<== NOT EXECUTED
size = rtems_rfs_file_size (handle);
4001e8ec: 10 bf ff aa b 4001e794 <rtems_rfs_file_set_size+0x28>
<== NOT EXECUTED
4001e8f0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
<== NOT EXECUTED
if (size < new_size)
4001e8f4: 28 bf ff ba bleu,a 4001e7dc <rtems_rfs_file_set_size+0x70>
<== NOT EXECUTED
4001e8f8: 92 84 ff ff addcc %l3, -1, %o1
<== NOT EXECUTED
count = new_size - size;
4001e8fc: b6 a4 c0 09 subcc %l3, %o1, %i3
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001e900: b2 06 20 04 add %i0, 4, %i1
<== NOT EXECUTED
count = new_size - size;
4001e904: b4 64 80 08 subx %l2, %o0, %i2
<== NOT EXECUTED
read_block = false;
4001e908: a6 10 20 00 clr %l3
<== NOT EXECUTED
4001e90c: 10 80 00 28 b 4001e9ac <rtems_rfs_file_set_size+0x240>
<== NOT EXECUTED
4001e910: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
if (count < (length - bpos.boff))
4001e914: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
4001e918: 28 80 00 44 bleu,a 4001ea28 <rtems_rfs_file_set_size+0x2bc>
<== NOT EXECUTED
4001e91c: c0 27 20 40 clr [ %i4 + 0x40 ]
<== NOT EXECUTED
length = count + bpos.boff;
4001e920: a0 00 40 1b add %g1, %i3, %l0
<== NOT EXECUTED
4001e924: e4 2f 20 34 stb %l2, [ %i4 + 0x34 ]
<== NOT EXECUTED
read_block = true;
4001e928: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
map->size.offset = offset;
4001e92c: e0 27 20 40 st %l0, [ %i4 + 0x40 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001e930: 96 0c e0 01 and %l3, 1, %o3
<== NOT EXECUTED
4001e934: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
<== NOT EXECUTED
4001e938: d4 07 bf f0 ld [ %fp + -16 ], %o2
<== NOT EXECUTED
4001e93c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
<== NOT EXECUTED
4001e940: 7f ff f5 5d call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001e944: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (rc > 0)
4001e948: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001e94c: 14 bf ff cc bg 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001e950: c2 07 bf f8 ld [ %fp + -8 ], %g1
<== NOT EXECUTED
dst = rtems_rfs_buffer_data (&handle->buffer);
4001e954: c4 06 20 0c ld [ %i0 + 0xc ], %g2
<== NOT EXECUTED
memset (dst + bpos.boff, 0, length - bpos.boff);
4001e958: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
<== NOT EXECUTED
4001e95c: 94 24 00 01 sub %l0, %g1, %o2
<== NOT EXECUTED
4001e960: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001e964: 40 00 0c 64 call 40021af4 <memset>
<== NOT EXECUTED
4001e968: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001e96c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001e970: e4 2e 20 04 stb %l2, [ %i0 + 4 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001e974: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001e978: 7f ff f6 16 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001e97c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
<== NOT EXECUTED
if (rc > 0)
4001e980: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001e984: 14 bf ff be bg 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001e988: c2 07 bf f8 ld [ %fp + -8 ], %g1
<== NOT EXECUTED
count -= length - bpos.boff;
4001e98c: 82 24 00 01 sub %l0, %g1, %g1
<== NOT EXECUTED
4001e990: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
<== NOT EXECUTED
4001e994: b6 a6 c0 01 subcc %i3, %g1, %i3
<== NOT EXECUTED
4001e998: b4 66 a0 00 subx %i2, 0, %i2
<== NOT EXECUTED
while (count)
4001e99c: 80 96 80 1b orcc %i2, %i3, %g0
<== NOT EXECUTED
4001e9a0: 02 bf ff af be 4001e85c <rtems_rfs_file_set_size+0xf0>
<== NOT EXECUTED
4001e9a4: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
<== NOT EXECUTED
4001e9a8: e8 00 a0 98 ld [ %g2 + 0x98 ], %l4
<== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
4001e9ac: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
<== NOT EXECUTED
4001e9b0: fa 27 bf f4 st %i5, [ %fp + -12 ]
<== NOT EXECUTED
4001e9b4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001e9b8: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
4001e9bc: 02 80 00 04 be 4001e9cc <rtems_rfs_file_set_size+0x260>
<== NOT EXECUTED
4001e9c0: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
4001e9c4: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
4001e9c8: fa 27 bf f4 st %i5, [ %fp + -12 ]
<== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001e9cc: 96 07 bf f0 add %fp, -16, %o3
<== NOT EXECUTED
4001e9d0: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4001e9d4: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
4001e9d8: 7f ff f1 ef call 4001b194 <rtems_rfs_block_map_find>
<== NOT EXECUTED
4001e9dc: 90 10 00 14 mov %l4, %o0
<== NOT EXECUTED
if (rc > 0)
4001e9e0: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001e9e4: 04 80 00 0c ble 4001ea14 <rtems_rfs_file_set_size+0x2a8>
<== NOT EXECUTED
4001e9e8: 80 a7 60 06 cmp %i5, 6
<== NOT EXECUTED
if (rc != ENXIO)
4001e9ec: 12 bf ff a4 bne 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001e9f0: 96 07 bf f0 add %fp, -16, %o3
<== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001e9f4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
<== NOT EXECUTED
4001e9f8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
<== NOT EXECUTED
4001e9fc: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4001ea00: 7f ff f2 69 call 4001b3a4 <rtems_rfs_block_map_grow>
<== NOT EXECUTED
4001ea04: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
if (rc > 0)
4001ea08: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001ea0c: 14 bf ff 9c bg 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001ea10: 01 00 00 00 nop
<== NOT EXECUTED
if (count < (length - bpos.boff))
4001ea14: c2 07 bf f8 ld [ %fp + -8 ], %g1
<== NOT EXECUTED
4001ea18: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001ea1c: 02 bf ff be be 4001e914 <rtems_rfs_file_set_size+0x1a8>
<== NOT EXECUTED
4001ea20: 84 24 00 01 sub %l0, %g1, %g2
<== NOT EXECUTED
4001ea24: c0 27 20 40 clr [ %i4 + 0x40 ]
<== NOT EXECUTED
map->dirty = true;
4001ea28: 10 bf ff c2 b 4001e930 <rtems_rfs_file_set_size+0x1c4>
<== NOT EXECUTED
4001ea2c: e4 2f 20 34 stb %l2, [ %i4 + 0x34 ]
<== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
4001ea30: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001ea34: 92 06 e0 34 add %i3, 0x34, %o1
<== NOT EXECUTED
4001ea38: 7f ff f3 58 call 4001b798 <rtems_rfs_block_map_shrink>
<== NOT EXECUTED
4001ea3c: 90 10 00 14 mov %l4, %o0
<== NOT EXECUTED
if (rc > 0)
4001ea40: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001ea44: 14 bf ff 8e bg 4001e87c <rtems_rfs_file_set_size+0x110>
<== NOT EXECUTED
4001ea48: 01 00 00 00 nop
<== NOT EXECUTED
4001ea4c: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
<== NOT EXECUTED
4001ea50: 10 bf ff 71 b 4001e814 <rtems_rfs_file_set_size+0xa8>
<== NOT EXECUTED
4001ea54: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
<== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001ea58: 3a bf ff 7a bcc,a 4001e840 <rtems_rfs_file_set_size+0xd4>
<== NOT EXECUTED
4001ea5c: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
<== NOT EXECUTED
4001ea60: 84 07 7f ff add %i5, -1, %g2
<== NOT EXECUTED
4001ea64: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4001ea68: 32 bf ff 7d bne,a 4001e85c <rtems_rfs_file_set_size+0xf0>
<== NOT EXECUTED
4001ea6c: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
4001ea70: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
4001ea74: 80 a0 40 19 cmp %g1, %i1
<== NOT EXECUTED
4001ea78: 38 bf ff 72 bgu,a 4001e840 <rtems_rfs_file_set_size+0xd4>
<== NOT EXECUTED
4001ea7c: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
<== NOT EXECUTED
4001ea80: 10 bf ff 77 b 4001e85c <rtems_rfs_file_set_size+0xf0>
<== NOT EXECUTED
4001ea84: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
40011f9c <rtems_rfs_format>:
return 0;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
40011f9c: 9d e3 be d8 save %sp, -296, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
40011fa0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40011fa4: 80 a0 60 00 cmp %g1, 0
40011fa8: 12 80 00 94 bne 400121f8 <rtems_rfs_format+0x25c>
<== NEVER TAKEN
40011fac: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40011fb0: 94 10 20 80 mov 0x80, %o2
40011fb4: 92 10 20 00 clr %o1
40011fb8: 40 00 3e cf call 40021af4 <memset>
40011fbc: 90 07 bf 80 add %fp, -128, %o0
head->next = tail;
40011fc0: 82 07 bf c4 add %fp, -60, %g1
40011fc4: c2 27 bf c0 st %g1, [ %fp + -64 ]
tail->previous = head;
40011fc8: 82 07 bf c0 add %fp, -64, %g1
40011fcc: c2 27 bf c8 st %g1, [ %fp + -56 ]
head->next = tail;
40011fd0: 82 07 bf d4 add %fp, -44, %g1
40011fd4: c2 27 bf d0 st %g1, [ %fp + -48 ]
tail->previous = head;
40011fd8: 82 07 bf d0 add %fp, -48, %g1
40011fdc: c2 27 bf d8 st %g1, [ %fp + -40 ]
head->next = tail;
40011fe0: 82 07 bf e4 add %fp, -28, %g1
40011fe4: c2 27 bf e0 st %g1, [ %fp + -32 ]
tail->previous = head;
40011fe8: 82 07 bf e0 add %fp, -32, %g1
40011fec: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->next = tail;
40011ff0: 82 07 bf f4 add %fp, -12, %g1
40011ff4: c2 27 bf f0 st %g1, [ %fp + -16 ]
tail->previous = head;
40011ff8: 82 07 bf f0 add %fp, -16, %g1
40011ffc: 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;
40012000: 82 10 20 05 mov 5, %g1
40012004: 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;
40012008: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4001200c: 92 07 bf 7c add %fp, -132, %o1
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
40012010: c2 27 bf 7c st %g1, [ %fp + -132 ]
rc = rtems_rfs_buffer_open (name, &fs);
40012014: 40 00 28 78 call 4001c1f4 <rtems_rfs_buffer_open>
40012018: 90 10 00 18 mov %i0, %o0
if (rc != 0)
4001201c: ba 92 20 00 orcc %o0, 0, %i5
40012020: 12 80 03 ac bne 40012ed0 <rtems_rfs_format+0xf34>
<== NEVER TAKEN
40012024: c2 07 bf 8c ld [ %fp + -116 ], %g1
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40012028: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
4001202c: 80 a2 a0 00 cmp %o2, 0
40012030: 02 80 03 93 be 40012e7c <rtems_rfs_format+0xee0>
<== NEVER TAKEN
40012034: 92 10 20 00 clr %o1
fs->block_size = config->block_size;
40012038: d2 06 40 00 ld [ %i1 ], %o1
if (!fs->block_size)
4001203c: 80 a2 60 00 cmp %o1, 0
40012040: 02 80 00 73 be 4001220c <rtems_rfs_format+0x270>
<== ALWAYS TAKEN
40012044: d2 27 bf 84 st %o1, [ %fp + -124 ]
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40012048: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001204c: 01 00 00 00 nop
<== NOT EXECUTED
40012050: 01 00 00 00 nop
<== NOT EXECUTED
40012054: 01 00 00 00 nop
<== NOT EXECUTED
40012058: 82 72 40 0a udiv %o1, %o2, %g1
<== NOT EXECUTED
4001205c: 82 58 40 0a smul %g1, %o2, %g1
<== NOT EXECUTED
40012060: 80 a2 40 01 cmp %o1, %g1
<== NOT EXECUTED
40012064: 32 80 00 91 bne,a 400122a8 <rtems_rfs_format+0x30c>
<== NOT EXECUTED
40012068: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
fs->group_blocks = config->group_blocks;
4001206c: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
40012070: c2 27 bf a4 st %g1, [ %fp + -92 ]
if (!fs->group_blocks)
40012074: 80 a0 60 00 cmp %g1, 0
40012078: 02 80 00 0d be 400120ac <rtems_rfs_format+0x110>
<== ALWAYS TAKEN
4001207c: 93 2a 60 03 sll %o1, 3, %o1
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
40012080: 80 a0 40 09 cmp %g1, %o1
<== NOT EXECUTED
40012084: 08 80 00 0b bleu 400120b0 <rtems_rfs_format+0x114>
<== NOT EXECUTED
40012088: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
printf ("group block count is higher than bits in block\n");
4001208c: 40 00 0c 86 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
40012090: 90 12 20 f8 or %o0, 0xf8, %o0 ! 400318f8 <_Thread_queue_Operations_default+0xc4>
<== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
{
errno = EINVAL;
40012094: 40 00 3a f5 call 40020c68 <__errno>
<== NOT EXECUTED
40012098: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001209c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400120a0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
400120a4: 81 c7 e0 08 ret
<== NOT EXECUTED
400120a8: 81 e8 00 00 restore
<== NOT EXECUTED
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
400120ac: d2 27 bf a4 st %o1, [ %fp + -92 ]
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
400120b0: 40 00 32 92 call 4001eaf8 <rtems_rfs_fs_media_size>
400120b4: 90 07 bf 7c add %fp, -132, %o0
400120b8: fa 07 bf 84 ld [ %fp + -124 ], %i5
400120bc: 94 10 20 00 clr %o2
400120c0: 40 00 74 bb call 4002f3ac <__udivdi3>
400120c4: 96 10 00 1d mov %i5, %o3
400120c8: d2 27 bf 80 st %o1, [ %fp + -128 ]
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
400120cc: b9 2f 60 03 sll %i5, 3, %i4
if (dividend == 0)
400120d0: 80 a2 60 00 cmp %o1, 0
400120d4: 12 80 01 06 bne 400124ec <rtems_rfs_format+0x550>
<== ALWAYS TAKEN
400120d8: 88 10 20 01 mov 1, %g4
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
400120dc: c8 27 bf a0 st %g4, [ %fp + -96 ]
<== NOT EXECUTED
400120e0: 83 37 60 03 srl %i5, 3, %g1
<== NOT EXECUTED
fs->group_inodes = config->group_inodes;
400120e4: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
400120e8: 05 09 24 92 sethi %hi(0x24924800), %g2
<== NOT EXECUTED
if (!fs->group_inodes)
400120ec: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
400120f0: 84 10 a1 25 or %g2, 0x125, %g2
<== NOT EXECUTED
400120f4: 80 50 40 02 umul %g1, %g2, %g0
<== NOT EXECUTED
400120f8: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
400120fc: 22 80 00 73 be,a 400122c8 <rtems_rfs_format+0x32c>
<== NOT EXECUTED
40012100: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
40012104: c2 27 bf ac st %g1, [ %fp + -84 ]
<== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40012108: 86 00 ff ff add %g3, -1, %g3
4001210c: 81 80 20 00 wr %g0, %y
40012110: 01 00 00 00 nop
40012114: 01 00 00 00 nop
40012118: 01 00 00 00 nop
4001211c: 84 70 c0 01 udiv %g3, %g1, %g2
40012120: 84 00 a0 01 inc %g2
40012124: 82 58 40 02 smul %g1, %g2, %g1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40012128: 80 a7 00 01 cmp %i4, %g1
4001212c: 2a 80 00 83 bcs,a 40012338 <rtems_rfs_format+0x39c>
<== NEVER TAKEN
40012130: f8 27 bf a8 st %i4, [ %fp + -88 ]
<== NOT EXECUTED
fs->group_inodes =
40012134: c2 27 bf a8 st %g1, [ %fp + -88 ]
fs->max_name_length = config->max_name_length;
40012138: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
4001213c: 80 a0 60 00 cmp %g1, 0
40012140: 32 80 00 83 bne,a 4001234c <rtems_rfs_format+0x3b0>
<== NEVER TAKEN
40012144: c2 27 bf 98 st %g1, [ %fp + -104 ]
<== NOT EXECUTED
fs->max_name_length = 512;
40012148: 82 10 22 00 mov 0x200, %g1
4001214c: c2 27 bf 98 st %g1, [ %fp + -104 ]
}
if (config->verbose)
40012150: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40012154: 80 a0 60 00 cmp %g1, 0
40012158: 12 80 00 81 bne 4001235c <rtems_rfs_format+0x3c0>
<== NEVER TAKEN
4001215c: 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));
40012160: 92 10 00 1d mov %i5, %o1
40012164: 40 00 28 d6 call 4001c4bc <rtems_rfs_buffer_setblksize>
40012168: 90 07 bf 7c add %fp, -132, %o0
if (rc != 0)
4001216c: ba 92 20 00 orcc %o0, 0, %i5
40012170: 12 80 03 4c bne 40012ea0 <rtems_rfs_format+0xf04>
<== NEVER TAKEN
40012174: 96 10 20 00 clr %o3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
40012178: c0 2f bf 54 clrb [ %fp + -172 ]
handle->bnum = 0;
4001217c: c0 27 bf 58 clr [ %fp + -168 ]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
40012180: 94 10 20 00 clr %o2
handle->buffer = NULL;
40012184: c0 27 bf 5c clr [ %fp + -164 ]
40012188: 92 07 bf 54 add %fp, -172, %o1
4001218c: 40 00 27 4a call 4001beb4 <rtems_rfs_buffer_handle_request>
40012190: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
40012194: b8 92 20 00 orcc %o0, 0, %i4
40012198: 04 80 00 f9 ble 4001257c <rtems_rfs_format+0x5e0>
<== ALWAYS TAKEN
4001219c: 92 07 bf 54 add %fp, -172, %o1
*/
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);
400121a0: 40 00 28 0c call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400121a4: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
400121a8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
handle->dirty = false;
400121ac: c0 2f bf 54 clrb [ %fp + -172 ]
<== NOT EXECUTED
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
errno = EIO;
return -1;
400121b0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
handle->bnum = 0;
400121b4: c0 27 bf 58 clr [ %fp + -168 ]
<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
400121b8: 40 00 42 f5 call 40022d8c <strerror>
<== NOT EXECUTED
400121bc: c0 27 bf 5c clr [ %fp + -164 ]
<== NOT EXECUTED
400121c0: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
400121c4: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
400121c8: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400121cc: 40 00 0c 27 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400121d0: 90 12 23 40 or %o0, 0x340, %o0 ! 40031b40 <_Thread_queue_Operations_default+0x30c>
<== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
400121d4: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400121d8: 40 00 0c 33 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
400121dc: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40031bb8 <_Thread_queue_Operations_default+0x384>
<== NOT EXECUTED
errno = EIO;
400121e0: 40 00 3a a2 call 40020c68 <__errno>
<== NOT EXECUTED
400121e4: 01 00 00 00 nop
<== NOT EXECUTED
400121e8: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
400121ec: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
400121f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400121f4: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
400121f8: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400121fc: 40 00 0c 1b call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012200: 90 12 20 48 or %o0, 0x48, %o0 ! 40031848 <_Thread_queue_Operations_default+0x14>
<== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40012204: 10 bf ff 6c b 40011fb4 <rtems_rfs_format+0x18>
<== NOT EXECUTED
40012208: 94 10 20 80 mov 0x80, %o2
<== NOT EXECUTED
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4001220c: 40 00 32 3b call 4001eaf8 <rtems_rfs_fs_media_size>
40012210: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
40012214: 80 a2 20 00 cmp %o0, 0
40012218: 22 80 00 c8 be,a 40012538 <rtems_rfs_format+0x59c>
<== ALWAYS TAKEN
4001221c: 03 00 03 ff sethi %hi(0xffc00), %g1
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40012220: 84 10 20 00 clr %g2
<== NOT EXECUTED
40012224: 07 00 04 00 sethi %hi(0x100000), %g3
<== NOT EXECUTED
for (b = 31; b > 0; b--)
40012228: 82 10 20 1f mov 0x1f, %g1
<== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4001222c: ba 82 40 03 addcc %o1, %g3, %i5
<== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
40012230: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40012234: b8 42 00 02 addx %o0, %g2, %i4
<== NOT EXECUTED
40012238: 89 37 60 14 srl %i5, 0x14, %g4
<== NOT EXECUTED
4001223c: 85 2f 20 0c sll %i4, 0xc, %g2
<== NOT EXECUTED
40012240: 10 80 00 04 b 40012250 <rtems_rfs_format+0x2b4>
<== NOT EXECUTED
40012244: 84 10 80 04 or %g2, %g4, %g2
<== NOT EXECUTED
for (b = 31; b > 0; b--)
40012248: 02 80 00 06 be 40012260 <rtems_rfs_format+0x2c4>
<== NOT EXECUTED
4001224c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
40012250: 93 28 c0 01 sll %g3, %g1, %o1
<== NOT EXECUTED
40012254: 80 88 80 09 btst %g2, %o1
<== NOT EXECUTED
40012258: 02 bf ff fc be 40012248 <rtems_rfs_format+0x2ac>
<== NOT EXECUTED
4001225c: 82 80 7f ff addcc %g1, -1, %g1
<== NOT EXECUTED
if (fs->block_size < 512)
40012260: 80 a2 61 ff cmp %o1, 0x1ff
<== NOT EXECUTED
40012264: 18 80 00 bd bgu 40012558 <rtems_rfs_format+0x5bc>
<== NOT EXECUTED
40012268: d2 27 bf 84 st %o1, [ %fp + -124 ]
<== NOT EXECUTED
4001226c: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
40012270: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
fs->block_size = 512;
40012274: 82 10 22 00 mov 0x200, %g1
40012278: c2 27 bf 84 st %g1, [ %fp + -124 ]
4001227c: 92 10 22 00 mov 0x200, %o1
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40012280: 81 80 20 00 wr %g0, %y
40012284: 01 00 00 00 nop
40012288: 01 00 00 00 nop
4001228c: 01 00 00 00 nop
40012290: 82 72 40 0a udiv %o1, %o2, %g1
40012294: 82 58 40 0a smul %g1, %o2, %g1
40012298: 80 a2 40 01 cmp %o1, %g1
4001229c: 22 bf ff 75 be,a 40012070 <rtems_rfs_format+0xd4>
<== ALWAYS TAKEN
400122a0: c2 06 60 04 ld [ %i1 + 4 ], %g1
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400122a4: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400122a8: 40 00 0b f0 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400122ac: 90 12 20 b8 or %o0, 0xb8, %o0 ! 400318b8 <_Thread_queue_Operations_default+0x84>
<== NOT EXECUTED
errno = EINVAL;
400122b0: 40 00 3a 6e call 40020c68 <__errno>
<== NOT EXECUTED
400122b4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400122b8: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400122bc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
400122c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400122c4: 81 e8 00 00 restore
<== NOT EXECUTED
if (config->inode_overhead)
400122c8: 80 a0 e0 00 cmp %g3, 0
400122cc: 22 80 00 02 be,a 400122d4 <rtems_rfs_format+0x338>
<== ALWAYS TAKEN
400122d0: 86 10 20 01 mov 1, %g3
blocks = ((rtems_rfs_fs_blocks (fs) -
400122d4: 84 02 7f ff add %o1, -1, %g2
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
400122d8: 37 14 7a e1 sethi %hi(0x51eb8400), %i3
400122dc: 84 58 80 03 smul %g2, %g3, %g2
400122e0: b6 16 e1 1f or %i3, 0x11f, %i3
400122e4: 80 50 80 1b umul %g2, %i3, %g0
400122e8: 85 40 00 00 rd %y, %g2
400122ec: 85 30 a0 05 srl %g2, 5, %g2
if (dividend == 0)
400122f0: 80 a0 a0 00 cmp %g2, 0
400122f4: 02 80 00 0a be 4001231c <rtems_rfs_format+0x380>
<== ALWAYS TAKEN
400122f8: 86 10 00 01 mov %g1, %g3
return ((dividend - 1) / divisor) + 1;
400122fc: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
40012300: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40012304: 01 00 00 00 nop
<== NOT EXECUTED
40012308: 01 00 00 00 nop
<== NOT EXECUTED
4001230c: 01 00 00 00 nop
<== NOT EXECUTED
40012310: 86 70 80 04 udiv %g2, %g4, %g3
<== NOT EXECUTED
40012314: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40012318: 86 58 c0 01 smul %g3, %g1, %g3
<== NOT EXECUTED
if (dividend == 0)
4001231c: 80 a0 e0 00 cmp %g3, 0
40012320: 12 bf ff 7a bne 40012108 <rtems_rfs_format+0x16c>
<== ALWAYS TAKEN
40012324: c2 27 bf ac st %g1, [ %fp + -84 ]
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40012328: 80 a7 00 01 cmp %i4, %g1
<== NOT EXECUTED
4001232c: 3a bf ff 83 bcc,a 40012138 <rtems_rfs_format+0x19c>
<== NOT EXECUTED
40012330: c2 27 bf a8 st %g1, [ %fp + -88 ]
<== NOT EXECUTED
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
40012334: f8 27 bf a8 st %i4, [ %fp + -88 ]
<== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40012338: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
if (!fs->max_name_length)
4001233c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012340: 22 bf ff 83 be,a 4001214c <rtems_rfs_format+0x1b0>
<== NOT EXECUTED
40012344: 82 10 22 00 mov 0x200, %g1
<== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40012348: c2 27 bf 98 st %g1, [ %fp + -104 ]
<== NOT EXECUTED
if (config->verbose)
4001234c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
<== NOT EXECUTED
40012350: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012354: 02 bf ff 84 be 40012164 <rtems_rfs_format+0x1c8>
<== NOT EXECUTED
40012358: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4001235c: 40 00 31 e7 call 4001eaf8 <rtems_rfs_fs_media_size>
<== NOT EXECUTED
40012360: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
40012364: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
40012368: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4001236c: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012370: 40 00 0b be call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012374: 90 12 21 28 or %o0, 0x128, %o0 ! 40031928 <_Thread_queue_Operations_default+0xf4>
<== NOT EXECUTED
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
40012378: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
4001237c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
<== NOT EXECUTED
40012380: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012384: 40 00 0b b9 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012388: 90 12 21 50 or %o0, 0x150, %o0 ! 40031950 <_Thread_queue_Operations_default+0x11c>
<== NOT EXECUTED
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
4001238c: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
40012390: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
<== NOT EXECUTED
40012394: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012398: 40 00 0b b4 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001239c: 90 12 21 78 or %o0, 0x178, %o0 ! 40031978 <_Thread_queue_Operations_default+0x144>
<== NOT EXECUTED
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
400123a0: 40 00 31 d0 call 4001eae0 <rtems_rfs_fs_size>
<== NOT EXECUTED
400123a4: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
400123a8: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
400123ac: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
400123b0: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400123b4: 40 00 0b ad call 40015268 <__wrap_printf>
<== NOT EXECUTED
400123b8: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400319a8 <_Thread_queue_Operations_default+0x174>
<== NOT EXECUTED
printf ("rtems-rfs: format: blocks = %zu\n",
400123bc: d2 07 bf 80 ld [ %fp + -128 ], %o1
<== NOT EXECUTED
400123c0: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400123c4: 40 00 0b a9 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400123c8: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 400319c8 <_Thread_queue_Operations_default+0x194>
<== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
400123cc: d2 07 bf 84 ld [ %fp + -124 ], %o1
<== NOT EXECUTED
400123d0: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400123d4: 40 00 0b a5 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400123d8: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400319f0 <_Thread_queue_Operations_default+0x1bc>
<== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
400123dc: d2 07 bf 84 ld [ %fp + -124 ], %o1
<== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
400123e0: 93 2a 60 03 sll %o1, 3, %o1
<== NOT EXECUTED
400123e4: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400123e8: 40 00 0b a0 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400123ec: 90 12 22 18 or %o0, 0x218, %o0 ! 40031a18 <_Thread_queue_Operations_default+0x1e4>
<== NOT EXECUTED
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
400123f0: 92 10 20 38 mov 0x38, %o1
<== NOT EXECUTED
400123f4: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400123f8: 40 00 0b 9c call 40015268 <__wrap_printf>
<== NOT EXECUTED
400123fc: 90 12 22 40 or %o0, 0x240, %o0 ! 40031a40 <_Thread_queue_Operations_default+0x20c>
<== NOT EXECUTED
fs.group_inodes * fs.group_count,
40012400: c4 07 bf a8 ld [ %fp + -88 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40012404: d2 07 bf a0 ld [ %fp + -96 ], %o1
<== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40012408: 83 28 a0 03 sll %g2, 3, %g1
<== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4001240c: 92 58 80 09 smul %g2, %o1, %o1
<== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40012410: 82 20 40 02 sub %g1, %g2, %g1
<== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
40012414: c6 07 bf 84 ld [ %fp + -124 ], %g3
<== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40012418: 83 28 60 03 sll %g1, 3, %g1
<== NOT EXECUTED
if (dividend == 0)
4001241c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012420: 02 80 00 0a be 40012448 <rtems_rfs_format+0x4ac>
<== NOT EXECUTED
40012424: 84 10 27 d0 mov 0x7d0, %g2
<== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40012428: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001242c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40012430: 01 00 00 00 nop
<== NOT EXECUTED
40012434: 01 00 00 00 nop
<== NOT EXECUTED
40012438: 01 00 00 00 nop
<== NOT EXECUTED
4001243c: 84 70 40 03 udiv %g1, %g3, %g2
<== NOT EXECUTED
40012440: 84 00 a0 02 add %g2, 2, %g2
<== NOT EXECUTED
40012444: 84 58 a3 e8 smul %g2, 0x3e8, %g2
<== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40012448: d6 07 bf 80 ld [ %fp + -128 ], %o3
<== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4001244c: 83 28 e0 03 sll %g3, 3, %g1
<== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40012450: 96 02 ff ff add %o3, -1, %o3
<== NOT EXECUTED
40012454: 80 a2 c0 01 cmp %o3, %g1
<== NOT EXECUTED
40012458: 38 80 00 02 bgu,a 40012460 <rtems_rfs_format+0x4c4>
<== NOT EXECUTED
4001245c: 96 10 00 01 mov %g1, %o3
<== NOT EXECUTED
40012460: 83 38 a0 1f sra %g2, 0x1f, %g1
<== NOT EXECUTED
40012464: 81 80 60 00 wr %g1, %y
<== NOT EXECUTED
40012468: 01 00 00 00 nop
<== NOT EXECUTED
4001246c: 01 00 00 00 nop
<== NOT EXECUTED
40012470: 01 00 00 00 nop
<== NOT EXECUTED
40012474: 84 78 80 0b sdiv %g2, %o3, %g2
<== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40012478: 03 19 99 99 sethi %hi(0x66666400), %g1
<== NOT EXECUTED
4001247c: 87 38 a0 1f sra %g2, 0x1f, %g3
<== NOT EXECUTED
40012480: 82 10 62 67 or %g1, 0x267, %g1
<== NOT EXECUTED
40012484: 80 58 80 01 smul %g2, %g1, %g0
<== NOT EXECUTED
40012488: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
4001248c: 83 38 60 02 sra %g1, 2, %g1
<== NOT EXECUTED
40012490: 82 20 40 03 sub %g1, %g3, %g1
<== NOT EXECUTED
40012494: 94 10 00 01 mov %g1, %o2
<== NOT EXECUTED
40012498: 97 28 60 02 sll %g1, 2, %o3
<== NOT EXECUTED
4001249c: 82 02 c0 01 add %o3, %g1, %g1
<== NOT EXECUTED
400124a0: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400124a4: 97 28 60 01 sll %g1, 1, %o3
<== NOT EXECUTED
400124a8: 90 12 22 68 or %o0, 0x268, %o0
<== NOT EXECUTED
400124ac: 40 00 0b 6f call 40015268 <__wrap_printf>
<== NOT EXECUTED
400124b0: 96 20 80 0b sub %g2, %o3, %o3
<== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
400124b4: d2 07 bf a0 ld [ %fp + -96 ], %o1
<== NOT EXECUTED
400124b8: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400124bc: 40 00 0b 6b call 40015268 <__wrap_printf>
<== NOT EXECUTED
400124c0: 90 12 22 98 or %o0, 0x298, %o0 ! 40031a98 <_Thread_queue_Operations_default+0x264>
<== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
400124c4: d2 07 bf a4 ld [ %fp + -92 ], %o1
<== NOT EXECUTED
400124c8: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400124cc: 40 00 0b 67 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400124d0: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40031ab8 <_Thread_queue_Operations_default+0x284>
<== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
400124d4: d2 07 bf a8 ld [ %fp + -88 ], %o1
<== NOT EXECUTED
400124d8: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
400124dc: 40 00 0b 63 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400124e0: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40031ae0 <_Thread_queue_Operations_default+0x2ac>
<== NOT EXECUTED
400124e4: 10 bf ff 1f b 40012160 <rtems_rfs_format+0x1c4>
<== NOT EXECUTED
400124e8: fa 07 bf 84 ld [ %fp + -124 ], %i5
<== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
400124ec: 82 02 7f ff add %o1, -1, %g1
400124f0: 81 80 20 00 wr %g0, %y
400124f4: 01 00 00 00 nop
400124f8: 01 00 00 00 nop
400124fc: 01 00 00 00 nop
40012500: 88 70 40 1c udiv %g1, %i4, %g4
40012504: 88 01 20 01 inc %g4
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
40012508: c8 27 bf a0 st %g4, [ %fp + -96 ]
4001250c: 83 37 60 03 srl %i5, 3, %g1
fs->group_inodes = config->group_inodes;
40012510: c6 06 60 08 ld [ %i1 + 8 ], %g3
40012514: 05 09 24 92 sethi %hi(0x24924800), %g2
if (!fs->group_inodes)
40012518: 80 a0 e0 00 cmp %g3, 0
4001251c: 84 10 a1 25 or %g2, 0x125, %g2
40012520: 80 50 40 02 umul %g1, %g2, %g0
40012524: 83 40 00 00 rd %y, %g1
40012528: 32 bf fe f8 bne,a 40012108 <rtems_rfs_format+0x16c>
<== NEVER TAKEN
4001252c: c2 27 bf ac st %g1, [ %fp + -84 ]
<== NOT EXECUTED
if (config->inode_overhead)
40012530: 10 bf ff 66 b 400122c8 <rtems_rfs_format+0x32c>
40012534: c6 06 60 0c ld [ %i1 + 0xc ], %g3
if (total_size >= GIGS (1))
40012538: 82 10 63 ff or %g1, 0x3ff, %g1
4001253c: 80 a2 40 01 cmp %o1, %g1
40012540: 18 bf ff 39 bgu 40012224 <rtems_rfs_format+0x288>
<== NEVER TAKEN
40012544: 84 10 20 00 clr %g2
40012548: d2 07 bf 84 ld [ %fp + -124 ], %o1
if (fs->block_size < 512)
4001254c: 80 a2 61 ff cmp %o1, 0x1ff
40012550: 08 bf ff 48 bleu 40012270 <rtems_rfs_format+0x2d4>
<== ALWAYS TAKEN
40012554: c2 07 bf 8c ld [ %fp + -116 ], %g1
if (fs->block_size > (4 * 1024))
40012558: 03 00 00 04 sethi %hi(0x1000), %g1
<== NOT EXECUTED
4001255c: 80 a2 40 01 cmp %o1, %g1
<== NOT EXECUTED
40012560: 28 80 00 05 bleu,a 40012574 <rtems_rfs_format+0x5d8>
<== NOT EXECUTED
40012564: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
fs->block_size = (4 * 1024);
40012568: c2 27 bf 84 st %g1, [ %fp + -124 ]
<== NOT EXECUTED
4001256c: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
40012570: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
40012574: 10 bf fe b5 b 40012048 <rtems_rfs_format+0xac>
<== NOT EXECUTED
40012578: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
<== NOT EXECUTED
sb = rtems_rfs_buffer_data (&handle);
4001257c: c2 07 bf 5c ld [ %fp + -164 ], %g1
40012580: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
40012584: d4 07 bf 84 ld [ %fp + -124 ], %o2
40012588: 92 10 20 ff mov 0xff, %o1
4001258c: 40 00 3d 5a call 40021af4 <memset>
40012590: 90 10 00 01 mov %g1, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
40012594: 84 10 20 28 mov 0x28, %g2
40012598: c4 2a 00 00 stb %g2, [ %o0 ]
4001259c: 84 10 20 09 mov 9, %g2
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400125a0: c0 2a 20 04 clrb [ %o0 + 4 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400125a4: 86 10 20 01 mov 1, %g3
400125a8: c4 2a 20 01 stb %g2, [ %o0 + 1 ]
400125ac: 84 10 20 20 mov 0x20, %g2
400125b0: c6 2a 20 03 stb %g3, [ %o0 + 3 ]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
400125b4: 82 10 00 08 mov %o0, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400125b8: c0 2a 20 05 clrb [ %o0 + 5 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400125bc: 92 07 bf 54 add %fp, -172, %o1
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400125c0: c4 2a 20 02 stb %g2, [ %o0 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400125c4: c0 2a 20 06 clrb [ %o0 + 6 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400125c8: 90 07 bf 7c add %fp, -132, %o0
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400125cc: c0 28 60 07 clrb [ %g1 + 7 ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
400125d0: c4 0f bf 84 ldub [ %fp + -124 ], %g2
400125d4: c4 28 60 08 stb %g2, [ %g1 + 8 ]
400125d8: c4 17 bf 84 lduh [ %fp + -124 ], %g2
400125dc: c4 28 60 09 stb %g2, [ %g1 + 9 ]
400125e0: c4 07 bf 84 ld [ %fp + -124 ], %g2
400125e4: 85 30 a0 08 srl %g2, 8, %g2
400125e8: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
400125ec: c4 07 bf 80 ld [ %fp + -128 ], %g2
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
400125f0: c8 07 bf 84 ld [ %fp + -124 ], %g4
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
400125f4: c4 28 60 0f stb %g2, [ %g1 + 0xf ]
400125f8: b9 30 a0 18 srl %g2, 0x18, %i4
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
400125fc: c8 28 60 0b stb %g4, [ %g1 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40012600: 89 30 a0 10 srl %g2, 0x10, %g4
40012604: f8 28 60 0c stb %i4, [ %g1 + 0xc ]
40012608: 85 30 a0 08 srl %g2, 8, %g2
4001260c: c8 28 60 0d stb %g4, [ %g1 + 0xd ]
40012610: c4 28 60 0e stb %g2, [ %g1 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40012614: c4 0f bf 94 ldub [ %fp + -108 ], %g2
40012618: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
4001261c: c4 17 bf 94 lduh [ %fp + -108 ], %g2
40012620: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
40012624: c4 07 bf 94 ld [ %fp + -108 ], %g2
40012628: 85 30 a0 08 srl %g2, 8, %g2
4001262c: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
40012630: c4 07 bf 94 ld [ %fp + -108 ], %g2
40012634: c4 28 60 13 stb %g2, [ %g1 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40012638: c4 0f bf 98 ldub [ %fp + -104 ], %g2
4001263c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
40012640: c4 17 bf 98 lduh [ %fp + -104 ], %g2
40012644: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40012648: c4 07 bf 98 ld [ %fp + -104 ], %g2
4001264c: 85 30 a0 08 srl %g2, 8, %g2
40012650: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40012654: c4 07 bf 98 ld [ %fp + -104 ], %g2
40012658: c4 28 60 17 stb %g2, [ %g1 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
4001265c: c4 0f bf a0 ldub [ %fp + -96 ], %g2
40012660: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
40012664: c4 17 bf a0 lduh [ %fp + -96 ], %g2
40012668: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
4001266c: c4 07 bf a0 ld [ %fp + -96 ], %g2
40012670: 85 30 a0 08 srl %g2, 8, %g2
40012674: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
40012678: c4 07 bf a0 ld [ %fp + -96 ], %g2
4001267c: c4 28 60 1b stb %g2, [ %g1 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
40012680: c4 0f bf a4 ldub [ %fp + -92 ], %g2
40012684: c4 28 60 1c stb %g2, [ %g1 + 0x1c ]
40012688: c4 17 bf a4 lduh [ %fp + -92 ], %g2
4001268c: c4 28 60 1d stb %g2, [ %g1 + 0x1d ]
40012690: c4 07 bf a4 ld [ %fp + -92 ], %g2
40012694: 85 30 a0 08 srl %g2, 8, %g2
40012698: c4 28 60 1e stb %g2, [ %g1 + 0x1e ]
4001269c: c4 07 bf a4 ld [ %fp + -92 ], %g2
400126a0: c4 28 60 1f stb %g2, [ %g1 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
400126a4: c4 0f bf a8 ldub [ %fp + -88 ], %g2
400126a8: c4 28 60 20 stb %g2, [ %g1 + 0x20 ]
400126ac: c4 17 bf a8 lduh [ %fp + -88 ], %g2
400126b0: c4 28 60 21 stb %g2, [ %g1 + 0x21 ]
400126b4: c4 07 bf a8 ld [ %fp + -88 ], %g2
400126b8: 85 30 a0 08 srl %g2, 8, %g2
400126bc: c4 28 60 22 stb %g2, [ %g1 + 0x22 ]
400126c0: c4 07 bf a8 ld [ %fp + -88 ], %g2
400126c4: c4 28 60 23 stb %g2, [ %g1 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
400126c8: 84 10 20 38 mov 0x38, %g2
400126cc: c0 28 60 24 clrb [ %g1 + 0x24 ]
400126d0: c4 28 60 27 stb %g2, [ %g1 + 0x27 ]
400126d4: c0 28 60 25 clrb [ %g1 + 0x25 ]
400126d8: c0 28 60 26 clrb [ %g1 + 0x26 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400126dc: 40 00 26 bd call 4001c1d0 <rtems_rfs_buffer_handle_release>
400126e0: c6 2f bf 54 stb %g3, [ %fp + -172 ]
rtems_rfs_buffer_handle_release (fs, handle);
400126e4: 92 07 bf 54 add %fp, -172, %o1
400126e8: b8 10 00 08 mov %o0, %i4
if (rc > 0)
400126ec: 80 a7 20 00 cmp %i4, 0
400126f0: 04 80 00 17 ble 4001274c <rtems_rfs_format+0x7b0>
<== ALWAYS TAKEN
400126f4: 90 07 bf 7c add %fp, -132, %o0
400126f8: 40 00 26 b6 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400126fc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
40012700: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
handle->dirty = false;
40012704: c0 2f bf 54 clrb [ %fp + -172 ]
<== NOT EXECUTED
handle->bnum = 0;
40012708: c0 27 bf 58 clr [ %fp + -168 ]
<== NOT EXECUTED
4001270c: 40 00 41 a0 call 40022d8c <strerror>
<== NOT EXECUTED
40012710: c0 27 bf 5c clr [ %fp + -164 ]
<== NOT EXECUTED
40012714: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40012718: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001271c: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012720: 40 00 0a d2 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012724: 90 12 23 78 or %o0, 0x378, %o0 ! 40031b78 <_Thread_queue_Operations_default+0x344>
<== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
40012728: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
4001272c: 40 00 0a de call 400152a4 <__wrap_puts>
<== NOT EXECUTED
40012730: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40031bb8 <_Thread_queue_Operations_default+0x384>
<== NOT EXECUTED
errno = EIO;
40012734: 40 00 39 4d call 40020c68 <__errno>
<== NOT EXECUTED
40012738: 01 00 00 00 nop
<== NOT EXECUTED
4001273c: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
40012740: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40012744: 81 c7 e0 08 ret
<== NOT EXECUTED
40012748: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001274c: 40 00 26 a1 call 4001c1d0 <rtems_rfs_buffer_handle_release>
40012750: 01 00 00 00 nop
}
for (group = 0; group < fs.group_count; group++)
40012754: c2 07 bf a0 ld [ %fp + -96 ], %g1
40012758: 80 a0 60 00 cmp %g1, 0
4001275c: 04 80 00 a1 ble 400129e0 <rtems_rfs_format+0xa44>
<== NEVER TAKEN
40012760: c2 07 bf 80 ld [ %fp + -128 ], %g1
if (group_base > rtems_rfs_fs_blocks (fs))
40012764: 80 a0 60 00 cmp %g1, 0
40012768: 02 80 00 34 be 40012838 <rtems_rfs_format+0x89c>
<== NEVER TAKEN
4001276c: 29 10 00 c7 sethi %hi(0x40031c00), %l4
printf (", inodes");
40012770: 86 15 21 50 or %l4, 0x150, %g3 ! 40031d50 <_Thread_queue_Operations_default+0x51c>
40012774: c6 27 bf 3c st %g3, [ %fp + -196 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40012778: 25 10 00 c7 sethi %hi(0x40031c00), %l2
if (!rtems_rfs_write_group (&fs, group,
4001277c: ea 0e 60 14 ldub [ %i1 + 0x14 ], %l5
40012780: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2
group_base = rtems_rfs_fs_block (fs, group, 0);
40012784: f6 07 bf a4 ld [ %fp + -92 ], %i3
printf (", blocks");
40012788: 23 10 00 c7 sethi %hi(0x40031c00), %l1
group_base = rtems_rfs_fs_block (fs, group, 0);
4001278c: b8 10 20 01 mov 1, %i4
40012790: a0 10 20 00 clr %l0
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40012794: a4 14 a0 28 or %l2, 0x28, %l2
printf (", blocks");
40012798: a2 14 60 60 or %l1, 0x60, %l1
rtems_rfs_buffer_mark_dirty (&handle);
4001279c: a6 10 20 01 mov 1, %l3
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
400127a0: 86 06 c0 1c add %i3, %i4, %g3
400127a4: 80 a0 c0 01 cmp %g3, %g1
400127a8: 38 80 00 02 bgu,a 400127b0 <rtems_rfs_format+0x814>
<== ALWAYS TAKEN
400127ac: b6 20 40 1c sub %g1, %i4, %i3
if (verbose)
400127b0: b4 88 a0 ff andcc %g2, 0xff, %i2
400127b4: 12 80 00 46 bne 400128cc <rtems_rfs_format+0x930>
<== NEVER TAKEN
400127b8: 96 10 00 1b mov %i3, %o3
handle->dirty = false;
400127bc: c0 2f bf 48 clrb [ %fp + -184 ]
handle->bnum = 0;
400127c0: c0 27 bf 4c clr [ %fp + -180 ]
handle->buffer = NULL;
400127c4: c0 27 bf 50 clr [ %fp + -176 ]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
400127c8: 98 10 00 1c mov %i4, %o4
400127cc: 96 10 00 1b mov %i3, %o3
400127d0: 94 07 bf 48 add %fp, -184, %o2
400127d4: 92 07 bf 7c add %fp, -132, %o1
400127d8: 40 00 20 a4 call 4001aa68 <rtems_rfs_bitmap_open>
400127dc: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
400127e0: ac 92 20 00 orcc %o0, 0, %l6
400127e4: 04 80 00 1f ble 40012860 <rtems_rfs_format+0x8c4>
<== ALWAYS TAKEN
400127e8: 92 07 bf 48 add %fp, -184, %o1
rtems_rfs_buffer_handle_release (fs, handle);
400127ec: 40 00 26 79 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400127f0: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
400127f4: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
handle->dirty = false;
400127f8: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
400127fc: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40012800: 40 00 41 63 call 40022d8c <strerror>
<== NOT EXECUTED
40012804: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40012808: 94 10 00 16 mov %l6, %o2
<== NOT EXECUTED
4001280c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40012810: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012814: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012818: 40 00 0a 94 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001281c: 90 12 20 70 or %o0, 0x70, %o0 ! 40031c70 <_Thread_queue_Operations_default+0x43c>
<== NOT EXECUTED
config->initialise_inodes, config->verbose))
{
errno = EIO;
40012820: 40 00 39 12 call 40020c68 <__errno>
<== NOT EXECUTED
40012824: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012828: 82 10 20 05 mov 5, %g1
<== NOT EXECUTED
4001282c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40012830: 81 c7 e0 08 ret
<== NOT EXECUTED
40012834: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40012838: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001283c: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012840: 40 00 0a 8a call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012844: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 40031be8 <_Thread_queue_Operations_default+0x3b4>
<== NOT EXECUTED
errno = EIO;
40012848: 40 00 39 08 call 40020c68 <__errno>
<== NOT EXECUTED
4001284c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012850: 82 10 20 05 mov 5, %g1
<== NOT EXECUTED
40012854: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40012858: 81 c7 e0 08 ret
<== NOT EXECUTED
4001285c: 81 e8 00 00 restore
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40012860: c2 07 bf 50 ld [ %fp + -176 ], %g1
40012864: d4 07 bf 84 ld [ %fp + -124 ], %o2
40012868: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001286c: 40 00 3c a2 call 40021af4 <memset>
40012870: 92 10 20 ff mov 0xff, %o1
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40012874: 40 00 1f c9 call 4001a798 <rtems_rfs_bitmap_map_clear_all>
40012878: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
4001287c: ac 92 20 00 orcc %o0, 0, %l6
40012880: 04 80 00 1e ble 400128f8 <rtems_rfs_format+0x95c>
<== ALWAYS TAKEN
40012884: 92 10 20 00 clr %o1
rtems_rfs_bitmap_close (&bitmap);
40012888: 40 00 20 89 call 4001aaac <rtems_rfs_bitmap_close>
<== NOT EXECUTED
4001288c: 90 07 bf 54 add %fp, -172, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40012890: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40012894: 40 00 26 4f call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40012898: 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",
4001289c: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
handle->dirty = false;
400128a0: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
400128a4: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
400128a8: 40 00 41 39 call 40022d8c <strerror>
<== NOT EXECUTED
400128ac: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
400128b0: 94 10 00 16 mov %l6, %o2
<== NOT EXECUTED
400128b4: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
400128b8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400128bc: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
400128c0: 40 00 0a 6a call 40015268 <__wrap_printf>
<== NOT EXECUTED
400128c4: 90 12 20 b8 or %o0, 0xb8, %o0 ! 40031cb8 <_Thread_queue_Operations_default+0x484>
<== NOT EXECUTED
400128c8: 30 bf ff d6 b,a 40012820 <rtems_rfs_format+0x884>
<== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400128cc: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
400128d0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400128d4: 40 00 0a 65 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400128d8: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
printf (", blocks");
400128dc: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
handle->dirty = false;
400128e0: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
400128e4: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
400128e8: 40 00 0a 60 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400128ec: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
400128f0: 10 bf ff b7 b 400127cc <rtems_rfs_format+0x830>
<== NOT EXECUTED
400128f4: 98 10 00 1c mov %i4, %o4
<== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
400128f8: 40 00 1f 5c call 4001a668 <rtems_rfs_bitmap_map_set>
400128fc: 90 07 bf 54 add %fp, -172, %o0
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
40012900: 92 10 20 01 mov 1, %o1
40012904: 40 00 1f 59 call 4001a668 <rtems_rfs_bitmap_map_set>
40012908: 90 07 bf 54 add %fp, -172, %o0
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
4001290c: c2 07 bf a8 ld [ %fp + -88 ], %g1
if (dividend == 0)
40012910: 80 a0 60 00 cmp %g1, 0
40012914: 02 80 00 74 be 40012ae4 <rtems_rfs_format+0xb48>
<== NEVER TAKEN
40012918: 92 10 20 02 mov 2, %o1
return ((dividend - 1) / divisor) + 1;
4001291c: 82 00 7f ff add %g1, -1, %g1
40012920: 81 80 20 00 wr %g0, %y
40012924: ee 07 bf ac ld [ %fp + -84 ], %l7
40012928: 01 00 00 00 nop
4001292c: 01 00 00 00 nop
40012930: ae 70 40 17 udiv %g1, %l7, %l7
40012934: ac 05 e0 01 add %l7, 1, %l6
for (b = 0; b < blocks; b++)
40012938: 80 a5 a0 00 cmp %l6, 0
4001293c: 04 80 00 0a ble 40012964 <rtems_rfs_format+0x9c8>
<== NEVER TAKEN
40012940: ae 05 e0 03 add %l7, 3, %l7
40012944: a8 10 20 02 mov 2, %l4
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40012948: 92 10 00 14 mov %l4, %o1
4001294c: 40 00 1f 47 call 4001a668 <rtems_rfs_bitmap_map_set>
40012950: 90 07 bf 54 add %fp, -172, %o0
40012954: a8 05 20 01 inc %l4
for (b = 0; b < blocks; b++)
40012958: 80 a5 c0 14 cmp %l7, %l4
4001295c: 12 bf ff fc bne 4001294c <rtems_rfs_format+0x9b0>
<== NEVER TAKEN
40012960: 92 10 00 14 mov %l4, %o1
rc = rtems_rfs_bitmap_close (&bitmap);
40012964: 40 00 20 52 call 4001aaac <rtems_rfs_bitmap_close>
40012968: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
4001296c: ae 92 20 00 orcc %o0, 0, %l7
40012970: 14 80 00 66 bg 40012b08 <rtems_rfs_format+0xb6c>
<== NEVER TAKEN
40012974: 92 07 bf 48 add %fp, -184, %o1
if (verbose)
40012978: 80 a6 a0 00 cmp %i2, 0
4001297c: 12 80 00 9f bne 40012bf8 <rtems_rfs_format+0xc5c>
<== NEVER TAKEN
40012980: e6 2f bf 48 stb %l3, [ %fp + -184 ]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40012984: 96 10 00 1b mov %i3, %o3
40012988: 98 04 20 02 add %l0, 2, %o4
4001298c: 94 07 bf 48 add %fp, -184, %o2
40012990: 92 07 bf 7c add %fp, -132, %o1
40012994: 40 00 20 35 call 4001aa68 <rtems_rfs_bitmap_open>
40012998: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
4001299c: b6 92 20 00 orcc %o0, 0, %i3
400129a0: 04 80 00 7a ble 40012b88 <rtems_rfs_format+0xbec>
<== ALWAYS TAKEN
400129a4: 92 07 bf 48 add %fp, -184, %o1
rtems_rfs_buffer_handle_release (fs, handle);
400129a8: 40 00 26 0a call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400129ac: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400129b0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
400129b4: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
400129b8: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
400129bc: 40 00 40 f4 call 40022d8c <strerror>
<== NOT EXECUTED
400129c0: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
400129c4: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
400129c8: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
400129cc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400129d0: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
400129d4: 40 00 0a 25 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400129d8: 90 12 21 60 or %o0, 0x160, %o0 ! 40031d60 <_Thread_queue_Operations_default+0x52c>
<== NOT EXECUTED
400129dc: 30 bf ff 91 b,a 40012820 <rtems_rfs_format+0x884>
<== NOT EXECUTED
}
if (config->verbose)
400129e0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
400129e4: 80 a0 60 00 cmp %g1, 0
400129e8: 12 80 00 65 bne 40012b7c <rtems_rfs_format+0xbe0>
<== NEVER TAKEN
400129ec: 01 00 00 00 nop
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
400129f0: 40 00 26 f4 call 4001c5c0 <rtems_rfs_buffer_close>
400129f4: 90 07 bf 7c add %fp, -132, %o0
if (rc != 0)
400129f8: ba 92 20 00 orcc %o0, 0, %i5
400129fc: 12 80 01 41 bne 40012f00 <rtems_rfs_format+0xf64>
<== NEVER TAKEN
40012a00: 98 07 bf 44 add %fp, -188, %o4
rc = rtems_rfs_fs_open (name, NULL,
40012a04: 96 10 20 00 clr %o3
40012a08: 94 10 20 06 mov 6, %o2
40012a0c: 92 10 20 00 clr %o1
40012a10: 40 00 30 41 call 4001eb14 <rtems_rfs_fs_open>
40012a14: 90 10 00 18 mov %i0, %o0
if (rc != 0)
40012a18: 80 a2 20 00 cmp %o0, 0
40012a1c: 12 80 00 49 bne 40012b40 <rtems_rfs_format+0xba4>
<== NEVER TAKEN
40012a20: 94 07 bf 48 add %fp, -184, %o2
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
40012a24: d0 07 bf 44 ld [ %fp + -188 ], %o0
40012a28: 40 00 03 17 call 40013684 <rtems_rfs_inode_alloc>
40012a2c: 92 10 20 01 mov 1, %o1
if (rc != 0)
40012a30: b0 92 20 00 orcc %o0, 0, %i0
40012a34: 12 80 00 87 bne 40012c50 <rtems_rfs_format+0xcb4>
<== NEVER TAKEN
40012a38: d2 07 bf 48 ld [ %fp + -184 ], %o1
if (ino != RTEMS_RFS_ROOT_INO)
40012a3c: 80 a2 60 01 cmp %o1, 1
40012a40: 12 80 00 72 bne 40012c08 <rtems_rfs_format+0xc6c>
<== NEVER TAKEN
40012a44: 96 10 20 01 mov 1, %o3
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40012a48: d0 07 bf 44 ld [ %fp + -188 ], %o0
40012a4c: 94 07 bf 54 add %fp, -172, %o2
40012a50: 40 00 03 44 call 40013760 <rtems_rfs_inode_open>
40012a54: 92 10 20 01 mov 1, %o1
if (rc != 0)
40012a58: b0 92 20 00 orcc %o0, 0, %i0
40012a5c: 12 80 00 fa bne 40012e44 <rtems_rfs_format+0xea8>
<== NEVER TAKEN
40012a60: 98 10 20 00 clr %o4
rc = rtems_rfs_inode_initialise (&inode, 0,
40012a64: 96 10 20 00 clr %o3
40012a68: 92 10 20 00 clr %o1
40012a6c: 15 00 00 10 sethi %hi(0x4000), %o2
40012a70: 90 07 bf 54 add %fp, -172, %o0
40012a74: 40 00 04 4b call 40013ba0 <rtems_rfs_inode_initialise>
40012a78: 94 12 a1 c9 or %o2, 0x1c9, %o2
if (rc != 0)
40012a7c: ba 92 20 00 orcc %o0, 0, %i5
40012a80: 12 80 00 d7 bne 40012ddc <rtems_rfs_format+0xe40>
<== NEVER TAKEN
40012a84: 01 00 00 00 nop
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40012a88: d8 07 bf 48 ld [ %fp + -184 ], %o4
40012a8c: d0 07 bf 44 ld [ %fp + -188 ], %o0
40012a90: 96 10 20 01 mov 1, %o3
40012a94: 92 07 bf 54 add %fp, -172, %o1
40012a98: 15 10 00 c0 sethi %hi(0x40030000), %o2
40012a9c: 40 00 28 52 call 4001cbe4 <rtems_rfs_dir_add_entry>
40012aa0: 94 12 a3 80 or %o2, 0x380, %o2 ! 40030380 <rtems_test_name+0x10>
if (rc != 0)
40012aa4: ba 92 20 00 orcc %o0, 0, %i5
40012aa8: 12 80 00 c4 bne 40012db8 <rtems_rfs_format+0xe1c>
<== NEVER TAKEN
40012aac: 01 00 00 00 nop
rc = rtems_rfs_inode_close (fs, &inode);
40012ab0: d0 07 bf 44 ld [ %fp + -188 ], %o0
40012ab4: 40 00 03 a2 call 4001393c <rtems_rfs_inode_close>
40012ab8: 92 07 bf 54 add %fp, -172, %o1
if (rc != 0)
40012abc: ba 92 20 00 orcc %o0, 0, %i5
40012ac0: 12 80 00 b6 bne 40012d98 <rtems_rfs_format+0xdfc>
<== NEVER TAKEN
40012ac4: 01 00 00 00 nop
rc = rtems_rfs_fs_close (fs);
40012ac8: 40 00 32 1d call 4001f33c <rtems_rfs_fs_close>
40012acc: d0 07 bf 44 ld [ %fp + -188 ], %o0
if (rc != 0)
40012ad0: b0 92 20 00 orcc %o0, 0, %i0
40012ad4: 12 80 00 a5 bne 40012d68 <rtems_rfs_format+0xdcc>
<== NEVER TAKEN
40012ad8: 01 00 00 00 nop
errno = rc;
return -1;
}
return 0;
}
40012adc: 81 c7 e0 08 ret
40012ae0: 81 e8 00 00 restore
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40012ae4: 40 00 1e e1 call 4001a668 <rtems_rfs_bitmap_map_set>
<== NOT EXECUTED
40012ae8: 90 07 bf 54 add %fp, -172, %o0
<== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
40012aec: 90 07 bf 54 add %fp, -172, %o0
<== NOT EXECUTED
40012af0: 40 00 1f ef call 4001aaac <rtems_rfs_bitmap_close>
<== NOT EXECUTED
40012af4: ac 10 20 01 mov 1, %l6
<== NOT EXECUTED
if (rc > 0)
40012af8: ae 92 20 00 orcc %o0, 0, %l7
<== NOT EXECUTED
40012afc: 04 bf ff a0 ble 4001297c <rtems_rfs_format+0x9e0>
<== NOT EXECUTED
40012b00: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40012b04: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40012b08: 40 00 25 b2 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40012b0c: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40012b10: 90 10 00 17 mov %l7, %o0
<== NOT EXECUTED
handle->dirty = false;
40012b14: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40012b18: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40012b1c: 40 00 40 9c call 40022d8c <strerror>
<== NOT EXECUTED
40012b20: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40012b24: 94 10 00 17 mov %l7, %o2
<== NOT EXECUTED
40012b28: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40012b2c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012b30: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012b34: 40 00 09 cd call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012b38: 90 12 21 08 or %o0, 0x108, %o0 ! 40031d08 <_Thread_queue_Operations_default+0x4d4>
<== NOT EXECUTED
40012b3c: 30 bf ff 39 b,a 40012820 <rtems_rfs_format+0x884>
<== NOT EXECUTED
rc = errno;
40012b40: 40 00 38 4a call 40020c68 <__errno>
<== NOT EXECUTED
40012b44: 01 00 00 00 nop
<== NOT EXECUTED
40012b48: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
40012b4c: 40 00 40 90 call 40022d8c <strerror>
<== NOT EXECUTED
40012b50: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40012b54: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40012b58: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012b5c: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012b60: 40 00 09 c2 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012b64: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40031eb8 <_Thread_queue_Operations_default+0x684>
<== NOT EXECUTED
if (rc != 0)
40012b68: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40012b6c: 12 80 00 2d bne 40012c20 <rtems_rfs_format+0xc84>
<== NOT EXECUTED
40012b70: 01 00 00 00 nop
<== NOT EXECUTED
}
40012b74: 81 c7 e0 08 ret
<== NOT EXECUTED
40012b78: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("\n");
40012b7c: 40 00 09 d0 call 400152bc <__wrap_putchar>
<== NOT EXECUTED
40012b80: 90 10 20 0a mov 0xa, %o0
<== NOT EXECUTED
40012b84: 30 bf ff 9b b,a 400129f0 <rtems_rfs_format+0xa54>
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
40012b88: c2 07 bf 50 ld [ %fp + -176 ], %g1
40012b8c: d4 07 bf 84 ld [ %fp + -124 ], %o2
40012b90: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40012b94: 40 00 3b d8 call 40021af4 <memset>
40012b98: 92 10 20 00 clr %o1
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40012b9c: 40 00 1e ff call 4001a798 <rtems_rfs_bitmap_map_clear_all>
40012ba0: 90 07 bf 54 add %fp, -172, %o0
40012ba4: b6 10 00 08 mov %o0, %i3
if (rc > 0)
40012ba8: 80 a6 e0 00 cmp %i3, 0
40012bac: 04 80 00 33 ble 40012c78 <rtems_rfs_format+0xcdc>
<== ALWAYS TAKEN
40012bb0: 90 07 bf 54 add %fp, -172, %o0
rtems_rfs_bitmap_close (&bitmap);
40012bb4: 40 00 1f be call 4001aaac <rtems_rfs_bitmap_close>
<== NOT EXECUTED
40012bb8: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40012bbc: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40012bc0: 40 00 25 84 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40012bc4: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
40012bc8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40012bcc: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40012bd0: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40012bd4: 40 00 40 6e call 40022d8c <strerror>
<== NOT EXECUTED
40012bd8: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40012bdc: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40012be0: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40012be4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012be8: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012bec: 40 00 09 9f call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012bf0: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 40031da8 <_Thread_queue_Operations_default+0x574>
<== NOT EXECUTED
40012bf4: 30 bf ff 0b b,a 40012820 <rtems_rfs_format+0x884>
<== NOT EXECUTED
printf (", inodes");
40012bf8: 40 00 09 9c call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012bfc: d0 07 bf 3c ld [ %fp + -196 ], %o0
<== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40012c00: 10 bf ff 62 b 40012988 <rtems_rfs_format+0x9ec>
<== NOT EXECUTED
40012c04: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40012c08: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012c0c: 40 00 09 97 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012c10: 90 12 23 28 or %o0, 0x328, %o0 ! 40031f28 <_Thread_queue_Operations_default+0x6f4>
<== NOT EXECUTED
rtems_rfs_fs_close (fs);
40012c14: 40 00 31 ca call 4001f33c <rtems_rfs_fs_close>
<== NOT EXECUTED
40012c18: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
return EINVAL;
40012c1c: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
40012c20: 40 00 40 5b call 40022d8c <strerror>
<== NOT EXECUTED
40012c24: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40012c28: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40012c2c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012c30: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40012c34: 40 00 09 8d call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012c38: 90 12 20 68 or %o0, 0x68, %o0 ! 40032068 <_Thread_queue_Operations_default+0x834>
<== NOT EXECUTED
errno = rc;
40012c3c: 40 00 38 0b call 40020c68 <__errno>
<== NOT EXECUTED
40012c40: 01 00 00 00 nop
<== NOT EXECUTED
40012c44: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
return -1;
40012c48: 81 c7 e0 08 ret
<== NOT EXECUTED
40012c4c: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
40012c50: 40 00 40 4f call 40022d8c <strerror>
<== NOT EXECUTED
40012c54: 01 00 00 00 nop
<== NOT EXECUTED
40012c58: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40012c5c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012c60: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012c64: 40 00 09 81 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012c68: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40031ef0 <_Thread_queue_Operations_default+0x6bc>
<== NOT EXECUTED
rtems_rfs_fs_close (fs);
40012c6c: 40 00 31 b4 call 4001f33c <rtems_rfs_fs_close>
<== NOT EXECUTED
40012c70: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
40012c74: 30 bf ff eb b,a 40012c20 <rtems_rfs_format+0xc84>
<== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
40012c78: 40 00 1f 8d call 4001aaac <rtems_rfs_bitmap_close>
40012c7c: 01 00 00 00 nop
if (rc > 0)
40012c80: b6 92 20 00 orcc %o0, 0, %i3
40012c84: 14 80 00 2a bg 40012d2c <rtems_rfs_format+0xd90>
<== NEVER TAKEN
40012c88: 80 8d 60 ff btst 0xff, %l5
if (initialise_inodes)
40012c8c: 02 80 00 5d be 40012e00 <rtems_rfs_format+0xe64>
<== ALWAYS TAKEN
40012c90: e6 2f bf 48 stb %l3, [ %fp + -184 ]
for (b = 0; b < blocks; b++)
40012c94: 80 a5 a0 00 cmp %l6, 0
<== NOT EXECUTED
40012c98: 04 80 00 5a ble 40012e00 <rtems_rfs_format+0xe64>
<== NOT EXECUTED
40012c9c: b8 07 20 02 add %i4, 2, %i4
<== NOT EXECUTED
40012ca0: 10 80 00 0a b 40012cc8 <rtems_rfs_format+0xd2c>
<== NOT EXECUTED
40012ca4: ac 05 80 1c add %l6, %i4, %l6
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40012ca8: c2 07 bf 50 ld [ %fp + -176 ], %g1
<== NOT EXECUTED
40012cac: d4 07 bf 84 ld [ %fp + -124 ], %o2
<== NOT EXECUTED
40012cb0: 40 00 3b 91 call 40021af4 <memset>
<== NOT EXECUTED
40012cb4: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
<== NOT EXECUTED
40012cb8: b8 07 20 01 inc %i4
<== NOT EXECUTED
for (b = 0; b < blocks; b++)
40012cbc: 80 a5 80 1c cmp %l6, %i4
<== NOT EXECUTED
40012cc0: 02 80 00 50 be 40012e00 <rtems_rfs_format+0xe64>
<== NOT EXECUTED
40012cc4: e6 2f bf 48 stb %l3, [ %fp + -184 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40012cc8: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40012ccc: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40012cd0: 96 10 20 00 clr %o3
<== NOT EXECUTED
40012cd4: 40 00 24 78 call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
40012cd8: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40012cdc: 92 10 20 ff mov 0xff, %o1
<== NOT EXECUTED
if (rc > 0)
40012ce0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012ce4: 04 bf ff f1 ble 40012ca8 <rtems_rfs_format+0xd0c>
<== NOT EXECUTED
40012ce8: b6 10 00 08 mov %o0, %i3
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40012cec: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40012cf0: 40 00 25 38 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40012cf4: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40012cf8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40012cfc: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40012d00: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40012d04: 40 00 40 22 call 40022d8c <strerror>
<== NOT EXECUTED
40012d08: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40012d0c: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
40012d10: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
40012d14: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40012d18: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012d1c: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012d20: 40 00 09 52 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012d24: 90 12 22 40 or %o0, 0x240, %o0 ! 40031e40 <_Thread_queue_Operations_default+0x60c>
<== NOT EXECUTED
40012d28: 30 bf fe be b,a 40012820 <rtems_rfs_format+0x884>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40012d2c: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40012d30: 40 00 25 28 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40012d34: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
40012d38: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40012d3c: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40012d40: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40012d44: 40 00 40 12 call 40022d8c <strerror>
<== NOT EXECUTED
40012d48: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40012d4c: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40012d50: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40012d54: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012d58: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012d5c: 40 00 09 43 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012d60: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 40031df8 <_Thread_queue_Operations_default+0x5c4>
<== NOT EXECUTED
40012d64: 30 bf fe af b,a 40012820 <rtems_rfs_format+0x884>
<== NOT EXECUTED
rc = errno;
40012d68: 40 00 37 c0 call 40020c68 <__errno>
<== NOT EXECUTED
40012d6c: 01 00 00 00 nop
<== NOT EXECUTED
40012d70: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
40012d74: 40 00 40 06 call 40022d8c <strerror>
<== NOT EXECUTED
40012d78: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40012d7c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40012d80: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012d84: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40012d88: 40 00 09 38 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012d8c: 90 12 20 30 or %o0, 0x30, %o0 ! 40032030 <_Thread_queue_Operations_default+0x7fc>
<== NOT EXECUTED
if (rc != 0)
40012d90: 10 bf ff 77 b 40012b6c <rtems_rfs_format+0xbd0>
<== NOT EXECUTED
40012d94: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40012d98: 40 00 3f fd call 40022d8c <strerror>
<== NOT EXECUTED
40012d9c: 01 00 00 00 nop
<== NOT EXECUTED
40012da0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012da4: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012da8: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40012dac: 40 00 09 2f call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012db0: 90 12 20 00 mov %o0, %o0 ! 40032000 <_Thread_queue_Operations_default+0x7cc>
<== NOT EXECUTED
40012db4: 30 bf ff 45 b,a 40012ac8 <rtems_rfs_format+0xb2c>
<== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40012db8: 40 00 3f f5 call 40022d8c <strerror>
<== NOT EXECUTED
40012dbc: 01 00 00 00 nop
<== NOT EXECUTED
40012dc0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012dc4: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012dc8: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012dcc: 40 00 09 27 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012dd0: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40031fc8 <_Thread_queue_Operations_default+0x794>
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
40012dd4: 10 bf ff 38 b 40012ab4 <rtems_rfs_format+0xb18>
<== NOT EXECUTED
40012dd8: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
40012ddc: 40 00 3f ec call 40022d8c <strerror>
<== NOT EXECUTED
40012de0: 01 00 00 00 nop
<== NOT EXECUTED
40012de4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012de8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012dec: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012df0: 40 00 09 1e call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012df4: 90 12 23 90 or %o0, 0x390, %o0 ! 40031f90 <_Thread_queue_Operations_default+0x75c>
<== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40012df8: 10 bf ff 25 b 40012a8c <rtems_rfs_format+0xaf0>
<== NOT EXECUTED
40012dfc: d8 07 bf 48 ld [ %fp + -184 ], %o4
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40012e00: 92 07 bf 48 add %fp, -184, %o1
40012e04: 40 00 24 f3 call 4001c1d0 <rtems_rfs_buffer_handle_release>
40012e08: 90 07 bf 7c add %fp, -132, %o0
for (group = 0; group < fs.group_count; group++)
40012e0c: c2 07 bf a0 ld [ %fp + -96 ], %g1
40012e10: ba 07 60 01 inc %i5
40012e14: 80 a0 40 1d cmp %g1, %i5
40012e18: 04 bf fe f2 ble 400129e0 <rtems_rfs_format+0xa44>
<== ALWAYS TAKEN
40012e1c: f6 07 bf a4 ld [ %fp + -92 ], %i3
if (group_base > rtems_rfs_fs_blocks (fs))
40012e20: c2 07 bf 80 ld [ %fp + -128 ], %g1
<== NOT EXECUTED
group_base = rtems_rfs_fs_block (fs, group, 0);
40012e24: a0 5f 40 1b smul %i5, %i3, %l0
<== NOT EXECUTED
40012e28: b8 04 20 01 add %l0, 1, %i4
<== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
40012e2c: 80 a7 00 01 cmp %i4, %g1
<== NOT EXECUTED
40012e30: 18 bf fe 83 bgu 4001283c <rtems_rfs_format+0x8a0>
<== NOT EXECUTED
40012e34: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
40012e38: ea 0e 60 14 ldub [ %i1 + 0x14 ], %l5
<== NOT EXECUTED
40012e3c: 10 bf fe 59 b 400127a0 <rtems_rfs_format+0x804>
<== NOT EXECUTED
40012e40: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
40012e44: 40 00 3f d2 call 40022d8c <strerror>
<== NOT EXECUTED
40012e48: 01 00 00 00 nop
<== NOT EXECUTED
40012e4c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40012e50: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012e54: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012e58: 40 00 09 04 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012e5c: 90 12 23 60 or %o0, 0x360, %o0 ! 40031f60 <_Thread_queue_Operations_default+0x72c>
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
40012e60: d4 07 bf 48 ld [ %fp + -184 ], %o2
<== NOT EXECUTED
40012e64: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
40012e68: 40 00 01 9a call 400134d0 <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40012e6c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_rfs_fs_close (fs);
40012e70: 40 00 31 33 call 4001f33c <rtems_rfs_fs_close>
<== NOT EXECUTED
40012e74: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
40012e78: 30 bf ff 6a b,a 40012c20 <rtems_rfs_format+0xc84>
<== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
40012e7c: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012e80: 40 00 08 fa call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012e84: 90 12 20 90 or %o0, 0x90, %o0 ! 40031890 <_Thread_queue_Operations_default+0x5c>
<== NOT EXECUTED
errno = EINVAL;
40012e88: 40 00 37 78 call 40020c68 <__errno>
<== NOT EXECUTED
40012e8c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012e90: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40012e94: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40012e98: 81 c7 e0 08 ret
<== NOT EXECUTED
40012e9c: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
40012ea0: 40 00 3f bb call 40022d8c <strerror>
<== NOT EXECUTED
40012ea4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012ea8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012eac: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012eb0: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012eb4: 40 00 08 ed call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012eb8: 90 12 23 08 or %o0, 0x308, %o0 ! 40031b08 <_Thread_queue_Operations_default+0x2d4>
<== NOT EXECUTED
errno = rc;
40012ebc: 40 00 37 6b call 40020c68 <__errno>
<== NOT EXECUTED
40012ec0: 01 00 00 00 nop
<== NOT EXECUTED
40012ec4: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
40012ec8: 81 c7 e0 08 ret
<== NOT EXECUTED
40012ecc: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
40012ed0: 40 00 3f af call 40022d8c <strerror>
<== NOT EXECUTED
40012ed4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012ed8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012edc: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012ee0: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40012ee4: 40 00 08 e1 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012ee8: 90 12 20 60 or %o0, 0x60, %o0 ! 40031860 <_Thread_queue_Operations_default+0x2c>
<== NOT EXECUTED
errno = rc;
40012eec: 40 00 37 5f call 40020c68 <__errno>
<== NOT EXECUTED
40012ef0: 01 00 00 00 nop
<== NOT EXECUTED
40012ef4: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
40012ef8: 81 c7 e0 08 ret
<== NOT EXECUTED
40012efc: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
40012f00: 40 00 3f a3 call 40022d8c <strerror>
<== NOT EXECUTED
40012f04: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012f08: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012f0c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012f10: 11 10 00 c7 sethi %hi(0x40031c00), %o0
<== NOT EXECUTED
40012f14: 40 00 08 d5 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40012f18: 90 12 22 88 or %o0, 0x288, %o0 ! 40031e88 <_Thread_queue_Operations_default+0x654>
<== NOT EXECUTED
errno = rc;
40012f1c: 40 00 37 53 call 40020c68 <__errno>
<== NOT EXECUTED
40012f20: 01 00 00 00 nop
<== NOT EXECUTED
40012f24: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
40012f28: 81 c7 e0 08 ret
<== NOT EXECUTED
40012f2c: 81 e8 00 00 restore
<== NOT EXECUTED
4001f33c <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001f33c: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
4001f340: 90 10 20 00 clr %o0
4001f344: 92 10 20 02 mov 2, %o1
4001f348: 7f ff d7 3b call 40015034 <rtems_rfs_trace>
4001f34c: ba 10 00 18 mov %i0, %i5
4001f350: 80 a2 20 00 cmp %o0, 0
4001f354: 12 80 00 18 bne 4001f3b4 <rtems_rfs_fs_close+0x78>
<== NEVER TAKEN
4001f358: 11 10 00 ce sethi %hi(0x40033800), %o0
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
4001f35c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4001f360: 80 a0 60 00 cmp %g1, 0
4001f364: 04 80 00 0d ble 4001f398 <rtems_rfs_fs_close+0x5c>
<== NEVER TAKEN
4001f368: 01 00 00 00 nop
4001f36c: b6 10 20 00 clr %i3 ! 0 <PROM_START>
4001f370: b8 10 20 00 clr %i4
rtems_rfs_group_close (fs, &fs->groups[group]);
4001f374: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
4001f378: 92 02 40 1b add %o1, %i3, %o1
4001f37c: 7f ff cf 7b call 40013168 <rtems_rfs_group_close>
4001f380: 90 10 00 1d mov %i5, %o0
for (group = 0; group < fs->group_count; group++)
4001f384: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4001f388: b8 07 20 01 inc %i4
4001f38c: 80 a0 40 1c cmp %g1, %i4
4001f390: 14 bf ff f9 bg 4001f374 <rtems_rfs_fs_close+0x38>
<== NEVER TAKEN
4001f394: b6 06 e0 50 add %i3, 0x50, %i3
rtems_rfs_buffer_close (fs);
4001f398: 7f ff f4 8a call 4001c5c0 <rtems_rfs_buffer_close>
4001f39c: 90 10 00 1d mov %i5, %o0
free (fs);
return 0;
}
4001f3a0: b0 10 20 00 clr %i0
free (fs);
4001f3a4: 7f ff a8 1c call 40009414 <free>
4001f3a8: 90 10 00 1d mov %i5, %o0
}
4001f3ac: 81 c7 e0 08 ret
4001f3b0: 81 e8 00 00 restore
printf ("rtems-rfs: close\n");
4001f3b4: 7f ff d7 bc call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001f3b8: 90 12 23 d8 or %o0, 0x3d8, %o0
<== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
4001f3bc: 10 bf ff e9 b 4001f360 <rtems_rfs_fs_close+0x24>
<== NOT EXECUTED
4001f3c0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
<== NOT EXECUTED
4001eb14 <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)
{
4001eb14: 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))
4001eb18: 90 10 20 00 clr %o0
4001eb1c: 7f ff d9 46 call 40015034 <rtems_rfs_trace>
4001eb20: 92 10 20 01 mov 1, %o1
4001eb24: 80 a2 20 00 cmp %o0, 0
4001eb28: 12 80 00 ef bne 4001eee4 <rtems_rfs_fs_open+0x3d0>
<== NEVER TAKEN
4001eb2c: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
4001eb30: 7f ff ac 38 call 40009c10 <malloc>
4001eb34: 90 10 20 84 mov 0x84, %o0
4001eb38: d0 27 00 00 st %o0, [ %i4 ]
if (!*fs)
4001eb3c: 80 a2 20 00 cmp %o0, 0
4001eb40: 02 80 01 e1 be 4001f2c4 <rtems_rfs_fs_open+0x7b0>
<== NEVER TAKEN
4001eb44: 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));
4001eb48: 94 10 20 7c mov 0x7c, %o2
4001eb4c: 92 10 20 00 clr %o1
4001eb50: 40 00 0b e9 call 40021af4 <memset>
4001eb54: 90 02 20 04 add %o0, 4, %o0
return &the_chain->Tail.Node;
4001eb58: 84 07 60 44 add %i5, 0x44, %g2
4001eb5c: 82 07 60 48 add %i5, 0x48, %g1
tail->previous = head;
4001eb60: c4 27 60 4c st %g2, [ %i5 + 0x4c ]
return &the_chain->Tail.Node;
4001eb64: 84 07 60 54 add %i5, 0x54, %g2
head->next = tail;
4001eb68: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
return &the_chain->Tail.Node;
4001eb6c: 82 07 60 58 add %i5, 0x58, %g1
tail->previous = head;
4001eb70: c4 27 60 5c st %g2, [ %i5 + 0x5c ]
return &the_chain->Tail.Node;
4001eb74: 84 07 60 64 add %i5, 0x64, %g2
head->next = tail;
4001eb78: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
return &the_chain->Tail.Node;
4001eb7c: 82 07 60 68 add %i5, 0x68, %g1
tail->previous = head;
4001eb80: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
return &the_chain->Tail.Node;
4001eb84: 84 07 60 74 add %i5, 0x74, %g2
head->next = tail;
4001eb88: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
return &the_chain->Tail.Node;
4001eb8c: 82 07 60 78 add %i5, 0x78, %g1
(*fs)->user = user;
4001eb90: f2 27 60 80 st %i1, [ %i5 + 0x80 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001eb94: 92 10 00 1d mov %i5, %o1
tail->previous = head;
4001eb98: c4 27 60 7c st %g2, [ %i5 + 0x7c ]
4001eb9c: 90 10 00 18 mov %i0, %o0
head->next = tail;
4001eba0: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
4001eba4: f6 27 60 40 st %i3, [ %i5 + 0x40 ]
rc = rtems_rfs_buffer_open (name, *fs);
4001eba8: 7f ff f5 93 call 4001c1f4 <rtems_rfs_buffer_open>
4001ebac: f4 27 40 00 st %i2, [ %i5 ]
if (rc > 0)
4001ebb0: ba 92 20 00 orcc %o0, 0, %i5
4001ebb4: 14 80 01 7c bg 4001f1a4 <rtems_rfs_fs_open+0x690>
<== NEVER TAKEN
4001ebb8: 96 10 20 01 mov 1, %o3
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
4001ebbc: f6 07 00 00 ld [ %i4 ], %i3
handle->dirty = false;
4001ebc0: c0 2f bf d8 clrb [ %fp + -40 ]
handle->bnum = 0;
4001ebc4: c0 27 bf dc clr [ %fp + -36 ]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
4001ebc8: 94 10 20 00 clr %o2
handle->buffer = NULL;
4001ebcc: c0 27 bf e0 clr [ %fp + -32 ]
4001ebd0: 92 07 bf d8 add %fp, -40, %o1
4001ebd4: 7f ff f4 b8 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001ebd8: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001ebdc: ba 92 20 00 orcc %o0, 0, %i5
4001ebe0: 14 80 00 ac bg 4001ee90 <rtems_rfs_fs_open+0x37c>
<== NEVER TAKEN
4001ebe4: c2 07 bf e0 ld [ %fp + -32 ], %g1
sb = rtems_rfs_buffer_data (&handle);
4001ebe8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
4001ebec: c8 0f 40 00 ldub [ %i5 ], %g4
4001ebf0: c4 0f 60 01 ldub [ %i5 + 1 ], %g2
4001ebf4: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
4001ebf8: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
4001ebfc: 89 29 20 18 sll %g4, 0x18, %g4
4001ec00: 85 28 a0 10 sll %g2, 0x10, %g2
4001ec04: 84 10 80 04 or %g2, %g4, %g2
4001ec08: 83 28 60 08 sll %g1, 8, %g1
4001ec0c: 82 10 40 02 or %g1, %g2, %g1
4001ec10: 05 0a 02 48 sethi %hi(0x28092000), %g2
4001ec14: 82 10 c0 01 or %g3, %g1, %g1
4001ec18: 84 10 a0 01 or %g2, 1, %g2
4001ec1c: 80 a0 40 02 cmp %g1, %g2
4001ec20: 32 80 00 b5 bne,a 4001eef4 <rtems_rfs_fs_open+0x3e0>
<== NEVER TAKEN
4001ec24: 90 10 20 00 clr %o0
<== NOT EXECUTED
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
4001ec28: c8 0f 60 0c ldub [ %i5 + 0xc ], %g4
4001ec2c: c6 0f 60 0d ldub [ %i5 + 0xd ], %g3
4001ec30: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
4001ec34: c4 0f 60 0f ldub [ %i5 + 0xf ], %g2
4001ec38: 89 29 20 18 sll %g4, 0x18, %g4
4001ec3c: 87 28 e0 10 sll %g3, 0x10, %g3
4001ec40: 83 28 60 08 sll %g1, 8, %g1
4001ec44: 86 10 c0 04 or %g3, %g4, %g3
4001ec48: 82 10 40 03 or %g1, %g3, %g1
4001ec4c: 84 10 80 01 or %g2, %g1, %g2
4001ec50: c4 26 e0 04 st %g2, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001ec54: f2 0f 60 0b ldub [ %i5 + 0xb ], %i1
4001ec58: c8 0f 60 08 ldub [ %i5 + 8 ], %g4
4001ec5c: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
4001ec60: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
4001ec64: f4 06 e0 10 ld [ %i3 + 0x10 ], %i2
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001ec68: 89 29 20 18 sll %g4, 0x18, %g4
4001ec6c: 87 28 e0 10 sll %g3, 0x10, %g3
4001ec70: 83 28 60 08 sll %g1, 8, %g1
4001ec74: 86 10 c0 04 or %g3, %g4, %g3
4001ec78: 82 10 40 03 or %g1, %g3, %g1
4001ec7c: 82 16 40 01 or %i1, %g1, %g1
4001ec80: c2 26 e0 08 st %g1, [ %i3 + 8 ]
return blocks * block_size;
4001ec84: 86 50 80 01 umul %g2, %g1, %g3
4001ec88: 85 40 00 00 rd %y, %g2
return media_blocks * media_block_size;
4001ec8c: f0 06 a0 1c ld [ %i2 + 0x1c ], %i0
4001ec90: c8 06 a0 20 ld [ %i2 + 0x20 ], %g4
4001ec94: b2 56 00 04 umul %i0, %g4, %i1
4001ec98: b1 40 00 00 rd %y, %i0
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
4001ec9c: 80 a0 80 18 cmp %g2, %i0
4001eca0: 38 80 00 d0 bgu,a 4001efe0 <rtems_rfs_fs_open+0x4cc>
<== NEVER TAKEN
4001eca4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001eca8: 02 80 00 cb be 4001efd4 <rtems_rfs_fs_open+0x4c0>
<== ALWAYS TAKEN
4001ecac: 80 a0 c0 19 cmp %g3, %i1
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
4001ecb0: f4 0f 60 24 ldub [ %i5 + 0x24 ], %i2
<== NOT EXECUTED
4001ecb4: c6 0f 60 25 ldub [ %i5 + 0x25 ], %g3
4001ecb8: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
4001ecbc: c8 0f 60 27 ldub [ %i5 + 0x27 ], %g4
4001ecc0: b5 2e a0 18 sll %i2, 0x18, %i2
4001ecc4: 87 28 e0 10 sll %g3, 0x10, %g3
4001ecc8: 85 28 a0 08 sll %g2, 8, %g2
4001eccc: 86 10 c0 1a or %g3, %i2, %g3
4001ecd0: 84 10 80 03 or %g2, %g3, %g2
4001ecd4: 84 11 00 02 or %g4, %g2, %g2
4001ecd8: 80 a0 a0 38 cmp %g2, 0x38
4001ecdc: 32 80 00 a9 bne,a 4001ef80 <rtems_rfs_fs_open+0x46c>
<== NEVER TAKEN
4001ece0: 90 10 20 00 clr %o0
<== NOT EXECUTED
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
4001ece4: c8 0f 60 13 ldub [ %i5 + 0x13 ], %g4
4001ece8: f4 0f 60 10 ldub [ %i5 + 0x10 ], %i2
4001ecec: c6 0f 60 11 ldub [ %i5 + 0x11 ], %g3
4001ecf0: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
4001ecf4: b5 2e a0 18 sll %i2, 0x18, %i2
4001ecf8: 87 28 e0 10 sll %g3, 0x10, %g3
4001ecfc: 85 28 a0 08 sll %g2, 8, %g2
4001ed00: 86 10 c0 1a or %g3, %i2, %g3
4001ed04: 84 10 80 03 or %g2, %g3, %g2
4001ed08: 84 11 00 02 or %g4, %g2, %g2
4001ed0c: c4 26 e0 18 st %g2, [ %i3 + 0x18 ]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
4001ed10: 87 30 60 02 srl %g1, 2, %g3
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
4001ed14: f4 0f 60 17 ldub [ %i5 + 0x17 ], %i2
4001ed18: f2 0f 60 14 ldub [ %i5 + 0x14 ], %i1
4001ed1c: c8 0f 60 15 ldub [ %i5 + 0x15 ], %g4
4001ed20: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
4001ed24: b3 2e 60 18 sll %i1, 0x18, %i1
4001ed28: 89 29 20 10 sll %g4, 0x10, %g4
4001ed2c: 85 28 a0 08 sll %g2, 8, %g2
4001ed30: 88 11 00 19 or %g4, %i1, %g4
4001ed34: 84 10 80 04 or %g2, %g4, %g2
4001ed38: 84 16 80 02 or %i2, %g2, %g2
4001ed3c: c4 26 e0 1c st %g2, [ %i3 + 0x1c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001ed40: b2 58 c0 03 smul %g3, %g3, %i1
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
4001ed44: f0 0f 60 1b ldub [ %i5 + 0x1b ], %i0
4001ed48: f4 0f 60 18 ldub [ %i5 + 0x18 ], %i2
4001ed4c: c8 0f 60 19 ldub [ %i5 + 0x19 ], %g4
4001ed50: c4 0f 60 1a ldub [ %i5 + 0x1a ], %g2
4001ed54: b5 2e a0 18 sll %i2, 0x18, %i2
4001ed58: 89 29 20 10 sll %g4, 0x10, %g4
4001ed5c: 85 28 a0 08 sll %g2, 8, %g2
4001ed60: 88 11 00 1a or %g4, %i2, %g4
4001ed64: 84 10 80 04 or %g2, %g4, %g2
4001ed68: 84 16 00 02 or %i0, %g2, %g2
4001ed6c: c4 26 e0 24 st %g2, [ %i3 + 0x24 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001ed70: 9b 28 e0 02 sll %g3, 2, %o5
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
4001ed74: de 0f 60 1c ldub [ %i5 + 0x1c ], %o7
4001ed78: f4 0f 60 1d ldub [ %i5 + 0x1d ], %i2
4001ed7c: c8 0f 60 1e ldub [ %i5 + 0x1e ], %g4
4001ed80: f0 0f 60 1f ldub [ %i5 + 0x1f ], %i0
4001ed84: 9f 2b e0 18 sll %o7, 0x18, %o7
4001ed88: b5 2e a0 10 sll %i2, 0x10, %i2
4001ed8c: 89 29 20 08 sll %g4, 8, %g4
4001ed90: b4 16 80 0f or %i2, %o7, %i2
4001ed94: 88 11 00 1a or %g4, %i2, %g4
4001ed98: b0 16 00 04 or %i0, %g4, %i0
4001ed9c: f0 26 e0 28 st %i0, [ %i3 + 0x28 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001eda0: 9a 03 40 03 add %o5, %g3, %o5
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001eda4: d8 0f 60 20 ldub [ %i5 + 0x20 ], %o4
4001eda8: f4 0f 60 21 ldub [ %i5 + 0x21 ], %i2
4001edac: c8 0f 60 22 ldub [ %i5 + 0x22 ], %g4
4001edb0: de 0f 60 23 ldub [ %i5 + 0x23 ], %o7
4001edb4: 99 2b 20 18 sll %o4, 0x18, %o4
4001edb8: bb 2e a0 10 sll %i2, 0x10, %i5
4001edbc: ba 17 40 0c or %i5, %o4, %i5
4001edc0: 89 29 20 08 sll %g4, 8, %g4
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001edc4: b5 2e 60 02 sll %i1, 2, %i2
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001edc8: 88 11 00 1d or %g4, %i5, %g4
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001edcc: b2 06 80 19 add %i2, %i1, %i1
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001edd0: 88 13 c0 04 or %o7, %g4, %g4
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001edd4: bb 30 60 03 srl %g1, 3, %i5
fs->inodes = fs->group_count * fs->group_inodes;
4001edd8: 84 58 80 04 smul %g2, %g4, %g2
fs->blocks_per_block =
4001eddc: c6 26 e0 34 st %g3, [ %i3 + 0x34 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001ede0: 07 09 24 92 sethi %hi(0x24924800), %g3
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001ede4: c8 26 e0 2c st %g4, [ %i3 + 0x2c ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001ede8: 86 10 e1 25 or %g3, 0x125, %g3
fs->block_map_singly_blocks =
4001edec: da 26 e0 38 st %o5, [ %i3 + 0x38 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001edf0: 80 57 40 03 umul %i5, %g3, %g0
4001edf4: 87 40 00 00 rd %y, %g3
fs->block_map_doubly_blocks =
4001edf8: f2 26 e0 3c st %i1, [ %i3 + 0x3c ]
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
4001edfc: 83 28 60 03 sll %g1, 3, %g1
fs->inodes = fs->group_count * fs->group_inodes;
4001ee00: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
rtems_rfs_buffer_handle_release (fs, handle);
4001ee04: 92 07 bf d8 add %fp, -40, %o1
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001ee08: c6 26 e0 30 st %g3, [ %i3 + 0x30 ]
if (fs->group_blocks >
4001ee0c: 80 a6 00 01 cmp %i0, %g1
4001ee10: 18 80 00 46 bgu 4001ef28 <rtems_rfs_fs_open+0x414>
<== NEVER TAKEN
4001ee14: 90 10 00 1b mov %i3, %o0
4001ee18: 7f ff f4 ee call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001ee1c: 01 00 00 00 nop
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
4001ee20: d2 06 e0 08 ld [ %i3 + 8 ], %o1
4001ee24: 90 10 00 1b mov %i3, %o0
handle->dirty = false;
4001ee28: c0 2f bf d8 clrb [ %fp + -40 ]
handle->bnum = 0;
4001ee2c: c0 27 bf dc clr [ %fp + -36 ]
4001ee30: 7f ff f5 a3 call 4001c4bc <rtems_rfs_buffer_setblksize>
4001ee34: c0 27 bf e0 clr [ %fp + -32 ]
if (rc > 0)
4001ee38: ba 92 20 00 orcc %o0, 0, %i5
4001ee3c: 04 80 00 7b ble 4001f028 <rtems_rfs_fs_open+0x514>
<== ALWAYS TAKEN
4001ee40: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_buffer_handle_release (fs, handle);
4001ee44: 7f ff f4 e3 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001ee48: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ee4c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ee50: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001ee54: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
handle->bnum = 0;
4001ee58: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4001ee5c: 7f ff d8 76 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ee60: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001ee64: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ee68: 02 80 00 10 be 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001ee6c: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
4001ee70: 40 00 0f c7 call 40022d8c <strerror>
<== NOT EXECUTED
4001ee74: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001ee78: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001ee7c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001ee80: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001ee84: 7f ff d8 f9 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ee88: 90 12 22 58 or %o0, 0x258, %o0 ! 40033a58 <status_code_to_errno+0x1314>
<== NOT EXECUTED
4001ee8c: 30 80 00 07 b,a 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ee90: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ee94: 7f ff d8 68 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ee98: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001ee9c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001eea0: 12 80 00 30 bne 4001ef60 <rtems_rfs_fs_open+0x44c>
<== NOT EXECUTED
4001eea4: 01 00 00 00 nop
<== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
4001eea8: 7f ff f5 c6 call 4001c5c0 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001eeac: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001eeb0: 7f ff a9 59 call 40009414 <free>
<== NOT EXECUTED
4001eeb4: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001eeb8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001eebc: 7f ff d8 5e call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001eec0: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001eec4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001eec8: 12 80 00 50 bne 4001f008 <rtems_rfs_fs_open+0x4f4>
<== NOT EXECUTED
4001eecc: 01 00 00 00 nop
<== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
4001eed0: 40 00 07 66 call 40020c68 <__errno>
<== NOT EXECUTED
4001eed4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4001eed8: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
4001eedc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001eee0: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
4001eee4: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001eee8: 7f ff d8 e0 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001eeec: 90 12 20 98 or %o0, 0x98, %o0 ! 40033898 <status_code_to_errno+0x1154>
<== NOT EXECUTED
4001eef0: 30 bf ff 10 b,a 4001eb30 <rtems_rfs_fs_open+0x1c>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001eef4: 7f ff d8 50 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001eef8: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001eefc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ef00: 22 80 00 06 be,a 4001ef18 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001ef04: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
4001ef08: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001ef0c: 7f ff d8 e6 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001ef10: 90 12 21 48 or %o0, 0x148, %o0 ! 40033948 <status_code_to_errno+0x1204>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001ef14: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001ef18: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4001ef1c: 7f ff f4 ad call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001ef20: ba 10 20 05 mov 5, %i5
<== NOT EXECUTED
4001ef24: 30 bf ff e1 b,a 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001ef28: 7f ff f4 aa call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001ef2c: ba 10 20 05 mov 5, %i5
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ef30: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ef34: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001ef38: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
handle->bnum = 0;
4001ef3c: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4001ef40: 7f ff d8 3d call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ef44: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001ef48: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ef4c: 02 bf ff d7 be 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001ef50: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
4001ef54: 7f ff d8 d4 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001ef58: 90 12 22 10 or %o0, 0x210, %o0 ! 40033a10 <status_code_to_errno+0x12cc>
<== NOT EXECUTED
4001ef5c: 30 bf ff d3 b,a 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
4001ef60: 40 00 0f 8b call 40022d8c <strerror>
<== NOT EXECUTED
4001ef64: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001ef68: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001ef6c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001ef70: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001ef74: 7f ff d8 bd call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001ef78: 90 12 21 10 or %o0, 0x110, %o0 ! 40033910 <status_code_to_errno+0x11cc>
<== NOT EXECUTED
4001ef7c: 30 bf ff cb b,a 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ef80: 7f ff d8 2d call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001ef84: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001ef88: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ef8c: 22 bf ff e3 be,a 4001ef18 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001ef90: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001ef94: c6 0f 60 04 ldub [ %i5 + 4 ], %g3
<== NOT EXECUTED
4001ef98: c4 0f 60 05 ldub [ %i5 + 5 ], %g2
<== NOT EXECUTED
4001ef9c: c2 0f 60 06 ldub [ %i5 + 6 ], %g1
<== NOT EXECUTED
4001efa0: d2 0f 60 07 ldub [ %i5 + 7 ], %o1
<== NOT EXECUTED
4001efa4: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
4001efa8: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001efac: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001efb0: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
4001efb4: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
4001efb8: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001efbc: 92 12 40 01 or %o1, %g1, %o1
<== NOT EXECUTED
4001efc0: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001efc4: 7f ff d8 a9 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001efc8: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 400339c8 <status_code_to_errno+0x1284>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001efcc: 10 bf ff d3 b 4001ef18 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001efd0: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
4001efd4: 28 bf ff 38 bleu,a 4001ecb4 <rtems_rfs_fs_open+0x1a0>
<== ALWAYS TAKEN
4001efd8: f4 0f 60 24 ldub [ %i5 + 0x24 ], %i2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001efdc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001efe0: 7f ff d8 15 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001efe4: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001efe8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001efec: 22 bf ff cb be,a 4001ef18 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001eff0: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
4001eff4: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001eff8: 7f ff d8 ab call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001effc: 90 12 21 88 or %o0, 0x188, %o0 ! 40033988 <status_code_to_errno+0x1244>
<== NOT EXECUTED
4001f000: 10 bf ff c6 b 4001ef18 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001f004: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
4001f008: 40 00 0f 61 call 40022d8c <strerror>
<== NOT EXECUTED
4001f00c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f010: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f014: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f018: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001f01c: 7f ff d8 93 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f020: 90 12 23 18 or %o0, 0x318, %o0 ! 40033b18 <status_code_to_errno+0x13d4>
<== NOT EXECUTED
4001f024: 30 bf ff ab b,a 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
4001f028: fa 06 e0 24 ld [ %i3 + 0x24 ], %i5
4001f02c: 92 10 20 50 mov 0x50, %o1
4001f030: 7f ff a8 2a call 400090d8 <calloc>
4001f034: 90 10 00 1d mov %i5, %o0
if (!fs->groups)
4001f038: 80 a2 20 00 cmp %o0, 0
4001f03c: 02 80 00 b0 be 4001f2fc <rtems_rfs_fs_open+0x7e8>
<== NEVER TAKEN
4001f040: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
for (group = 0; group < fs->group_count; group++)
4001f044: b2 10 20 00 clr %i1
4001f048: 80 a7 60 00 cmp %i5, 0
4001f04c: 14 80 00 09 bg 4001f070 <rtems_rfs_fs_open+0x55c>
<== ALWAYS TAKEN
4001f050: b4 10 20 00 clr %i2
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001f054: 10 80 00 33 b 4001f120 <rtems_rfs_fs_open+0x60c>
<== NOT EXECUTED
4001f058: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
4001f05c: b4 06 a0 01 inc %i2
4001f060: 80 a6 80 01 cmp %i2, %g1
4001f064: 16 80 00 2e bge 4001f11c <rtems_rfs_fs_open+0x608>
<== ALWAYS TAKEN
4001f068: b2 06 60 50 add %i1, 0x50, %i1
4001f06c: d0 06 e0 20 ld [ %i3 + 0x20 ], %o0
<== NOT EXECUTED
rtems_rfs_fs_block (fs, group, 0),
4001f070: d4 06 e0 28 ld [ %i3 + 0x28 ], %o2
rc = rtems_rfs_group_open (fs,
4001f074: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
4001f078: 92 5e 80 0a smul %i2, %o2, %o1
rc = rtems_rfs_group_open (fs,
4001f07c: 98 02 00 19 add %o0, %i1, %o4
4001f080: 92 02 60 01 inc %o1
4001f084: 7f ff cf ab call 40012f30 <rtems_rfs_group_open>
4001f088: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001f08c: ba 92 20 00 orcc %o0, 0, %i5
4001f090: 24 bf ff f3 ble,a 4001f05c <rtems_rfs_fs_open+0x548>
<== ALWAYS TAKEN
4001f094: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
for (g = 0; g < group; g++)
4001f098: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001f09c: 02 80 00 0d be 4001f0d0 <rtems_rfs_fs_open+0x5bc>
<== NOT EXECUTED
4001f0a0: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f0a4: b0 10 20 00 clr %i0
<== NOT EXECUTED
4001f0a8: b2 10 20 00 clr %i1
<== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
4001f0ac: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1
<== NOT EXECUTED
4001f0b0: 92 02 40 18 add %o1, %i0, %o1
<== NOT EXECUTED
4001f0b4: 7f ff d0 2d call 40013168 <rtems_rfs_group_close>
<== NOT EXECUTED
4001f0b8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
for (g = 0; g < group; g++)
4001f0bc: b2 06 60 01 inc %i1
<== NOT EXECUTED
4001f0c0: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
4001f0c4: 12 bf ff fa bne 4001f0ac <rtems_rfs_fs_open+0x598>
<== NOT EXECUTED
4001f0c8: b0 06 20 50 add %i0, 0x50, %i0
<== NOT EXECUTED
4001f0cc: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f0d0: 7f ff f4 40 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001f0d4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f0d8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f0dc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001f0e0: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
handle->bnum = 0;
4001f0e4: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4001f0e8: 7f ff d7 d3 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f0ec: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001f0f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f0f4: 02 bf ff 6d be 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001f0f8: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
4001f0fc: 40 00 0f 24 call 40022d8c <strerror>
<== NOT EXECUTED
4001f100: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f104: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f108: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f10c: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001f110: 7f ff d8 56 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f114: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 40033ad8 <status_code_to_errno+0x1394>
<== NOT EXECUTED
4001f118: 30 bf ff 64 b,a 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001f11c: d0 07 00 00 ld [ %i4 ], %o0
4001f120: 96 10 20 01 mov 1, %o3
4001f124: 94 07 bf d8 add %fp, -40, %o2
4001f128: 7f ff d1 8e call 40013760 <rtems_rfs_inode_open>
4001f12c: 92 10 20 01 mov 1, %o1
if (rc > 0)
4001f130: ba 92 20 00 orcc %o0, 0, %i5
4001f134: 14 80 00 40 bg 4001f234 <rtems_rfs_fs_open+0x720>
<== NEVER TAKEN
4001f138: 01 00 00 00 nop
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
4001f13c: d0 07 00 00 ld [ %i4 ], %o0
4001f140: c2 02 00 00 ld [ %o0 ], %g1
4001f144: 80 88 60 04 btst 4, %g1
4001f148: 12 80 00 0f bne 4001f184 <rtems_rfs_fs_open+0x670>
4001f14c: c4 07 bf e4 ld [ %fp + -28 ], %g2
return rtems_rfs_read_u16 (&handle->node->mode);
4001f150: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
4001f154: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
4001f158: 83 28 60 08 sll %g1, 8, %g1
4001f15c: 82 10 40 02 or %g1, %g2, %g1
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
4001f160: 05 00 00 3f sethi %hi(0xfc00), %g2
4001f164: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_Configuration_Interrupt_stack_size+0x7fff>
4001f168: 80 a0 40 02 cmp %g1, %g2
4001f16c: 02 80 00 1e be 4001f1e4 <rtems_rfs_fs_open+0x6d0>
<== NEVER TAKEN
4001f170: 82 08 70 00 and %g1, -4096, %g1
4001f174: 05 00 00 10 sethi %hi(0x4000), %g2
4001f178: 80 a0 40 02 cmp %g1, %g2
4001f17c: 12 80 00 1a bne 4001f1e4 <rtems_rfs_fs_open+0x6d0>
<== NEVER TAKEN
4001f180: 01 00 00 00 nop
rc = rtems_rfs_inode_close (*fs, &inode);
4001f184: 92 07 bf d8 add %fp, -40, %o1
4001f188: 7f ff d1 ed call 4001393c <rtems_rfs_inode_close>
4001f18c: b0 10 20 00 clr %i0
if (rc > 0)
4001f190: 80 a2 20 00 cmp %o0, 0
4001f194: 14 80 00 3a bg 4001f27c <rtems_rfs_fs_open+0x768>
<== NEVER TAKEN
4001f198: ba 10 00 08 mov %o0, %i5
}
return 0;
}
4001f19c: 81 c7 e0 08 ret
4001f1a0: 81 e8 00 00 restore
free (*fs);
4001f1a4: 7f ff a8 9c call 40009414 <free>
<== NOT EXECUTED
4001f1a8: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f1ac: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f1b0: 7f ff d7 a1 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f1b4: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001f1b8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f1bc: 02 bf ff 45 be 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
4001f1c0: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
4001f1c4: 40 00 0e f2 call 40022d8c <strerror>
<== NOT EXECUTED
4001f1c8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f1cc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f1d0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f1d4: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001f1d8: 7f ff d8 24 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f1dc: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400338e0 <status_code_to_errno+0x119c>
<== NOT EXECUTED
4001f1e0: 30 bf ff 3c b,a 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
4001f1e4: 7f ff d1 d6 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f1e8: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001f1ec: 7f ff f4 f5 call 4001c5c0 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001f1f0: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001f1f4: 7f ff a8 88 call 40009414 <free>
<== NOT EXECUTED
4001f1f8: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f1fc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f200: 7f ff d7 8d call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f204: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001f208: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f20c: 02 80 00 04 be 4001f21c <rtems_rfs_fs_open+0x708>
<== NOT EXECUTED
4001f210: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
4001f214: 7f ff d8 24 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001f218: 90 12 23 78 or %o0, 0x378, %o0 ! 40033b78 <status_code_to_errno+0x1434>
<== NOT EXECUTED
errno = EIO;
4001f21c: 40 00 06 93 call 40020c68 <__errno>
<== NOT EXECUTED
4001f220: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001f224: 82 10 20 05 mov 5, %g1
<== NOT EXECUTED
4001f228: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
4001f22c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f230: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001f234: 7f ff f4 e3 call 4001c5c0 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001f238: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001f23c: 7f ff a8 76 call 40009414 <free>
<== NOT EXECUTED
4001f240: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f244: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f248: 7f ff d7 7b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f24c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001f250: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f254: 02 bf ff 1f be 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
4001f258: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
4001f25c: 40 00 0e cc call 40022d8c <strerror>
<== NOT EXECUTED
4001f260: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f264: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f268: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f26c: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001f270: 7f ff d7 fe call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f274: 90 12 23 48 or %o0, 0x348, %o0 ! 40033b48 <status_code_to_errno+0x1404>
<== NOT EXECUTED
4001f278: 30 bf ff 16 b,a 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001f27c: 7f ff f4 d1 call 4001c5c0 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001f280: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001f284: 7f ff a8 64 call 40009414 <free>
<== NOT EXECUTED
4001f288: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f28c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f290: 7f ff d7 69 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f294: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001f298: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f29c: 02 bf ff 0d be 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
4001f2a0: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
4001f2a4: 40 00 0e ba call 40022d8c <strerror>
<== NOT EXECUTED
4001f2a8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f2ac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f2b0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f2b4: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001f2b8: 7f ff d7 ec call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f2bc: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 40033ba8 <status_code_to_errno+0x1464>
<== NOT EXECUTED
4001f2c0: 30 bf ff 04 b,a 4001eed0 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f2c4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f2c8: 7f ff d7 5b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f2cc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001f2d0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f2d4: 02 80 00 04 be 4001f2e4 <rtems_rfs_fs_open+0x7d0>
<== NOT EXECUTED
4001f2d8: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
4001f2dc: 7f ff d7 f2 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001f2e0: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400338b0 <status_code_to_errno+0x116c>
<== NOT EXECUTED
errno = ENOMEM;
4001f2e4: 40 00 06 61 call 40020c68 <__errno>
<== NOT EXECUTED
4001f2e8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001f2ec: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
4001f2f0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
4001f2f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f2f8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001f2fc: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f300: 7f ff f3 b4 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001f304: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f308: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f30c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001f310: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
return ENOMEM;
4001f314: ba 10 20 0c mov 0xc, %i5
<== NOT EXECUTED
handle->bnum = 0;
4001f318: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f31c: 7f ff d7 46 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f320: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001f324: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f328: 02 bf fe e0 be 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001f32c: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
4001f330: 7f ff d7 dd call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001f334: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 40033aa0 <status_code_to_errno+0x135c>
<== NOT EXECUTED
4001f338: 30 bf fe dc b,a 4001eea8 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001eae0 <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;
4001eae0: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
4001eae4: d0 02 20 08 ld [ %o0 + 8 ], %o0
<== NOT EXECUTED
}
4001eae8: 92 50 80 08 umul %g2, %o0, %o1
<== NOT EXECUTED
4001eaec: 91 40 00 00 rd %y, %o0
<== NOT EXECUTED
4001eaf0: 81 c3 e0 08 retl
<== NOT EXECUTED
4001eaf4: 01 00 00 00 nop
<== NOT EXECUTED
40013218 <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)
{
40013218: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
4001321c: 80 a6 a0 00 cmp %i2, 0
40013220: 02 80 00 58 be 40013380 <rtems_rfs_group_bitmap_alloc+0x168>
40013224: 80 a6 60 00 cmp %i1, 0
{
size = fs->group_inodes;
40013228: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
4001322c: b2 06 7f ff add %i1, -1, %i1
*/
if (goal >= RTEMS_RFS_ROOT_INO)
goal -= RTEMS_RFS_ROOT_INO;
}
group_start = goal / size;
40013230: 81 80 20 00 wr %g0, %y
40013234: 01 00 00 00 nop
40013238: 01 00 00 00 nop
4001323c: 01 00 00 00 nop
40013240: a0 76 40 11 udiv %i1, %l1, %l0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40013244: c0 2f bf fb clrb [ %fp + -5 ]
bit = (rtems_rfs_bitmap_bit) (goal % size);
40013248: 82 5c 00 11 smul %l0, %l1, %g1
4001324c: b2 26 40 01 sub %i1, %g1, %i1
40013250: 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);
40013254: ba 10 00 10 mov %l0, %i5
direction = 1;
40013258: a4 10 20 01 mov 1, %l2
updown = true;
4001325c: a6 10 20 01 mov 1, %l3
bool allocated = false;
40013260: b2 10 20 00 clr %i1
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
40013264: 80 a7 60 00 cmp %i5, 0
40013268: 06 80 00 2e bl 40013320 <rtems_rfs_group_bitmap_alloc+0x108>
<== NEVER TAKEN
4001326c: a2 04 7f ff add %l1, -1, %l1
group = group_start + (direction * offset);
40013270: a8 04 00 19 add %l0, %i1, %l4
if ((group < 0) || (group >= fs->group_count))
40013274: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40013278: 80 a0 40 1d cmp %g1, %i5
4001327c: 04 80 00 2a ble 40013324 <rtems_rfs_group_bitmap_alloc+0x10c>
40013280: 80 8c e0 ff btst 0xff, %l3
* 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)
40013284: aa 0c e0 ff and %l3, 0xff, %l5
40013288: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4001328c: b9 2f 60 02 sll %i5, 2, %i4
if (inode)
40013290: 80 a6 a0 00 cmp %i2, 0
40013294: b8 07 00 1d add %i4, %i5, %i4
40013298: b9 2f 20 04 sll %i4, 4, %i4
4001329c: 82 00 40 1c add %g1, %i4, %g1
400132a0: 12 80 00 3c bne 40013390 <rtems_rfs_group_bitmap_alloc+0x178>
400132a4: ac 00 60 08 add %g1, 8, %l6
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
400132a8: d2 07 bf fc ld [ %fp + -4 ], %o1
400132ac: 96 07 bf fc add %fp, -4, %o3
400132b0: 94 07 bf fb add %fp, -5, %o2
400132b4: 40 00 1d 6b call 4001a860 <rtems_rfs_bitmap_map_alloc>
400132b8: 90 10 00 16 mov %l6, %o0
if (rc > 0)
400132bc: 80 a2 20 00 cmp %o0, 0
400132c0: 14 80 00 21 bg 40013344 <rtems_rfs_group_bitmap_alloc+0x12c>
<== NEVER TAKEN
400132c4: 01 00 00 00 nop
if (rtems_rfs_fs_release_bitmaps (fs))
400132c8: c2 06 00 00 ld [ %i0 ], %g1
400132cc: 80 88 60 01 btst 1, %g1
400132d0: 22 80 00 46 be,a 400133e8 <rtems_rfs_group_bitmap_alloc+0x1d0>
<== ALWAYS TAKEN
400132d4: d2 05 80 00 ld [ %l6 ], %o1
if (allocated)
400132d8: c2 0f bf fb ldub [ %fp + -5 ], %g1
<== NOT EXECUTED
400132dc: 80 88 60 ff btst 0xff, %g1
400132e0: 12 80 00 5b bne 4001344c <rtems_rfs_group_bitmap_alloc+0x234>
400132e4: 80 a5 60 00 cmp %l5, 0
if (updown)
400132e8: 22 80 00 2c be,a 40013398 <rtems_rfs_group_bitmap_alloc+0x180>
<== NEVER TAKEN
400132ec: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
{
direction = direction > 0 ? -1 : 1;
400132f0: 80 a4 a0 01 cmp %l2, 1
400132f4: 12 80 00 41 bne 400133f8 <rtems_rfs_group_bitmap_alloc+0x1e0>
<== NEVER TAKEN
400132f8: a4 10 3f ff mov -1, %l2
bool allocated = false;
400132fc: c0 2f bf fb clrb [ %fp + -5 ]
group = group_start + (direction * offset);
40013300: ba 38 00 19 xnor %g0, %i1, %i5
40013304: ba 07 40 10 add %i5, %l0, %i5
if ( direction == -1 )
offset++;
40013308: b2 06 60 01 inc %i1
bit = direction > 0 ? 0 : size - 1;
4001330c: 82 10 00 11 mov %l1, %g1
40013310: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((group < 0) || (group >= fs->group_count))
40013314: 80 a7 60 00 cmp %i5, 0
40013318: 36 bf ff d7 bge,a 40013274 <rtems_rfs_group_bitmap_alloc+0x5c>
4001331c: a8 04 00 19 add %l0, %i1, %l4
if (!updown)
40013320: 80 8c e0 ff btst 0xff, %l3
40013324: 12 80 00 0a bne 4001334c <rtems_rfs_group_bitmap_alloc+0x134>
40013328: 90 10 20 00 clr %o0
offset++;
}
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4001332c: 40 00 07 42 call 40015034 <rtems_rfs_trace>
40013330: 13 00 00 80 sethi %hi(0x20000), %o1
40013334: 80 a2 20 00 cmp %o0, 0
40013338: 12 80 00 20 bne 400133b8 <rtems_rfs_group_bitmap_alloc+0x1a0>
<== NEVER TAKEN
4001333c: 11 10 00 c8 sethi %hi(0x40032000), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
40013340: 90 10 20 1c mov 0x1c, %o0
}
40013344: 81 c7 e0 08 ret
40013348: 91 e8 00 08 restore %g0, %o0, %o0
direction = direction > 0 ? -1 : 1;
4001334c: 80 a4 a0 01 cmp %l2, 1
40013350: 12 80 00 1e bne 400133c8 <rtems_rfs_group_bitmap_alloc+0x1b0>
<== ALWAYS TAKEN
40013354: c0 2f bf fb clrb [ %fp + -5 ]
40013358: ba 24 00 19 sub %l0, %i1, %i5
<== NOT EXECUTED
4001335c: a4 10 3f ff mov -1, %l2
<== NOT EXECUTED
if (offset)
40013360: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40013364: 12 bf ff ea bne 4001330c <rtems_rfs_group_bitmap_alloc+0xf4>
<== NOT EXECUTED
40013368: a6 10 20 00 clr %l3
<== NOT EXECUTED
if ((group < 0) || (group >= fs->group_count))
4001336c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40013370: 36 bf ff c1 bge,a 40013274 <rtems_rfs_group_bitmap_alloc+0x5c>
<== NOT EXECUTED
40013374: a8 04 00 19 add %l0, %i1, %l4
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40013378: 10 bf ff ed b 4001332c <rtems_rfs_group_bitmap_alloc+0x114>
<== NOT EXECUTED
4001337c: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (goal >= RTEMS_RFS_ROOT_INO)
40013380: 04 bf ff ac ble 40013230 <rtems_rfs_group_bitmap_alloc+0x18>
40013384: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
goal -= RTEMS_RFS_ROOT_INO;
40013388: 10 bf ff aa b 40013230 <rtems_rfs_group_bitmap_alloc+0x18>
4001338c: b2 06 7f ff add %i1, -1, %i1
40013390: 10 bf ff c6 b 400132a8 <rtems_rfs_group_bitmap_alloc+0x90>
40013394: ac 00 60 2c add %g1, 0x2c, %l6
offset++;
40013398: b2 06 60 01 inc %i1
<== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
4001339c: 80 a4 a0 01 cmp %l2, 1
<== NOT EXECUTED
400133a0: ba 5c 80 19 smul %l2, %i1, %i5
<== NOT EXECUTED
400133a4: 12 bf ff da bne 4001330c <rtems_rfs_group_bitmap_alloc+0xf4>
<== NOT EXECUTED
400133a8: ba 07 40 10 add %i5, %l0, %i5
<== NOT EXECUTED
400133ac: 82 10 20 00 clr %g1
<== NOT EXECUTED
400133b0: 10 bf ff d9 b 40013314 <rtems_rfs_group_bitmap_alloc+0xfc>
<== NOT EXECUTED
400133b4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
400133b8: 40 00 07 bb call 400152a4 <__wrap_puts>
<== NOT EXECUTED
400133bc: 90 12 22 08 or %o0, 0x208, %o0
<== NOT EXECUTED
return ENOSPC;
400133c0: 10 bf ff e1 b 40013344 <rtems_rfs_group_bitmap_alloc+0x12c>
<== NOT EXECUTED
400133c4: 90 10 20 1c mov 0x1c, %o0
<== NOT EXECUTED
400133c8: ba 06 40 10 add %i1, %l0, %i5
if (offset)
400133cc: a4 10 20 01 mov 1, %l2
400133d0: a6 10 20 00 clr %l3
400133d4: 80 a6 60 00 cmp %i1, 0
400133d8: 02 bf ff e5 be 4001336c <rtems_rfs_group_bitmap_alloc+0x154>
<== NEVER TAKEN
400133dc: 82 10 20 00 clr %g1
bit = direction > 0 ? 0 : size - 1;
400133e0: 10 bf ff cd b 40013314 <rtems_rfs_group_bitmap_alloc+0xfc>
400133e4: c2 27 bf fc st %g1, [ %fp + -4 ]
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400133e8: 40 00 23 7a call 4001c1d0 <rtems_rfs_buffer_handle_release>
400133ec: 90 10 00 18 mov %i0, %o0
if (allocated)
400133f0: 10 bf ff bb b 400132dc <rtems_rfs_group_bitmap_alloc+0xc4>
400133f4: c2 0f bf fb ldub [ %fp + -5 ], %g1
bool allocated = false;
400133f8: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
if (offset)
400133fc: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40013400: 02 80 00 05 be 40013414 <rtems_rfs_group_bitmap_alloc+0x1fc>
<== NOT EXECUTED
40013404: ba 10 00 14 mov %l4, %i5
<== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40013408: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
4001340c: 10 bf ff e9 b 400133b0 <rtems_rfs_group_bitmap_alloc+0x198>
<== NOT EXECUTED
40013410: 82 10 20 00 clr %g1
<== NOT EXECUTED
if ((group < 0) || (group >= fs->group_count))
40013414: 80 a5 20 00 cmp %l4, 0
<== NOT EXECUTED
40013418: 26 80 00 07 bl,a 40013434 <rtems_rfs_group_bitmap_alloc+0x21c>
<== NOT EXECUTED
4001341c: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
40013420: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
<== NOT EXECUTED
40013424: 80 a0 80 14 cmp %g2, %l4
<== NOT EXECUTED
40013428: 14 bf ff 98 bg 40013288 <rtems_rfs_group_bitmap_alloc+0x70>
<== NOT EXECUTED
4001342c: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
bool allocated = false;
40013430: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
40013434: a4 10 3f ff mov -1, %l2
<== NOT EXECUTED
if ((group < 0) || (group >= fs->group_count))
40013438: 80 a5 20 00 cmp %l4, 0
<== NOT EXECUTED
4001343c: 16 bf ff 8e bge 40013274 <rtems_rfs_group_bitmap_alloc+0x5c>
<== NOT EXECUTED
40013440: a6 10 00 01 mov %g1, %l3
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40013444: 10 bf ff ba b 4001332c <rtems_rfs_group_bitmap_alloc+0x114>
<== NOT EXECUTED
40013448: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (inode)
4001344c: 80 a6 a0 00 cmp %i2, 0
40013450: 02 80 00 14 be 400134a0 <rtems_rfs_group_bitmap_alloc+0x288>
40013454: c4 07 bf fc ld [ %fp + -4 ], %g2
*result = rtems_rfs_group_inode (fs, group, bit);
40013458: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
4001345c: 84 00 a0 01 inc %g2
40013460: 82 5f 40 01 smul %i5, %g1, %g1
40013464: 82 00 40 02 add %g1, %g2, %g1
40013468: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4001346c: 90 10 20 00 clr %o0
40013470: 40 00 06 f1 call 40015034 <rtems_rfs_trace>
40013474: 13 00 00 80 sethi %hi(0x20000), %o1
40013478: 80 a2 20 00 cmp %o0, 0
4001347c: 02 80 00 07 be 40013498 <rtems_rfs_group_bitmap_alloc+0x280>
<== ALWAYS TAKEN
40013480: 13 10 00 c8 sethi %hi(0x40032000), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40013484: 92 12 61 c8 or %o1, 0x1c8, %o1 ! 400321c8 <_Thread_queue_Operations_default+0x994>
<== NOT EXECUTED
40013488: d4 06 c0 00 ld [ %i3 ], %o2
<== NOT EXECUTED
4001348c: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013490: 40 00 07 76 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013494: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400321d0 <_Thread_queue_Operations_default+0x99c>
<== NOT EXECUTED
return 0;
40013498: 10 bf ff ab b 40013344 <rtems_rfs_group_bitmap_alloc+0x12c>
4001349c: 90 10 20 00 clr %o0
*result = rtems_rfs_group_block (&fs->groups[group], bit);
400134a0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400134a4: c2 00 40 1c ld [ %g1 + %i4 ], %g1
400134a8: 84 00 40 02 add %g1, %g2, %g2
400134ac: c4 26 c0 00 st %g2, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
400134b0: 90 10 20 00 clr %o0
400134b4: 40 00 06 e0 call 40015034 <rtems_rfs_trace>
400134b8: 13 00 00 80 sethi %hi(0x20000), %o1
400134bc: 80 a2 20 00 cmp %o0, 0
400134c0: 02 bf ff f6 be 40013498 <rtems_rfs_group_bitmap_alloc+0x280>
<== ALWAYS TAKEN
400134c4: 13 10 00 c8 sethi %hi(0x40032000), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
400134c8: 10 bf ff f0 b 40013488 <rtems_rfs_group_bitmap_alloc+0x270>
<== NOT EXECUTED
400134cc: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 400321c0 <_Thread_queue_Operations_default+0x98c>
<== NOT EXECUTED
400134d0 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
400134d0: 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))
400134d4: 90 10 20 00 clr %o0
400134d8: 13 00 00 80 sethi %hi(0x20000), %o1
400134dc: 40 00 06 d6 call 40015034 <rtems_rfs_trace>
400134e0: b8 10 00 18 mov %i0, %i4
400134e4: 80 a2 20 00 cmp %o0, 0
400134e8: 22 80 00 0c be,a 40013518 <rtems_rfs_group_bitmap_free+0x48>
<== ALWAYS TAKEN
400134ec: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
400134f0: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
400134f4: 12 80 00 36 bne 400135cc <rtems_rfs_group_bitmap_free+0xfc>
<== NOT EXECUTED
400134f8: 13 10 00 c8 sethi %hi(0x40032000), %o1
<== NOT EXECUTED
400134fc: 13 10 00 c8 sethi %hi(0x40032000), %o1
<== NOT EXECUTED
40013500: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 400321c0 <_Thread_queue_Operations_default+0x98c>
<== NOT EXECUTED
40013504: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013508: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001350c: 40 00 07 57 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013510: 90 12 22 40 or %o0, 0x240, %o0
<== NOT EXECUTED
40013514: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
<== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40013518: 80 a6 60 00 cmp %i1, 0
4001351c: 02 80 00 17 be 40013578 <rtems_rfs_group_bitmap_free+0xa8>
40013520: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
40013524: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
40013528: 81 80 20 00 wr %g0, %y
4001352c: 01 00 00 00 nop
40013530: 01 00 00 00 nop
40013534: 01 00 00 00 nop
40013538: 84 76 80 09 udiv %i2, %o1, %g2
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4001353c: 83 28 a0 02 sll %g2, 2, %g1
40013540: 82 00 40 02 add %g1, %g2, %g1
40013544: 83 28 60 04 sll %g1, 4, %g1
bit = (rtems_rfs_bitmap_bit) (no % size);
40013548: 92 58 80 09 smul %g2, %o1, %o1
bitmap = &fs->groups[group].inode_bitmap;
4001354c: ba 07 40 01 add %i5, %g1, %i5
bit = (rtems_rfs_bitmap_bit) (no % size);
40013550: 92 26 80 09 sub %i2, %o1, %o1
bitmap = &fs->groups[group].inode_bitmap;
40013554: ba 07 60 2c add %i5, 0x2c, %i5
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40013558: 40 00 1c 6b call 4001a704 <rtems_rfs_bitmap_map_clear>
4001355c: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40013560: d2 07 40 00 ld [ %i5 ], %o1
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40013564: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40013568: 40 00 23 1a call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001356c: 90 10 00 1c mov %i4, %o0
return rc;
}
40013570: 81 c7 e0 08 ret
40013574: 81 e8 00 00 restore
size = fs->group_blocks;
40013578: d2 07 20 28 ld [ %i4 + 0x28 ], %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
4001357c: 81 80 20 00 wr %g0, %y
40013580: 01 00 00 00 nop
40013584: 01 00 00 00 nop
40013588: 01 00 00 00 nop
4001358c: 84 76 80 09 udiv %i2, %o1, %g2
bitmap = &fs->groups[group].block_bitmap;
40013590: 83 28 a0 02 sll %g2, 2, %g1
40013594: 82 00 40 02 add %g1, %g2, %g1
40013598: 83 28 60 04 sll %g1, 4, %g1
bit = (rtems_rfs_bitmap_bit) (no % size);
4001359c: 92 58 80 09 smul %g2, %o1, %o1
bitmap = &fs->groups[group].block_bitmap;
400135a0: ba 07 40 01 add %i5, %g1, %i5
bit = (rtems_rfs_bitmap_bit) (no % size);
400135a4: 92 26 80 09 sub %i2, %o1, %o1
bitmap = &fs->groups[group].block_bitmap;
400135a8: ba 07 60 08 add %i5, 8, %i5
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400135ac: 40 00 1c 56 call 4001a704 <rtems_rfs_bitmap_map_clear>
400135b0: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400135b4: d2 07 40 00 ld [ %i5 ], %o1
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400135b8: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400135bc: 40 00 23 05 call 4001c1d0 <rtems_rfs_buffer_handle_release>
400135c0: 90 10 00 1c mov %i4, %o0
}
400135c4: 81 c7 e0 08 ret
400135c8: 81 e8 00 00 restore
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
400135cc: 10 bf ff ce b 40013504 <rtems_rfs_group_bitmap_free+0x34>
<== NOT EXECUTED
400135d0: 92 12 61 c8 or %o1, 0x1c8, %o1
<== NOT EXECUTED
40013168 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40013168: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4001316c: 90 10 20 00 clr %o0
40013170: 40 00 07 b1 call 40015034 <rtems_rfs_trace>
40013174: 13 00 00 40 sethi %hi(0x10000), %o1
40013178: 80 a2 20 00 cmp %o0, 0
4001317c: 32 80 00 18 bne,a 400131dc <rtems_rfs_group_close+0x74>
<== NEVER TAKEN
40013180: 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);
40013184: 40 00 1e 4a call 4001aaac <rtems_rfs_bitmap_close>
40013188: 90 06 60 2c add %i1, 0x2c, %o0
rtems_rfs_buffer_handle_release (fs, handle);
4001318c: 92 06 60 44 add %i1, 0x44, %o1
40013190: ba 10 00 08 mov %o0, %i5
40013194: 40 00 24 0f call 4001c1d0 <rtems_rfs_buffer_handle_release>
40013198: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001319c: 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);
400131a0: 90 06 60 08 add %i1, 8, %o0
handle->bnum = 0;
400131a4: c0 26 60 48 clr [ %i1 + 0x48 ]
400131a8: 40 00 1e 41 call 4001aaac <rtems_rfs_bitmap_close>
400131ac: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
400131b0: 82 92 20 00 orcc %o0, 0, %g1
400131b4: 04 80 00 0e ble 400131ec <rtems_rfs_group_close+0x84>
<== ALWAYS TAKEN
400131b8: 92 06 60 20 add %i1, 0x20, %o1
rtems_rfs_buffer_handle_release (fs, handle);
400131bc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400131c0: 40 00 24 04 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400131c4: b0 10 00 01 mov %g1, %i0
<== NOT EXECUTED
handle->dirty = false;
400131c8: c0 2e 60 20 clrb [ %i1 + 0x20 ]
<== NOT EXECUTED
handle->bnum = 0;
400131cc: c0 26 60 24 clr [ %i1 + 0x24 ]
<== NOT EXECUTED
handle->buffer = NULL;
400131d0: c0 26 60 28 clr [ %i1 + 0x28 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
400131d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400131d8: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
400131dc: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
400131e0: 40 00 08 22 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400131e4: 90 12 21 98 or %o0, 0x198, %o0 ! 40032198 <_Thread_queue_Operations_default+0x964>
<== NOT EXECUTED
400131e8: 30 bf ff e7 b,a 40013184 <rtems_rfs_group_close+0x1c>
<== NOT EXECUTED
400131ec: 82 38 00 1d xnor %g0, %i5, %g1
400131f0: 83 38 60 1f sra %g1, 0x1f, %g1
400131f4: 82 0f 40 01 and %i5, %g1, %g1
rtems_rfs_buffer_handle_release (fs, handle);
400131f8: 90 10 00 18 mov %i0, %o0
400131fc: 40 00 23 f5 call 4001c1d0 <rtems_rfs_buffer_handle_release>
40013200: b0 10 00 01 mov %g1, %i0
handle->dirty = false;
40013204: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40013208: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
4001320c: c0 26 60 28 clr [ %i1 + 0x28 ]
}
40013210: 81 c7 e0 08 ret
40013214: 81 e8 00 00 restore
40012f30 <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)
{
40012f30: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40012f34: c2 06 20 04 ld [ %i0 + 4 ], %g1
40012f38: 80 a0 40 19 cmp %g1, %i1
40012f3c: 08 80 00 56 bleu 40013094 <rtems_rfs_group_open+0x164>
<== NEVER TAKEN
40012f40: ba 10 00 18 mov %i0, %i5
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))
40012f44: 84 06 40 1a add %i1, %i2, %g2
40012f48: 80 a0 40 02 cmp %g1, %g2
40012f4c: 28 80 00 02 bleu,a 40012f54 <rtems_rfs_group_open+0x24>
<== ALWAYS TAKEN
40012f50: b4 20 40 19 sub %g1, %i1, %i2
40012f54: 80 a6 80 1b cmp %i2, %i3
40012f58: 18 80 00 25 bgu 40012fec <rtems_rfs_group_open+0xbc>
<== ALWAYS TAKEN
40012f5c: a0 10 00 1a mov %i2, %l0
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012f60: 90 10 20 00 clr %o0
<== NOT EXECUTED
40012f64: 40 00 08 34 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
40012f68: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
40012f6c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012f70: 12 80 00 42 bne 40013078 <rtems_rfs_group_open+0x148>
<== NOT EXECUTED
40012f74: 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;
40012f78: f2 27 00 00 st %i1, [ %i4 ]
<== NOT EXECUTED
group->size = size;
rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
40012f7c: b6 07 20 20 add %i4, 0x20, %i3
group->size = size;
40012f80: 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,
40012f84: a2 07 20 08 add %i4, 8, %l1
handle->dirty = false;
40012f88: c0 2f 20 20 clrb [ %i4 + 0x20 ]
40012f8c: 98 10 00 19 mov %i1, %o4
handle->bnum = 0;
40012f90: c0 27 20 24 clr [ %i4 + 0x24 ]
40012f94: 96 10 00 1a mov %i2, %o3
handle->buffer = NULL;
40012f98: c0 27 20 28 clr [ %i4 + 0x28 ]
40012f9c: 94 10 00 1b mov %i3, %o2
40012fa0: 92 10 00 1d mov %i5, %o1
40012fa4: 40 00 1e b1 call 4001aa68 <rtems_rfs_bitmap_open>
40012fa8: 90 10 00 11 mov %l1, %o0
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40012fac: b0 92 20 00 orcc %o0, 0, %i0
40012fb0: 04 80 00 18 ble 40013010 <rtems_rfs_group_open+0xe0>
<== ALWAYS TAKEN
40012fb4: 92 10 00 1b mov %i3, %o1
rtems_rfs_buffer_handle_release (fs, handle);
40012fb8: 40 00 24 86 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40012fbc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
handle->dirty = false;
40012fc0: c0 2f 20 20 clrb [ %i4 + 0x20 ]
<== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012fc4: 90 10 20 00 clr %o0
<== NOT EXECUTED
handle->bnum = 0;
40012fc8: c0 27 20 24 clr [ %i4 + 0x24 ]
<== NOT EXECUTED
40012fcc: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
40012fd0: 40 00 08 19 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
40012fd4: c0 27 20 28 clr [ %i4 + 0x28 ]
<== NOT EXECUTED
40012fd8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012fdc: 12 80 00 3e bne 400130d4 <rtems_rfs_group_open+0x1a4>
<== NOT EXECUTED
40012fe0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
40012fe4: 81 c7 e0 08 ret
<== NOT EXECUTED
40012fe8: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012fec: 90 10 20 00 clr %o0
40012ff0: 13 00 00 20 sethi %hi(0x8000), %o1
40012ff4: 40 00 08 10 call 40015034 <rtems_rfs_trace>
40012ff8: a0 10 00 1b mov %i3, %l0
40012ffc: 80 a2 20 00 cmp %o0, 0
40013000: 22 bf ff df be,a 40012f7c <rtems_rfs_group_open+0x4c>
<== ALWAYS TAKEN
40013004: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40013008: 10 80 00 1c b 40013078 <rtems_rfs_group_open+0x148>
<== NOT EXECUTED
4001300c: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
handle->dirty = false;
40013010: c0 2f 20 44 clrb [ %i4 + 0x44 ]
rc = rtems_rfs_buffer_handle_open (fs, &group->inode_bitmap_buffer);
40013014: b4 07 20 44 add %i4, 0x44, %i2
handle->bnum = 0;
40013018: c0 27 20 48 clr [ %i4 + 0x48 ]
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
4001301c: 96 10 00 10 mov %l0, %o3
handle->buffer = NULL;
40013020: c0 27 20 4c clr [ %i4 + 0x4c ]
40013024: 94 10 00 1a mov %i2, %o2
40013028: d8 07 00 00 ld [ %i4 ], %o4
4001302c: 98 03 20 01 inc %o4
40013030: 92 10 00 1d mov %i5, %o1
40013034: 40 00 1e 8d call 4001aa68 <rtems_rfs_bitmap_open>
40013038: 90 07 20 2c add %i4, 0x2c, %o0
if (rc > 0)
4001303c: b0 92 20 00 orcc %o0, 0, %i0
40013040: 14 80 00 2e bg 400130f8 <rtems_rfs_group_open+0x1c8>
<== NEVER TAKEN
40013044: 92 10 00 1a mov %i2, %o1
if (rtems_rfs_fs_release_bitmaps (fs))
40013048: c2 07 40 00 ld [ %i5 ], %g1
4001304c: 80 88 60 01 btst 1, %g1
40013050: 12 bf ff e5 bne 40012fe4 <rtems_rfs_group_open+0xb4>
<== NEVER TAKEN
40013054: b0 10 20 00 clr %i0
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40013058: d2 07 20 08 ld [ %i4 + 8 ], %o1
4001305c: 40 00 24 5d call 4001c1d0 <rtems_rfs_buffer_handle_release>
40013060: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40013064: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40013068: 40 00 24 5a call 4001c1d0 <rtems_rfs_buffer_handle_release>
4001306c: 90 10 00 1d mov %i5, %o0
}
40013070: 81 c7 e0 08 ret
40013074: 81 e8 00 00 restore
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40013078: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001307c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40013080: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013084: 40 00 08 79 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013088: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400320e0 <_Thread_queue_Operations_default+0x8ac>
<== NOT EXECUTED
group->base = base;
4001308c: 10 bf ff bc b 40012f7c <rtems_rfs_group_open+0x4c>
<== NOT EXECUTED
40013090: f2 27 00 00 st %i1, [ %i4 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40013094: 90 10 20 00 clr %o0
<== NOT EXECUTED
40013098: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
4001309c: 40 00 07 e6 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
400130a0: b0 10 20 05 mov 5, %i0
<== NOT EXECUTED
400130a4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400130a8: 02 80 00 2e be 40013160 <rtems_rfs_group_open+0x230>
<== NOT EXECUTED
400130ac: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
400130b0: 40 00 3f 37 call 40022d8c <strerror>
<== NOT EXECUTED
400130b4: 90 10 20 05 mov 5, %o0 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
400130b8: 92 10 20 05 mov 5, %o1
<== NOT EXECUTED
400130bc: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
400130c0: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
400130c4: 40 00 08 69 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400130c8: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400320a0 <_Thread_queue_Operations_default+0x86c>
<== NOT EXECUTED
400130cc: 81 c7 e0 08 ret
<== NOT EXECUTED
400130d0: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
400130d4: 40 00 3f 2e call 40022d8c <strerror>
<== NOT EXECUTED
400130d8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400130dc: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400130e0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
400130e4: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
400130e8: 40 00 08 60 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400130ec: 90 12 21 18 or %o0, 0x118, %o0 ! 40032118 <_Thread_queue_Operations_default+0x8e4>
<== NOT EXECUTED
400130f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400130f4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400130f8: 40 00 24 36 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400130fc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
handle->dirty = false;
40013100: c0 2f 20 44 clrb [ %i4 + 0x44 ]
<== NOT EXECUTED
rtems_rfs_bitmap_close (&group->block_bitmap);
40013104: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
handle->bnum = 0;
40013108: c0 27 20 48 clr [ %i4 + 0x48 ]
<== NOT EXECUTED
4001310c: 40 00 1e 68 call 4001aaac <rtems_rfs_bitmap_close>
<== NOT EXECUTED
40013110: c0 27 20 4c clr [ %i4 + 0x4c ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40013114: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40013118: 40 00 24 2e call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001311c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
handle->dirty = false;
40013120: c0 2f 20 20 clrb [ %i4 + 0x20 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40013124: 90 10 20 00 clr %o0
<== NOT EXECUTED
handle->bnum = 0;
40013128: c0 27 20 24 clr [ %i4 + 0x24 ]
<== NOT EXECUTED
4001312c: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
40013130: 40 00 07 c1 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
40013134: c0 27 20 28 clr [ %i4 + 0x28 ]
<== NOT EXECUTED
40013138: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001313c: 02 80 00 09 be 40013160 <rtems_rfs_group_open+0x230>
<== NOT EXECUTED
40013140: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40013144: 40 00 3f 12 call 40022d8c <strerror>
<== NOT EXECUTED
40013148: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001314c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40013150: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40013154: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013158: 40 00 08 44 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001315c: 90 12 21 58 or %o0, 0x158, %o0 ! 40032158 <_Thread_queue_Operations_default+0x924>
<== NOT EXECUTED
40013160: 81 c7 e0 08 ret
<== NOT EXECUTED
40013164: 81 e8 00 00 restore
<== NOT EXECUTED
400135d4 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
400135d4: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
*inodes = 0;
400135d8: c0 22 80 00 clr [ %o2 ]
<== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
400135dc: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
<== NOT EXECUTED
400135e0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400135e4: 04 80 00 20 ble 40013664 <rtems_rfs_group_usage+0x90>
<== NOT EXECUTED
400135e8: 86 10 20 00 clr %g3
<== NOT EXECUTED
400135ec: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
<== NOT EXECUTED
400135f0: 82 00 60 14 add %g1, 0x14, %g1
<== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
400135f4: da 00 40 00 ld [ %g1 ], %o5
<== NOT EXECUTED
400135f8: c8 00 60 04 ld [ %g1 + 4 ], %g4
<== NOT EXECUTED
400135fc: c4 02 40 00 ld [ %o1 ], %g2
<== NOT EXECUTED
40013600: 84 00 80 0d add %g2, %o5, %g2
<== NOT EXECUTED
40013604: 84 20 80 04 sub %g2, %g4, %g2
<== NOT EXECUTED
40013608: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
4001360c: 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 +=
40013610: c8 00 60 28 ld [ %g1 + 0x28 ], %g4
<== NOT EXECUTED
40013614: da 00 60 24 ld [ %g1 + 0x24 ], %o5
<== NOT EXECUTED
40013618: c4 02 80 00 ld [ %o2 ], %g2
<== NOT EXECUTED
4001361c: 84 00 80 0d add %g2, %o5, %g2
<== NOT EXECUTED
40013620: 84 20 80 04 sub %g2, %g4, %g2
<== NOT EXECUTED
40013624: c4 22 80 00 st %g2, [ %o2 ]
<== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40013628: c8 02 20 24 ld [ %o0 + 0x24 ], %g4
<== NOT EXECUTED
4001362c: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
40013630: 14 bf ff f1 bg 400135f4 <rtems_rfs_group_usage+0x20>
<== NOT EXECUTED
40013634: 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))
40013638: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
4001363c: c6 02 40 00 ld [ %o1 ], %g3
<== NOT EXECUTED
40013640: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40013644: 38 80 00 0e bgu,a 4001367c <rtems_rfs_group_usage+0xa8>
<== NOT EXECUTED
40013648: c2 22 40 00 st %g1, [ %o1 ]
<== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
4001364c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
40013650: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013654: 2a 80 00 02 bcs,a 4001365c <rtems_rfs_group_usage+0x88>
<== NOT EXECUTED
40013658: c2 22 80 00 st %g1, [ %o2 ]
<== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
4001365c: 81 c3 e0 08 retl
<== NOT EXECUTED
40013660: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (*blocks > rtems_rfs_fs_blocks (fs))
40013664: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
40013668: c4 02 40 00 ld [ %o1 ], %g2
<== NOT EXECUTED
4001366c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40013670: 08 bf ff fb bleu 4001365c <rtems_rfs_group_usage+0x88>
<== NOT EXECUTED
40013674: 01 00 00 00 nop
<== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
40013678: c2 22 40 00 st %g1, [ %o1 ]
<== NOT EXECUTED
4001367c: 10 bf ff f4 b 4001364c <rtems_rfs_group_usage+0x78>
<== NOT EXECUTED
40013680: c4 02 80 00 ld [ %o2 ], %g2
<== NOT EXECUTED
4001393c <rtems_rfs_inode_close>:
{
4001393c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40013940: 90 10 20 00 clr %o0
40013944: 40 00 05 bc call 40015034 <rtems_rfs_trace>
40013948: 13 00 02 00 sethi %hi(0x80000), %o1
4001394c: 80 a2 20 00 cmp %o0, 0
40013950: 32 80 00 16 bne,a 400139a8 <rtems_rfs_inode_close+0x6c>
<== NEVER TAKEN
40013954: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40013958: 90 10 00 18 mov %i0, %o0
4001395c: 94 10 20 01 mov 1, %o2
40013960: 7f ff ff b9 call 40013844 <rtems_rfs_inode_unload>
40013964: 92 10 00 19 mov %i1, %o1
if ((rc == 0) && (handle->loads > 0))
40013968: b0 92 20 00 orcc %o0, 0, %i0
4001396c: 32 80 00 0d bne,a 400139a0 <rtems_rfs_inode_close+0x64>
<== NEVER TAKEN
40013970: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
40013974: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40013978: 80 a0 60 00 cmp %g1, 0
4001397c: 04 80 00 08 ble 4001399c <rtems_rfs_inode_close+0x60>
<== ALWAYS TAKEN
40013980: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40013984: 13 00 02 00 sethi %hi(0x80000), %o1
<== NOT EXECUTED
40013988: 40 00 05 ab call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001398c: b0 10 20 05 mov 5, %i0
<== NOT EXECUTED
40013990: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40013994: 32 80 00 0a bne,a 400139bc <rtems_rfs_inode_close+0x80>
<== NOT EXECUTED
40013998: d2 06 60 24 ld [ %i1 + 0x24 ], %o1
<== NOT EXECUTED
handle->ino = 0;
4001399c: c0 26 60 08 clr [ %i1 + 8 ]
}
400139a0: 81 c7 e0 08 ret
400139a4: 81 e8 00 00 restore
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
400139a8: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
400139ac: 40 00 06 2f call 40015268 <__wrap_printf>
<== NOT EXECUTED
400139b0: 90 12 23 10 or %o0, 0x310, %o0 ! 40032310 <_Thread_queue_Operations_default+0xadc>
<== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
400139b4: 10 bf ff ea b 4001395c <rtems_rfs_inode_close+0x20>
<== NOT EXECUTED
400139b8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
400139bc: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
400139c0: 40 00 06 2a call 40015268 <__wrap_printf>
<== NOT EXECUTED
400139c4: 90 12 23 38 or %o0, 0x338, %o0 ! 40032338 <_Thread_queue_Operations_default+0xb04>
<== NOT EXECUTED
400139c8: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
400139cc: 81 c7 e0 08 ret
<== NOT EXECUTED
400139d0: 81 e8 00 00 restore
<== NOT EXECUTED
40013ce0 <rtems_rfs_inode_create>:
{
40013ce0: 9d e3 bf 50 save %sp, -176, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40013ce4: 90 10 20 00 clr %o0
{
40013ce8: e6 17 a0 5e lduh [ %fp + 0x5e ], %l3
40013cec: e8 17 a0 62 lduh [ %fp + 0x62 ], %l4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40013cf0: 13 00 10 00 sethi %hi(0x400000), %o1
40013cf4: 40 00 04 d0 call 40015034 <rtems_rfs_trace>
40013cf8: a2 0f 30 00 and %i4, -4096, %l1
{
40013cfc: aa 10 00 18 mov %i0, %l5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40013d00: 80 a2 20 00 cmp %o0, 0
40013d04: 02 80 00 2c be 40013db4 <rtems_rfs_inode_create+0xd4>
<== ALWAYS TAKEN
40013d08: a3 2c 60 10 sll %l1, 0x10, %l1
if (RTEMS_RFS_S_ISDIR (mode))
40013d0c: 83 34 60 10 srl %l1, 0x10, %g1
<== NOT EXECUTED
40013d10: 05 00 00 10 sethi %hi(0x4000), %g2
<== NOT EXECUTED
40013d14: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013d18: 02 80 00 11 be 40013d5c <rtems_rfs_inode_create+0x7c>
<== NOT EXECUTED
40013d1c: 05 00 00 08 sethi %hi(0x2000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
40013d20: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013d24: 02 80 00 56 be 40013e7c <rtems_rfs_inode_create+0x19c>
<== NOT EXECUTED
40013d28: 05 00 00 18 sethi %hi(0x6000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
40013d2c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013d30: 02 80 00 50 be 40013e70 <rtems_rfs_inode_create+0x190>
<== NOT EXECUTED
40013d34: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
40013d38: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013d3c: 02 80 00 73 be 40013f08 <rtems_rfs_inode_create+0x228>
<== NOT EXECUTED
40013d40: 05 00 00 28 sethi %hi(0xa000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
40013d44: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013d48: 22 80 00 73 be,a 40013f14 <rtems_rfs_inode_create+0x234>
<== NOT EXECUTED
40013d4c: 31 10 00 c8 sethi %hi(0x40032000), %i0
<== NOT EXECUTED
const char* type = "unknown";
40013d50: 31 10 00 c8 sethi %hi(0x40032000), %i0
<== NOT EXECUTED
40013d54: 10 80 00 04 b 40013d64 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40013d58: b0 16 23 b0 or %i0, 0x3b0, %i0 ! 400323b0 <_Thread_queue_Operations_default+0xb7c>
<== NOT EXECUTED
type = "dir";
40013d5c: 31 10 00 c8 sethi %hi(0x40032000), %i0
<== NOT EXECUTED
40013d60: b0 16 23 98 or %i0, 0x398, %i0 ! 40032398 <_Thread_queue_Operations_default+0xb64>
<== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
40013d64: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40013d68: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013d6c: 40 00 05 3f call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013d70: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 400323c0 <_Thread_queue_Operations_default+0xb8c>
<== NOT EXECUTED
for (c = 0; c < length; c++)
40013d74: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
40013d78: 02 80 00 0a be 40013da0 <rtems_rfs_inode_create+0xc0>
<== NOT EXECUTED
40013d7c: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013d80: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
40013d84: a4 06 c0 1a add %i3, %i2, %l2
<== NOT EXECUTED
printf ("%c", name[c]);
40013d88: 40 00 05 4d call 400152bc <__wrap_putchar>
<== NOT EXECUTED
40013d8c: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
40013d90: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
40013d94: 80 a4 80 10 cmp %l2, %l0
<== NOT EXECUTED
40013d98: 12 bf ff fc bne 40013d88 <rtems_rfs_inode_create+0xa8>
<== NOT EXECUTED
40013d9c: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
40013da0: 96 0f 23 ff and %i4, 0x3ff, %o3
<== NOT EXECUTED
40013da4: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40013da8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40013dac: 40 00 05 2f call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013db0: 90 12 23 f0 or %o0, 0x3f0, %o0
<== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
40013db4: 83 34 60 10 srl %l1, 0x10, %g1
40013db8: 05 00 00 18 sethi %hi(0x6000), %g2
40013dbc: 80 a0 40 02 cmp %g1, %g2
40013dc0: 02 80 00 14 be 40013e10 <rtems_rfs_inode_create+0x130>
<== NEVER TAKEN
40013dc4: 92 10 00 19 mov %i1, %o1
40013dc8: 18 80 00 0b bgu 40013df4 <rtems_rfs_inode_create+0x114>
40013dcc: 05 00 00 20 sethi %hi(0x8000), %g2
40013dd0: 05 00 00 08 sethi %hi(0x2000), %g2
40013dd4: 80 a0 40 02 cmp %g1, %g2
40013dd8: 02 80 00 0e be 40013e10 <rtems_rfs_inode_create+0x130>
<== NEVER TAKEN
40013ddc: 05 00 00 10 sethi %hi(0x4000), %g2
40013de0: 80 a0 40 02 cmp %g1, %g2
40013de4: 02 80 00 0c be 40013e14 <rtems_rfs_inode_create+0x134>
<== ALWAYS TAKEN
40013de8: 94 10 20 01 mov 1, %o2
return EINVAL;
40013dec: 81 c7 e0 08 ret
<== NOT EXECUTED
40013df0: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
40013df4: 80 a0 40 02 cmp %g1, %g2
40013df8: 02 80 00 05 be 40013e0c <rtems_rfs_inode_create+0x12c>
<== ALWAYS TAKEN
40013dfc: 05 00 00 28 sethi %hi(0xa000), %g2
40013e00: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40013e04: 12 bf ff fa bne 40013dec <rtems_rfs_inode_create+0x10c>
<== NOT EXECUTED
40013e08: 01 00 00 00 nop
<== NOT EXECUTED
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
40013e0c: 92 10 00 19 mov %i1, %o1
40013e10: 94 10 20 01 mov 1, %o2
40013e14: 96 07 bf d8 add %fp, -40, %o3
40013e18: 7f ff fd 00 call 40013218 <rtems_rfs_group_bitmap_alloc>
40013e1c: 90 10 00 15 mov %l5, %o0
*ino = bit;
40013e20: d2 07 bf d8 ld [ %fp + -40 ], %o1
40013e24: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
40013e28: d2 20 40 00 st %o1, [ %g1 ]
if (rc > 0)
40013e2c: 80 a2 20 00 cmp %o0, 0
40013e30: 14 80 00 0e bg 40013e68 <rtems_rfs_inode_create+0x188>
40013e34: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
40013e38: 96 10 20 01 mov 1, %o3
40013e3c: 94 07 bf d8 add %fp, -40, %o2
40013e40: 7f ff fe 48 call 40013760 <rtems_rfs_inode_open>
40013e44: 90 10 00 15 mov %l5, %o0
if (rc > 0)
40013e48: b0 92 20 00 orcc %o0, 0, %i0
40013e4c: 04 80 00 0f ble 40013e88 <rtems_rfs_inode_create+0x1a8>
<== ALWAYS TAKEN
40013e50: 98 10 00 14 mov %l4, %o4
return rtems_rfs_group_bitmap_free (fs, true, bit);
40013e54: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
40013e58: d4 00 40 00 ld [ %g1 ], %o2
<== NOT EXECUTED
40013e5c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40013e60: 7f ff fd 9c call 400134d0 <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40013e64: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
40013e68: 81 c7 e0 08 ret
40013e6c: 81 e8 00 00 restore
type = "block";
40013e70: 31 10 00 c8 sethi %hi(0x40032000), %i0
<== NOT EXECUTED
40013e74: 10 bf ff bc b 40013d64 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40013e78: b0 16 21 c0 or %i0, 0x1c0, %i0 ! 400321c0 <_Thread_queue_Operations_default+0x98c>
<== NOT EXECUTED
type = "char";
40013e7c: 31 10 00 c8 sethi %hi(0x40032000), %i0
<== NOT EXECUTED
40013e80: 10 bf ff b9 b 40013d64 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40013e84: b0 16 23 a0 or %i0, 0x3a0, %i0 ! 400323a0 <_Thread_queue_Operations_default+0xb6c>
<== NOT EXECUTED
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
40013e88: 96 10 00 13 mov %l3, %o3
40013e8c: 94 10 00 1c mov %i4, %o2
40013e90: 92 10 00 1d mov %i5, %o1
40013e94: 7f ff ff 43 call 40013ba0 <rtems_rfs_inode_initialise>
40013e98: 90 07 bf d8 add %fp, -40, %o0
if (rc > 0)
40013e9c: b0 92 20 00 orcc %o0, 0, %i0
40013ea0: 14 80 00 16 bg 40013ef8 <rtems_rfs_inode_create+0x218>
<== NEVER TAKEN
40013ea4: 92 07 bf d8 add %fp, -40, %o1
if (RTEMS_RFS_S_ISDIR (mode))
40013ea8: 03 10 00 00 sethi %hi(0x40000000), %g1
40013eac: 80 a4 40 01 cmp %l1, %g1
40013eb0: 02 80 00 3d be 40013fa4 <rtems_rfs_inode_create+0x2c4>
40013eb4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40013eb8: 96 10 20 01 mov 1, %o3
40013ebc: 94 07 bf b0 add %fp, -80, %o2
40013ec0: 92 10 00 19 mov %i1, %o1
40013ec4: 7f ff fe 27 call 40013760 <rtems_rfs_inode_open>
40013ec8: 90 10 00 15 mov %l5, %o0
if (rc > 0)
40013ecc: b0 92 20 00 orcc %o0, 0, %i0
40013ed0: 04 80 00 13 ble 40013f1c <rtems_rfs_inode_create+0x23c>
<== ALWAYS TAKEN
40013ed4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rtems_rfs_inode_delete (fs, &inode);
40013ed8: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40013edc: 7f ff fe be call 400139d4 <rtems_rfs_inode_delete>
<== NOT EXECUTED
40013ee0: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40013ee4: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40013ee8: 7f ff fe 95 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
40013eec: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
40013ef0: 81 c7 e0 08 ret
<== NOT EXECUTED
40013ef4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40013ef8: 7f ff fe 91 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
40013efc: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
40013f00: 10 bf ff d6 b 40013e58 <rtems_rfs_inode_create+0x178>
<== NOT EXECUTED
40013f04: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
type = "file";
40013f08: 31 10 00 c8 sethi %hi(0x40032000), %i0
<== NOT EXECUTED
40013f0c: 10 bf ff 96 b 40013d64 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40013f10: b0 16 23 a8 or %i0, 0x3a8, %i0 ! 400323a8 <_Thread_queue_Operations_default+0xb74>
<== NOT EXECUTED
type = "link";
40013f14: 10 bf ff 94 b 40013d64 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40013f18: b0 16 23 b8 or %i0, 0x3b8, %i0
<== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
40013f1c: d8 00 40 00 ld [ %g1 ], %o4
40013f20: 96 10 00 1b mov %i3, %o3
40013f24: 94 10 00 1a mov %i2, %o2
40013f28: 92 07 bf b0 add %fp, -80, %o1
40013f2c: 40 00 23 2e call 4001cbe4 <rtems_rfs_dir_add_entry>
40013f30: 90 10 00 15 mov %l5, %o0
if (rc > 0)
40013f34: b0 92 20 00 orcc %o0, 0, %i0
40013f38: 14 80 00 32 bg 40014000 <rtems_rfs_inode_create+0x320>
<== NEVER TAKEN
40013f3c: 03 10 00 00 sethi %hi(0x40000000), %g1
if (RTEMS_RFS_S_ISDIR (mode))
40013f40: 80 a4 40 01 cmp %l1, %g1
40013f44: 02 80 00 3a be 4001402c <rtems_rfs_inode_create+0x34c>
40013f48: c6 07 bf bc ld [ %fp + -68 ], %g3
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40013f4c: 94 10 20 01 mov 1, %o2
40013f50: 92 10 20 01 mov 1, %o1
40013f54: 7f ff fe ea call 40013afc <rtems_rfs_inode_time_stamp_now>
40013f58: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
40013f5c: b0 92 20 00 orcc %o0, 0, %i0
40013f60: 14 bf ff df bg 40013edc <rtems_rfs_inode_create+0x1fc>
<== NEVER TAKEN
40013f64: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
40013f68: 92 07 bf b0 add %fp, -80, %o1
40013f6c: 7f ff fe 74 call 4001393c <rtems_rfs_inode_close>
40013f70: 90 10 00 15 mov %l5, %o0
rtems_rfs_inode_delete (fs, &inode);
40013f74: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
40013f78: b0 10 00 08 mov %o0, %i0
if (rc > 0)
40013f7c: 80 a6 20 00 cmp %i0, 0
40013f80: 04 80 00 3e ble 40014078 <rtems_rfs_inode_create+0x398>
<== ALWAYS TAKEN
40013f84: 90 10 00 15 mov %l5, %o0
rtems_rfs_inode_delete (fs, &inode);
40013f88: 7f ff fe 93 call 400139d4 <rtems_rfs_inode_delete>
<== NOT EXECUTED
40013f8c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40013f90: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40013f94: 7f ff fe 6a call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
40013f98: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
40013f9c: 81 c7 e0 08 ret
<== NOT EXECUTED
40013fa0: 81 e8 00 00 restore
<== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
40013fa4: d8 00 40 00 ld [ %g1 ], %o4
40013fa8: 96 10 20 01 mov 1, %o3
40013fac: 92 07 bf d8 add %fp, -40, %o1
40013fb0: 15 10 00 c0 sethi %hi(0x40030000), %o2
40013fb4: 90 10 00 15 mov %l5, %o0
40013fb8: 40 00 23 0b call 4001cbe4 <rtems_rfs_dir_add_entry>
40013fbc: 94 12 a3 80 or %o2, 0x380, %o2
if (rc == 0)
40013fc0: b0 92 20 00 orcc %o0, 0, %i0
40013fc4: 12 80 00 0b bne 40013ff0 <rtems_rfs_inode_create+0x310>
<== NEVER TAKEN
40013fc8: 80 a6 20 00 cmp %i0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
40013fcc: 98 10 00 19 mov %i1, %o4
40013fd0: 96 10 20 02 mov 2, %o3
40013fd4: 92 07 bf d8 add %fp, -40, %o1
40013fd8: 15 10 00 c0 sethi %hi(0x40030000), %o2
40013fdc: 90 10 00 15 mov %l5, %o0
40013fe0: 40 00 23 01 call 4001cbe4 <rtems_rfs_dir_add_entry>
40013fe4: 94 12 a3 88 or %o2, 0x388, %o2
40013fe8: b0 10 00 08 mov %o0, %i0
if (rc > 0)
40013fec: 80 a6 20 00 cmp %i0, 0
40013ff0: 04 bf ff b3 ble 40013ebc <rtems_rfs_inode_create+0x1dc>
<== ALWAYS TAKEN
40013ff4: 96 10 20 01 mov 1, %o3
40013ff8: 10 bf ff b9 b 40013edc <rtems_rfs_inode_create+0x1fc>
<== NOT EXECUTED
40013ffc: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
40014000: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40014004: 7f ff fe 74 call 400139d4 <rtems_rfs_inode_delete>
<== NOT EXECUTED
40014008: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001400c: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40014010: 7f ff fe 4b call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
40014014: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40014018: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001401c: 7f ff fe 48 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
40014020: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
40014024: 81 c7 e0 08 ret
<== NOT EXECUTED
40014028: 81 e8 00 00 restore
<== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
4001402c: c4 08 e0 01 ldub [ %g3 + 1 ], %g2
40014030: c2 08 c0 00 ldub [ %g3 ], %g1
40014034: 83 28 60 08 sll %g1, 8, %g1
if (links == 0xffff)
40014038: 09 00 00 3f sethi %hi(0xfc00), %g4
links = rtems_rfs_read_u16 (&handle->node->links);
4001403c: 82 10 40 02 or %g1, %g2, %g1
if (links == 0xffff)
40014040: 88 11 23 ff or %g4, 0x3ff, %g4
40014044: 80 a0 40 04 cmp %g1, %g4
40014048: 12 80 00 03 bne 40014054 <rtems_rfs_inode_create+0x374>
<== ALWAYS TAKEN
4001404c: 84 10 00 01 mov %g1, %g2
links = 0;
40014050: 84 10 20 00 clr %g2
<== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode,
40014054: 82 00 a0 01 add %g2, 1, %g1
rtems_rfs_write_u16 (&handle->node->links, links);
40014058: 85 28 60 10 sll %g1, 0x10, %g2
4001405c: 85 30 a0 18 srl %g2, 0x18, %g2
40014060: c4 28 c0 00 stb %g2, [ %g3 ]
40014064: c4 07 bf bc ld [ %fp + -68 ], %g2
40014068: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001406c: 82 10 20 01 mov 1, %g1
40014070: 10 bf ff b7 b 40013f4c <rtems_rfs_inode_create+0x26c>
40014074: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rc = rtems_rfs_inode_close (fs, &inode);
40014078: 7f ff fe 31 call 4001393c <rtems_rfs_inode_close>
4001407c: 01 00 00 00 nop
if (rc > 0)
40014080: b0 92 20 00 orcc %o0, 0, %i0
40014084: 14 bf ff 75 bg 40013e58 <rtems_rfs_inode_create+0x178>
<== NEVER TAKEN
40014088: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
}
4001408c: 81 c7 e0 08 ret
40014090: 91 e8 20 00 restore %g0, 0, %o0
400139d4 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400139d4: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
400139d8: 90 10 20 00 clr %o0
400139dc: 40 00 05 96 call 40015034 <rtems_rfs_trace>
400139e0: 13 00 20 00 sethi %hi(0x800000), %o1
400139e4: 80 a2 20 00 cmp %o0, 0
400139e8: 02 80 00 0b be 40013a14 <rtems_rfs_inode_delete+0x40>
<== ALWAYS TAKEN
400139ec: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
400139f0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400139f4: 02 80 00 14 be 40013a44 <rtems_rfs_inode_delete+0x70>
<== NOT EXECUTED
400139f8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
400139fc: 15 10 00 c8 sethi %hi(0x40032000), %o2
<== NOT EXECUTED
40013a00: 94 12 a2 70 or %o2, 0x270, %o2 ! 40032270 <_Thread_queue_Operations_default+0xa3c>
<== NOT EXECUTED
40013a04: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013a08: 40 00 06 18 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013a0c: 90 12 23 68 or %o0, 0x368, %o0 ! 40032368 <_Thread_queue_Operations_default+0xb34>
<== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40013a10: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
40013a14: 80 a0 60 00 cmp %g1, 0
40013a18: 02 80 00 09 be 40013a3c <rtems_rfs_inode_delete+0x68>
<== NEVER TAKEN
40013a1c: ba 10 20 00 clr %i5
return rtems_rfs_group_bitmap_free (fs, true, bit);
40013a20: d4 06 60 08 ld [ %i1 + 8 ], %o2
40013a24: 92 10 20 01 mov 1, %o1
40013a28: 7f ff fe aa call 400134d0 <rtems_rfs_group_bitmap_free>
40013a2c: 90 10 00 18 mov %i0, %o0
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
if (rc > 0)
40013a30: ba 92 20 00 orcc %o0, 0, %i5
40013a34: 04 80 00 07 ble 40013a50 <rtems_rfs_inode_delete+0x7c>
<== ALWAYS TAKEN
40013a38: 92 10 00 19 mov %i1, %o1
if (rrc > 0)
rc = rrc;
}
}
return rc;
}
40013a3c: 81 c7 e0 08 ret
40013a40: 91 e8 00 1d restore %g0, %i5, %o0
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
40013a44: 15 10 00 c2 sethi %hi(0x40030800), %o2
<== NOT EXECUTED
40013a48: 10 bf ff ef b 40013a04 <rtems_rfs_inode_delete+0x30>
<== NOT EXECUTED
40013a4c: 94 12 a0 d8 or %o2, 0xd8, %o2 ! 400308d8 <__func__.8600+0x1c0>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, handle, &map);
40013a50: 94 07 bf b0 add %fp, -80, %o2
40013a54: 40 00 1c fe call 4001ae4c <rtems_rfs_block_map_open>
40013a58: 90 10 00 18 mov %i0, %o0
if (rc == 0)
40013a5c: ba 92 20 00 orcc %o0, 0, %i5
40013a60: 12 bf ff f7 bne 40013a3c <rtems_rfs_inode_delete+0x68>
<== NEVER TAKEN
40013a64: 92 07 bf b0 add %fp, -80, %o1
rrc = rtems_rfs_block_map_free_all (fs, &map);
40013a68: 40 00 20 11 call 4001baac <rtems_rfs_block_map_free_all>
40013a6c: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
40013a70: 92 07 bf b0 add %fp, -80, %o1
rrc = rtems_rfs_block_map_free_all (fs, &map);
40013a74: b6 10 00 08 mov %o0, %i3
rc = rtems_rfs_block_map_close (fs, &map);
40013a78: 40 00 1d 54 call 4001afc8 <rtems_rfs_block_map_close>
40013a7c: 90 10 00 18 mov %i0, %o0
40013a80: b8 06 60 10 add %i1, 0x10, %i4
40013a84: ba 10 00 08 mov %o0, %i5
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40013a88: 94 10 20 38 mov 0x38, %o2
40013a8c: d0 06 60 0c ld [ %i1 + 0xc ], %o0
if (rc > 0)
40013a90: 80 a7 60 00 cmp %i5, 0
40013a94: 04 80 00 0c ble 40013ac4 <rtems_rfs_inode_delete+0xf0>
<== ALWAYS TAKEN
40013a98: 92 10 20 ff mov 0xff, %o1
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40013a9c: 40 00 38 16 call 40021af4 <memset>
<== NOT EXECUTED
40013aa0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013aa4: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
40013aa8: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40013aac: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40013ab0: 40 00 21 c8 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40013ab4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->loads = 0;
40013ab8: c0 26 60 24 clr [ %i1 + 0x24 ]
<== NOT EXECUTED
handle->node = NULL;
40013abc: 10 bf ff e0 b 40013a3c <rtems_rfs_inode_delete+0x68>
<== NOT EXECUTED
40013ac0: c0 26 60 0c clr [ %i1 + 0xc ]
<== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40013ac4: 40 00 38 0c call 40021af4 <memset>
40013ac8: 01 00 00 00 nop
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013acc: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
40013ad0: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40013ad4: 92 10 00 1c mov %i4, %o1
40013ad8: 40 00 21 be call 4001c1d0 <rtems_rfs_buffer_handle_release>
40013adc: 90 10 00 18 mov %i0, %o0
handle->loads = 0;
40013ae0: c0 26 60 24 clr [ %i1 + 0x24 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40013ae4: ba 10 00 08 mov %o0, %i5
if (rrc > 0)
40013ae8: 80 a6 e0 00 cmp %i3, 0
40013aec: 04 bf ff d4 ble 40013a3c <rtems_rfs_inode_delete+0x68>
<== ALWAYS TAKEN
40013af0: c0 26 60 0c clr [ %i1 + 0xc ]
40013af4: 10 bf ff d2 b 40013a3c <rtems_rfs_inode_delete+0x68>
<== NOT EXECUTED
40013af8: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
400136ac <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400136ac: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
400136b0: 90 10 20 00 clr %o0
400136b4: 40 00 06 60 call 40015034 <rtems_rfs_trace>
400136b8: 13 00 04 00 sethi %hi(0x100000), %o1
400136bc: 80 a2 20 00 cmp %o0, 0
400136c0: 02 80 00 0c be 400136f0 <rtems_rfs_inode_load+0x44>
<== ALWAYS TAKEN
400136c4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
400136c8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
400136cc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400136d0: 02 80 00 11 be 40013714 <rtems_rfs_inode_load+0x68>
<== NOT EXECUTED
400136d4: d4 06 60 24 ld [ %i1 + 0x24 ], %o2
<== NOT EXECUTED
400136d8: 17 10 00 c8 sethi %hi(0x40032000), %o3
<== NOT EXECUTED
400136dc: 96 12 e2 70 or %o3, 0x270, %o3 ! 40032270 <_Thread_queue_Operations_default+0xa3c>
<== NOT EXECUTED
400136e0: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
400136e4: 40 00 06 e1 call 40015268 <__wrap_printf>
<== NOT EXECUTED
400136e8: 90 12 22 78 or %o0, 0x278, %o0 ! 40032278 <_Thread_queue_Operations_default+0xa44>
<== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
400136ec: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
400136f0: 80 a0 60 00 cmp %g1, 0
400136f4: 22 80 00 0b be,a 40013720 <rtems_rfs_inode_load+0x74>
400136f8: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400136fc: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40013700: 82 00 60 01 inc %g1
40013704: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
40013708: b0 10 20 00 clr %i0
}
4001370c: 81 c7 e0 08 ret
40013710: 81 e8 00 00 restore
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40013714: 17 10 00 c2 sethi %hi(0x40030800), %o3
<== NOT EXECUTED
40013718: 10 bf ff f2 b 400136e0 <rtems_rfs_inode_load+0x34>
<== NOT EXECUTED
4001371c: 96 12 e0 d8 or %o3, 0xd8, %o3 ! 400308d8 <__func__.8600+0x1c0>
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
40013720: 90 10 00 18 mov %i0, %o0
40013724: 96 10 20 01 mov 1, %o3
40013728: 40 00 21 e3 call 4001beb4 <rtems_rfs_buffer_handle_request>
4001372c: 92 06 60 10 add %i1, 0x10, %o1
if (rc > 0)
40013730: b0 92 20 00 orcc %o0, 0, %i0
40013734: 14 bf ff f6 bg 4001370c <rtems_rfs_inode_load+0x60>
<== NEVER TAKEN
40013738: 01 00 00 00 nop
handle->node = rtems_rfs_buffer_data (&handle->buffer);
4001373c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
handle->node += handle->offset;
40013740: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
40013744: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
40013748: 83 28 e0 03 sll %g3, 3, %g1
4001374c: 82 20 40 03 sub %g1, %g3, %g1
40013750: 83 28 60 03 sll %g1, 3, %g1
40013754: 82 00 80 01 add %g2, %g1, %g1
40013758: 10 bf ff e9 b 400136fc <rtems_rfs_inode_load+0x50>
4001375c: c2 26 60 0c st %g1, [ %i1 + 0xc ]
40013760 <rtems_rfs_inode_open>:
{
40013760: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
40013764: 90 10 20 00 clr %o0
40013768: 40 00 06 33 call 40015034 <rtems_rfs_trace>
4001376c: 13 00 01 00 sethi %hi(0x40000), %o1
40013770: 80 a2 20 00 cmp %o0, 0
40013774: 32 80 00 2f bne,a 40013830 <rtems_rfs_inode_open+0xd0>
<== NEVER TAKEN
40013778: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
4001377c: 80 a6 60 00 cmp %i1, 0
40013780: 02 80 00 29 be 40013824 <rtems_rfs_inode_open+0xc4>
<== NEVER TAKEN
40013784: 82 06 7f ff add %i1, -1, %g1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
40013788: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4001378c: 80 a0 40 02 cmp %g1, %g2
40013790: 18 80 00 25 bgu 40013824 <rtems_rfs_inode_open+0xc4>
<== NEVER TAKEN
40013794: 80 a6 e0 00 cmp %i3, 0
group = gino / fs->group_inodes;
40013798: fa 06 20 2c ld [ %i0 + 0x2c ], %i5
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4001379c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
400137a0: c8 06 20 30 ld [ %i0 + 0x30 ], %g4
gino = gino % fs->group_inodes;
400137a4: 81 80 20 00 wr %g0, %y
400137a8: 01 00 00 00 nop
400137ac: 01 00 00 00 nop
400137b0: 01 00 00 00 nop
400137b4: 84 70 40 1d udiv %g1, %i5, %g2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400137b8: 87 28 a0 02 sll %g2, 2, %g3
400137bc: 86 00 c0 02 add %g3, %g2, %g3
gino = gino % fs->group_inodes;
400137c0: 84 58 80 1d smul %g2, %i5, %g2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400137c4: 87 28 e0 04 sll %g3, 4, %g3
400137c8: c6 07 00 03 ld [ %i4 + %g3 ], %g3
gino = gino % fs->group_inodes;
400137cc: 82 20 40 02 sub %g1, %g2, %g1
handle->ino = ino;
400137d0: f2 26 a0 08 st %i1, [ %i2 + 8 ]
handle->offset = gino % fs->inodes_per_block;
400137d4: 81 80 20 00 wr %g0, %y
400137d8: 01 00 00 00 nop
400137dc: 01 00 00 00 nop
400137e0: 01 00 00 00 nop
400137e4: 84 70 40 04 udiv %g1, %g4, %g2
handle->node = NULL;
400137e8: c0 26 a0 0c clr [ %i2 + 0xc ]
handle->offset = gino % fs->inodes_per_block;
400137ec: 88 58 80 04 smul %g2, %g4, %g4
handle->loads = 0;
400137f0: c0 26 a0 24 clr [ %i2 + 0x24 ]
handle->offset = gino % fs->inodes_per_block;
400137f4: 82 20 40 04 sub %g1, %g4, %g1
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
400137f8: 84 00 a0 02 add %g2, 2, %g2
handle->offset = gino % fs->inodes_per_block;
400137fc: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40013800: 84 00 c0 02 add %g3, %g2, %g2
handle->dirty = false;
40013804: c0 2e a0 10 clrb [ %i2 + 0x10 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
40013808: 82 10 20 00 clr %g1
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4001380c: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
handle->bnum = 0;
40013810: c0 26 a0 14 clr [ %i2 + 0x14 ]
if ((rc == 0) && load)
40013814: 02 80 00 05 be 40013828 <rtems_rfs_inode_open+0xc8>
<== NEVER TAKEN
40013818: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_inode_load (fs, handle);
4001381c: 7f ff ff a4 call 400136ac <rtems_rfs_inode_load>
40013820: 93 e8 00 1a restore %g0, %i2, %o1
return EINVAL;
40013824: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
}
40013828: 81 c7 e0 08 ret
<== NOT EXECUTED
4001382c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
40013830: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
40013834: 40 00 06 8d call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013838: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 400322b0 <_Thread_queue_Operations_default+0xa7c>
<== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
4001383c: 10 bf ff d1 b 40013780 <rtems_rfs_inode_open+0x20>
<== NOT EXECUTED
40013840: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40013afc <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40013afc: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40013b00: c2 06 20 0c ld [ %i0 + 0xc ], %g1
{
40013b04: ba 10 00 18 mov %i0, %i5
if (!rtems_rfs_inode_is_loaded (handle))
40013b08: 80 a0 60 00 cmp %g1, 0
40013b0c: 02 80 00 23 be 40013b98 <rtems_rfs_inode_time_stamp_now+0x9c>
<== NEVER TAKEN
40013b10: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
40013b14: 40 00 48 bd call 40025e08 <time>
40013b18: 90 10 20 00 clr %o0
if (atime)
40013b1c: 80 a6 60 00 cmp %i1, 0
40013b20: 02 80 00 0f be 40013b5c <rtems_rfs_inode_time_stamp_now+0x60>
<== NEVER TAKEN
40013b24: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_write_u32 (&handle->node->atime, atime);
40013b28: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013b2c: 85 32 60 18 srl %o1, 0x18, %g2
40013b30: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
40013b34: 83 32 60 10 srl %o1, 0x10, %g1
40013b38: c4 07 60 0c ld [ %i5 + 0xc ], %g2
40013b3c: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
40013b40: 83 32 60 08 srl %o1, 8, %g1
40013b44: c4 07 60 0c ld [ %i5 + 0xc ], %g2
40013b48: c2 28 a0 12 stb %g1, [ %g2 + 0x12 ]
40013b4c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013b50: d2 28 60 13 stb %o1, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013b54: 82 10 20 01 mov 1, %g1
40013b58: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
40013b5c: 02 80 00 0f be 40013b98 <rtems_rfs_inode_time_stamp_now+0x9c>
<== NEVER TAKEN
40013b60: b0 10 20 00 clr %i0
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
40013b64: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013b68: 85 32 60 18 srl %o1, 0x18, %g2
40013b6c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
40013b70: 85 32 60 10 srl %o1, 0x10, %g2
40013b74: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013b78: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40013b7c: 85 32 60 08 srl %o1, 8, %g2
40013b80: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013b84: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40013b88: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013b8c: d2 28 60 17 stb %o1, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013b90: 82 10 20 01 mov 1, %g1
40013b94: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
40013b98: 81 c7 e0 08 ret
40013b9c: 81 e8 00 00 restore
40013844 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
40013844: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
40013848: 90 10 20 00 clr %o0
4001384c: 40 00 05 fa call 40015034 <rtems_rfs_trace>
40013850: 13 00 08 00 sethi %hi(0x200000), %o1
40013854: 80 a2 20 00 cmp %o0, 0
40013858: 02 80 00 0c be 40013888 <rtems_rfs_inode_unload+0x44>
<== ALWAYS TAKEN
4001385c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40013860: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
40013864: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40013868: 02 80 00 22 be 400138f0 <rtems_rfs_inode_unload+0xac>
<== NOT EXECUTED
4001386c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2
<== NOT EXECUTED
40013870: 17 10 00 c8 sethi %hi(0x40032000), %o3
<== NOT EXECUTED
40013874: 96 12 e2 70 or %o3, 0x270, %o3 ! 40032270 <_Thread_queue_Operations_default+0xa3c>
<== NOT EXECUTED
40013878: 11 10 00 c8 sethi %hi(0x40032000), %o0
<== NOT EXECUTED
4001387c: 40 00 06 7b call 40015268 <__wrap_printf>
<== NOT EXECUTED
40013880: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400322d8 <_Thread_queue_Operations_default+0xaa4>
<== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40013884: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
40013888: 80 a0 60 00 cmp %g1, 0
4001388c: 22 80 00 17 be,a 400138e8 <rtems_rfs_inode_unload+0xa4>
40013890: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
40013894: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40013898: 80 a0 60 00 cmp %g1, 0
4001389c: 02 80 00 10 be 400138dc <rtems_rfs_inode_unload+0x98>
<== NEVER TAKEN
400138a0: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
400138a4: 82 00 7f ff add %g1, -1, %g1
if (handle->loads == 0)
400138a8: 80 a0 60 00 cmp %g1, 0
400138ac: 12 80 00 0e bne 400138e4 <rtems_rfs_inode_unload+0xa0>
400138b0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
400138b4: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
400138b8: 80 a0 60 00 cmp %g1, 0
400138bc: 02 80 00 04 be 400138cc <rtems_rfs_inode_unload+0x88>
400138c0: 80 a6 a0 00 cmp %i2, 0
400138c4: 12 80 00 0e bne 400138fc <rtems_rfs_inode_unload+0xb8>
<== ALWAYS TAKEN
400138c8: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
400138cc: 92 06 60 10 add %i1, 0x10, %o1
400138d0: 40 00 22 40 call 4001c1d0 <rtems_rfs_buffer_handle_release>
400138d4: 90 10 00 18 mov %i0, %o0
handle->node = NULL;
400138d8: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
400138dc: 81 c7 e0 08 ret
400138e0: 91 e8 00 08 restore %g0, %o0, %o0
int rc = 0;
400138e4: 90 10 20 00 clr %o0
}
400138e8: 81 c7 e0 08 ret
400138ec: 91 e8 00 08 restore %g0, %o0, %o0
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
400138f0: 17 10 00 c2 sethi %hi(0x40030800), %o3
<== NOT EXECUTED
400138f4: 10 bf ff e1 b 40013878 <rtems_rfs_inode_unload+0x34>
<== NOT EXECUTED
400138f8: 96 12 e0 d8 or %o3, 0xd8, %o3 ! 400308d8 <__func__.8600+0x1c0>
<== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
400138fc: 40 00 49 43 call 40025e08 <time>
40013900: 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);
40013904: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40013908: 85 32 60 18 srl %o1, 0x18, %g2
4001390c: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
40013910: 85 32 60 10 srl %o1, 0x10, %g2
40013914: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40013918: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
4001391c: 85 32 60 08 srl %o1, 8, %g2
40013920: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40013924: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
40013928: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4001392c: d2 28 60 1b stb %o1, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013930: 82 10 20 01 mov 1, %g1
40013934: 10 bf ff e6 b 400138cc <rtems_rfs_inode_unload+0x88>
40013938: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
4001f3c4 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
4001f3c4: 9d e3 bf 50 save %sp, -176, %sp
<== NOT EXECUTED
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))
4001f3c8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f3cc: 13 00 40 00 sethi %hi(0x1000000), %o1
<== NOT EXECUTED
4001f3d0: 7f ff d7 19 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f3d4: a2 10 00 18 mov %i0, %l1
<== NOT EXECUTED
4001f3d8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f3dc: 12 80 00 50 bne 4001f51c <rtems_rfs_link+0x158>
<== NOT EXECUTED
4001f3e0: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001f3e4: 94 07 bf d8 add %fp, -40, %o2
<== NOT EXECUTED
4001f3e8: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001f3ec: 7f ff d0 dd call 40013760 <rtems_rfs_inode_open>
<== NOT EXECUTED
4001f3f0: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
if (rc)
4001f3f4: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4001f3f8: 12 80 00 3c bne 4001f4e8 <rtems_rfs_link+0x124>
<== NOT EXECUTED
4001f3fc: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
/*
* 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)))
4001f400: 12 80 00 0a bne 4001f428 <rtems_rfs_link+0x64>
<== NOT EXECUTED
4001f404: c2 07 bf e4 ld [ %fp + -28 ], %g1
<== NOT EXECUTED
4001f408: 05 00 00 3c sethi %hi(0xf000), %g2
<== NOT EXECUTED
4001f40c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
4001f410: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001f414: 82 08 40 02 and %g1, %g2, %g1
<== NOT EXECUTED
4001f418: 05 00 00 10 sethi %hi(0x4000), %g2
<== NOT EXECUTED
4001f41c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4001f420: 02 80 00 5a be 4001f588 <rtems_rfs_link+0x1c4>
<== NOT EXECUTED
4001f424: b0 10 20 86 mov 0x86, %i0
<== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001f428: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001f42c: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001f430: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001f434: 7f ff d0 cb call 40013760 <rtems_rfs_inode_open>
<== NOT EXECUTED
4001f438: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
if (rc)
4001f43c: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4001f440: 12 80 00 26 bne 4001f4d8 <rtems_rfs_link+0x114>
<== NOT EXECUTED
4001f444: 98 10 00 1c mov %i4, %o4
<== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
4001f448: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4001f44c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001f450: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001f454: 7f ff f5 e4 call 4001cbe4 <rtems_rfs_dir_add_entry>
<== NOT EXECUTED
4001f458: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
if (rc > 0)
4001f45c: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4001f460: 14 80 00 43 bg 4001f56c <rtems_rfs_link+0x1a8>
<== NOT EXECUTED
4001f464: c4 07 bf e4 ld [ %fp + -28 ], %g2
<== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
4001f468: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
<== NOT EXECUTED
4001f46c: c2 08 80 00 ldub [ %g2 ], %g1
<== NOT EXECUTED
4001f470: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001f474: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
if (links == 0xffff)
4001f478: 07 00 00 3f sethi %hi(0xfc00), %g3
<== NOT EXECUTED
4001f47c: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_Configuration_Interrupt_stack_size+0x7fff>
<== NOT EXECUTED
4001f480: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
4001f484: 22 80 00 3f be,a 4001f580 <rtems_rfs_link+0x1bc>
<== NOT EXECUTED
4001f488: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001f48c: 82 00 60 01 inc %g1
<== NOT EXECUTED
4001f490: 87 28 60 10 sll %g1, 0x10, %g3
<== NOT EXECUTED
4001f494: 87 30 e0 18 srl %g3, 0x18, %g3
<== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->links, links);
4001f498: c6 28 80 00 stb %g3, [ %g2 ]
<== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001f49c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001f4a0: c4 07 bf e4 ld [ %fp + -28 ], %g2
<== NOT EXECUTED
4001f4a4: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f4a8: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001f4ac: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4001f4b0: c2 2f bf e8 stb %g1, [ %fp + -24 ]
<== NOT EXECUTED
4001f4b4: 7f ff d1 92 call 40013afc <rtems_rfs_inode_time_stamp_now>
<== NOT EXECUTED
4001f4b8: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
4001f4bc: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001f4c0: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
if (rc > 0)
4001f4c4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4001f4c8: 04 80 00 0a ble 4001f4f0 <rtems_rfs_link+0x12c>
<== NOT EXECUTED
4001f4cc: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001f4d0: 7f ff d1 1b call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f4d4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f4d8: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f4dc: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4001f4e0: 7f ff d1 17 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f4e4: 01 00 00 00 nop
<== NOT EXECUTED
return rc;
4001f4e8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f4ec: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001f4f0: 7f ff d1 13 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f4f4: 01 00 00 00 nop
<== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
4001f4f8: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001f4fc: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
if (rc > 0)
4001f500: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4001f504: 14 bf ff f7 bg 4001f4e0 <rtems_rfs_link+0x11c>
<== NOT EXECUTED
4001f508: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
4001f50c: 7f ff d1 0c call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f510: 01 00 00 00 nop
<== NOT EXECUTED
return rc;
}
4001f514: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f518: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
4001f51c: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001f520: 11 10 00 ce sethi %hi(0x40033800), %o0
<== NOT EXECUTED
4001f524: 7f ff d7 51 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f528: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 40033bf0 <status_code_to_errno+0x14ac>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001f52c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001f530: 04 80 00 09 ble 4001f554 <rtems_rfs_link+0x190>
<== NOT EXECUTED
4001f534: b0 06 80 19 add %i2, %i1, %i0
<== NOT EXECUTED
4001f538: a0 10 00 19 mov %i1, %l0
<== NOT EXECUTED
printf ("%c", name[c]);
4001f53c: 7f ff d7 60 call 400152bc <__wrap_putchar>
<== NOT EXECUTED
4001f540: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
4001f544: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001f548: 80 a6 00 10 cmp %i0, %l0
<== NOT EXECUTED
4001f54c: 12 bf ff fc bne 4001f53c <rtems_rfs_link+0x178>
<== NOT EXECUTED
4001f550: 01 00 00 00 nop
<== NOT EXECUTED
printf ("(%" PRIu32 ")\n", target);
4001f554: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001f558: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f55c: 7f ff d7 43 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f560: 90 12 20 18 or %o0, 0x18, %o0 ! 40033c18 <status_code_to_errno+0x14d4>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001f564: 10 bf ff a0 b 4001f3e4 <rtems_rfs_link+0x20>
<== NOT EXECUTED
4001f568: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001f56c: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001f570: 7f ff d0 f3 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f574: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f578: 10 bf ff d9 b 4001f4dc <rtems_rfs_link+0x118>
<== NOT EXECUTED
4001f57c: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
if (links == 0xffff)
4001f580: 10 bf ff c6 b 4001f498 <rtems_rfs_link+0xd4>
<== NOT EXECUTED
4001f584: 86 10 20 00 clr %g3
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f588: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f58c: 7f ff d0 ec call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f590: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
return ENOTSUP;
4001f594: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f598: 81 e8 00 00 restore
<== NOT EXECUTED
40032450 <rtems_rfs_ops>:
40032450: 40 01 4a 88 40 01 4a 70 40 01 49 f4 40 01 47 74 @.J.@.Jp@.I.@.Gt
40032460: 40 00 41 34 40 01 48 84 40 01 46 04 40 01 42 7c @.A4@.H.@.F.@.B|
40032470: 40 01 41 d0 40 01 82 0c 40 01 82 38 40 01 84 58 @.A.@...@..8@..X
40032480: 40 01 85 1c 40 01 4a 9c 40 01 41 1c 40 01 48 04 @...@.J.@.A.@.H.
40032490: 40 01 47 c0 40 01 46 e4 40 01 46 4c @.G.@.F.@.FL
40033e4c <rtems_rfs_rtems_device_handlers>:
40033e4c: 40 01 fe ec 40 01 fe d8 40 01 fe c4 40 01 fe b0 @...@...@...@...
40033e5c: 40 01 fe 9c 40 01 83 04 40 01 43 0c 40 01 fe 94 @...@...@.C.@...
40033e6c: 40 01 82 40 40 01 82 40 40 01 82 30 40 01 84 7c @..@@..@@..0@..|
40033e7c: 40 01 82 b8 40 01 84 a0 40 01 85 54 40 01 84 3c @...@...@..T@..<
40033e8c <rtems_rfs_rtems_dir_handlers>:
40033e8c: 40 02 01 2c 40 02 00 18 40 02 00 20 40 01 85 38 @..,@...@.. @..8
40033e9c: 40 01 82 9c 40 01 82 c0 40 01 43 0c 40 01 82 64 @...@...@.C.@..d
40033eac: 40 01 82 40 40 01 4c f4 40 01 82 30 40 01 84 7c @..@@.L.@..0@..|
40033ebc: 40 01 82 b8 40 01 84 a0 40 01 85 54 40 01 84 3c @...@...@..T@..<
40014cf4 <rtems_rfs_rtems_fdatasync>:
{
40014cf4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40014cf8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
40014cfc: 40 00 1d a6 call 4001c394 <rtems_rfs_buffer_sync>
<== NOT EXECUTED
40014d00: d0 00 60 08 ld [ %g1 + 8 ], %o0
<== NOT EXECUTED
if (rc)
40014d04: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40014d08: 12 80 00 04 bne 40014d18 <rtems_rfs_rtems_fdatasync+0x24>
<== NOT EXECUTED
40014d0c: 01 00 00 00 nop
<== NOT EXECUTED
}
40014d10: 81 c7 e0 08 ret
<== NOT EXECUTED
40014d14: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
40014d18: 40 00 2f d4 call 40020c68 <__errno>
<== NOT EXECUTED
40014d1c: 01 00 00 00 nop
<== NOT EXECUTED
40014d20: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
40014d24: 81 c7 e0 08 ret
<== NOT EXECUTED
40014d28: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40033ecc <rtems_rfs_rtems_file_handlers>:
40033ecc: 40 02 07 b0 40 02 07 50 40 02 05 b0 40 02 03 6c @...@..P@...@..l
40033edc: 40 01 82 9c 40 02 02 7c 40 01 43 0c 40 02 02 10 @...@..|@.C.@...
40033eec: 40 01 4c f4 40 01 4c f4 40 01 82 30 40 01 84 7c @.L.@.L.@..0@..|
40033efc: 40 01 82 b8 40 01 84 a0 40 01 85 54 40 01 84 3c @...@...@..T@..<
40033f0c: 00 00 00 00 3f 00 00 00 00 00 00 00 52 54 45 4d ....?.......RTEM
40033f1c: 53 5f 54 41 53 4b 5f 45 58 49 54 54 45 44 00 00 S_TASK_EXITTED..
40033f2c: 00 00 00 00 52 54 45 4d 53 5f 4d 50 5f 4e 4f 54 ....RTEMS_MP_NOT
40033f3c: 5f 43 4f 4e 46 49 47 55 52 45 44 00 52 54 45 4d _CONFIGURED.RTEM
40033f4c: 53 5f 49 4e 56 41 4c 49 44 5f 4e 41 4d 45 00 00 S_INVALID_NAME..
40033f5c: 00 00 00 00 52 54 45 4d 53 5f 49 4e 56 41 4c 49 ....RTEMS_INVALI
40033f6c: 44 5f 49 44 00 00 00 00 00 00 00 00 52 54 45 4d D_ID........RTEM
40033f7c: 53 5f 54 4f 4f 5f 4d 41 4e 59 00 00 52 54 45 4d S_TOO_MANY..RTEM
40033f8c: 53 5f 54 49 4d 45 4f 55 54 00 00 00 52 54 45 4d S_TIMEOUT...RTEM
40033f9c: 53 5f 4f 42 4a 45 43 54 5f 57 41 53 5f 44 45 4c S_OBJECT_WAS_DEL
40033fac: 45 54 45 44 00 00 00 00 00 00 00 00 52 54 45 4d ETED........RTEM
40033fbc: 53 5f 49 4e 56 41 4c 49 44 5f 53 49 5a 45 00 00 S_INVALID_SIZE..
40033fcc: 00 00 00 00 52 54 45 4d 53 5f 49 4e 56 41 4c 49 ....RTEMS_INVALI
40033fdc: 44 5f 41 44 44 52 45 53 53 00 00 00 52 54 45 4d D_ADDRESS...RTEM
40033fec: 53 5f 49 4e 56 41 4c 49 44 5f 4e 55 4d 42 45 52 S_INVALID_NUMBER
40033ffc: 00 00 00 00 52 54 45 4d 53 5f 4e 4f 54 5f 44 45 ....RTEMS_NOT_DE
4003400c: 46 49 4e 45 44 00 00 00 00 00 00 00 52 54 45 4d FINED.......RTEM
4003401c: 53 5f 52 45 53 4f 55 52 43 45 5f 49 4e 5f 55 53 S_RESOURCE_IN_US
4003402c: 45 00 00 00 52 54 45 4d 53 5f 55 4e 53 41 54 49 E...RTEMS_UNSATI
4003403c: 53 46 49 45 44 00 00 00 00 00 00 00 52 54 45 4d SFIED.......RTEM
4003404c: 53 5f 49 4e 43 4f 52 52 45 43 54 5f 53 54 41 54 S_INCORRECT_STAT
4003405c: 45 00 00 00 52 54 45 4d 53 5f 41 4c 52 45 41 44 E...RTEMS_ALREAD
4003406c: 59 5f 53 55 53 50 45 4e 44 45 44 00 52 54 45 4d Y_SUSPENDED.RTEM
4003407c: 53 5f 49 4c 4c 45 47 41 4c 5f 4f 4e 5f 53 45 4c S_ILLEGAL_ON_SEL
4003408c: 46 00 00 00 52 54 45 4d 53 5f 49 4c 4c 45 47 41 F...RTEMS_ILLEGA
4003409c: 4c 5f 4f 4e 5f 52 45 4d 4f 54 45 5f 4f 42 4a 45 L_ON_REMOTE_OBJE
400340ac: 43 54 00 00 52 54 45 4d 53 5f 43 41 4c 4c 45 44 CT..RTEMS_CALLED
400340bc: 5f 46 52 4f 4d 5f 49 53 52 00 00 00 52 54 45 4d _FROM_ISR...RTEM
400340cc: 53 5f 49 4e 56 41 4c 49 44 5f 50 52 49 4f 52 49 S_INVALID_PRIORI
400340dc: 54 59 00 00 52 54 45 4d 53 5f 49 4e 56 41 4c 49 TY..RTEMS_INVALI
400340ec: 44 5f 43 4c 4f 43 4b 00 00 00 00 00 52 54 45 4d D_CLOCK.....RTEM
400340fc: 53 5f 49 4e 56 41 4c 49 44 5f 4e 4f 44 45 00 00 S_INVALID_NODE..
4003410c: 00 00 00 00 52 54 45 4d 53 5f 4e 4f 54 5f 43 4f ....RTEMS_NOT_CO
4003411c: 4e 46 49 47 55 52 45 44 00 00 00 00 52 54 45 4d NFIGURED....RTEM
4003412c: 53 5f 4e 4f 54 5f 4f 57 4e 45 52 5f 4f 46 5f 52 S_NOT_OWNER_OF_R
4003413c: 45 53 4f 55 52 43 45 00 00 00 00 00 52 54 45 4d ESOURCE.....RTEM
4003414c: 53 5f 4e 4f 54 5f 49 4d 50 4c 45 4d 45 4e 54 45 S_NOT_IMPLEMENTE
4003415c: 44 00 00 00 52 54 45 4d 53 5f 49 4e 54 45 52 4e D...RTEMS_INTERN
4003416c: 41 4c 5f 45 52 52 4f 52 00 00 00 00 52 54 45 4d AL_ERROR....RTEM
4003417c: 53 5f 4e 4f 5f 4d 45 4d 4f 52 59 00 52 54 45 4d S_NO_MEMORY.RTEM
4003418c: 53 5f 49 4f 5f 45 52 52 4f 52 00 00 52 54 45 4d S_IO_ERROR..RTEM
4003419c: 53 5f 50 52 4f 58 59 5f 42 4c 4f 43 4b 49 4e 47 S_PROXY_BLOCKING
400341ac: 00 00 00 00 ....
4001430c <rtems_rfs_rtems_fstat>:
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4001430c: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40014310: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40014314: fa 00 60 08 ld [ %g1 + 8 ], %i5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40014318: d2 06 20 08 ld [ %i0 + 8 ], %o1
4001431c: 96 10 20 01 mov 1, %o3
40014320: 94 07 bf d8 add %fp, -40, %o2
40014324: 7f ff fd 0f call 40013760 <rtems_rfs_inode_open>
40014328: 90 10 00 1d mov %i5, %o0
if (rc)
4001432c: b0 92 20 00 orcc %o0, 0, %i0
40014330: 12 80 00 b0 bne 400145f0 <rtems_rfs_rtems_fstat+0x2e4>
<== NEVER TAKEN
40014334: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_read_u16 (&handle->node->mode);
40014338: c4 08 60 03 ldub [ %g1 + 3 ], %g2
4001433c: d0 08 60 02 ldub [ %g1 + 2 ], %o0
40014340: 91 2a 20 08 sll %o0, 8, %o0
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
40014344: 07 00 00 08 sethi %hi(0x2000), %g3
40014348: 90 12 00 02 or %o0, %g2, %o0
4001434c: 05 3f ff ec sethi %hi(0xffffb000), %g2
40014350: 84 0a 00 02 and %o0, %g2, %g2
40014354: 80 a0 80 03 cmp %g2, %g3
40014358: 22 80 00 46 be,a 40014470 <rtems_rfs_rtems_fstat+0x164>
<== NEVER TAKEN
4001435c: da 08 60 20 ldub [ %g1 + 0x20 ], %o5
<== NOT EXECUTED
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
40014360: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40014364: c2 26 60 04 st %g1, [ %i1 + 4 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
40014368: c2 07 bf e0 ld [ %fp + -32 ], %g1
4001436c: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = rtems_rfs_rtems_mode (mode);
40014370: 40 00 03 2f call 4001502c <rtems_rfs_rtems_mode>
40014374: c0 26 40 00 clr [ %i1 ]
40014378: d0 26 60 0c st %o0, [ %i1 + 0xc ]
4001437c: c4 07 bf e4 ld [ %fp + -28 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
40014380: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
40014384: c2 08 80 00 ldub [ %g2 ], %g1
40014388: 83 28 60 08 sll %g1, 8, %g1
4001438c: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
40014390: 07 00 00 3f sethi %hi(0xfc00), %g3
40014394: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_Configuration_Interrupt_stack_size+0x7fff>
40014398: 80 a0 40 03 cmp %g1, %g3
4001439c: 12 80 00 03 bne 400143a8 <rtems_rfs_rtems_fstat+0x9c>
<== ALWAYS TAKEN
400143a0: 88 10 00 01 mov %g1, %g4
links = 0;
400143a4: 88 10 20 00 clr %g4
<== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
400143a8: c8 36 60 10 sth %g4, [ %i1 + 0x10 ]
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
400143ac: 90 10 00 1d mov %i5, %o0
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
400143b0: c6 08 a0 06 ldub [ %g2 + 6 ], %g3
400143b4: c2 08 a0 07 ldub [ %g2 + 7 ], %g1
400143b8: 87 28 e0 08 sll %g3, 8, %g3
400143bc: 82 10 40 03 or %g1, %g3, %g1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
400143c0: c2 36 60 12 sth %g1, [ %i1 + 0x12 ]
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
400143c4: c2 08 a0 05 ldub [ %g2 + 5 ], %g1
400143c8: c6 08 a0 04 ldub [ %g2 + 4 ], %g3
400143cc: 85 28 e0 18 sll %g3, 0x18, %g2
400143d0: 83 28 60 10 sll %g1, 0x10, %g1
400143d4: 82 10 40 02 or %g1, %g2, %g1
400143d8: 83 30 60 10 srl %g1, 0x10, %g1
400143dc: c2 36 60 14 sth %g1, [ %i1 + 0x14 ]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
400143e0: 40 00 29 aa call 4001ea88 <rtems_rfs_file_get_shared>
400143e4: d2 07 bf e0 ld [ %fp + -32 ], %o1
if (shared)
400143e8: 80 a2 20 00 cmp %o0, 0
400143ec: 02 80 00 3b be 400144d8 <rtems_rfs_rtems_fstat+0x1cc>
400143f0: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
400143f4: c4 02 20 94 ld [ %o0 + 0x94 ], %g2
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
400143f8: c2 02 20 84 ld [ %o0 + 0x84 ], %g1
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
400143fc: c8 02 20 8c ld [ %o0 + 0x8c ], %g4
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40014400: c6 02 20 90 ld [ %o0 + 0x90 ], %g3
40014404: c6 26 60 3c st %g3, [ %i1 + 0x3c ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40014408: c4 26 60 4c st %g2, [ %i1 + 0x4c ]
if (S_ISLNK (buf->st_mode))
4001440c: 05 00 00 3c sethi %hi(0xf000), %g2
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
40014410: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
40014414: c0 26 60 28 clr [ %i1 + 0x28 ]
40014418: c8 26 60 2c st %g4, [ %i1 + 0x2c ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4001441c: c0 26 60 38 clr [ %i1 + 0x38 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40014420: c0 26 60 48 clr [ %i1 + 0x48 ]
if (S_ISLNK (buf->st_mode))
40014424: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40014428: 82 08 40 02 and %g1, %g2, %g1
4001442c: 05 00 00 28 sethi %hi(0xa000), %g2
40014430: 80 a0 40 02 cmp %g1, %g2
40014434: 12 80 00 25 bne 400144c8 <rtems_rfs_rtems_fstat+0x1bc>
<== ALWAYS TAKEN
40014438: 92 02 20 84 add %o0, 0x84, %o1
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
4001443c: c2 12 20 8a lduh [ %o0 + 0x8a ], %g1
<== NOT EXECUTED
40014440: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
<== NOT EXECUTED
40014444: c0 26 60 20 clr [ %i1 + 0x20 ]
<== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
40014448: 90 10 00 1d mov %i5, %o0
buf->st_blksize = rtems_rfs_fs_block_size (fs);
4001444c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40014450: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
rc = rtems_rfs_inode_close (fs, &inode);
40014454: 7f ff fd 3a call 4001393c <rtems_rfs_inode_close>
40014458: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001445c: ba 92 20 00 orcc %o0, 0, %i5
40014460: 14 80 00 5f bg 400145dc <rtems_rfs_rtems_fstat+0x2d0>
<== NEVER TAKEN
40014464: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
return 0;
}
40014468: 81 c7 e0 08 ret
4001446c: 81 e8 00 00 restore
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
40014470: f8 08 60 21 ldub [ %g1 + 0x21 ], %i4
<== NOT EXECUTED
40014474: c8 08 60 22 ldub [ %g1 + 0x22 ], %g4
<== NOT EXECUTED
40014478: f4 08 60 23 ldub [ %g1 + 0x23 ], %i2
<== NOT EXECUTED
4001447c: de 08 60 1c ldub [ %g1 + 0x1c ], %o7
<== NOT EXECUTED
40014480: c6 08 60 1d ldub [ %g1 + 0x1d ], %g3
<== NOT EXECUTED
40014484: c4 08 60 1e ldub [ %g1 + 0x1e ], %g2
<== NOT EXECUTED
40014488: f6 08 60 1f ldub [ %g1 + 0x1f ], %i3
<== NOT EXECUTED
4001448c: 83 2b 60 18 sll %o5, 0x18, %g1
<== NOT EXECUTED
40014490: b9 2f 20 10 sll %i4, 0x10, %i4
<== NOT EXECUTED
40014494: b8 17 00 01 or %i4, %g1, %i4
<== NOT EXECUTED
40014498: 83 2b e0 18 sll %o7, 0x18, %g1
<== NOT EXECUTED
4001449c: 89 29 20 08 sll %g4, 8, %g4
<== NOT EXECUTED
400144a0: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
400144a4: 88 11 00 1c or %g4, %i4, %g4
<== NOT EXECUTED
400144a8: 86 10 c0 01 or %g3, %g1, %g3
<== NOT EXECUTED
400144ac: 88 16 80 04 or %i2, %g4, %g4
<== NOT EXECUTED
400144b0: 83 28 a0 08 sll %g2, 8, %g1
<== NOT EXECUTED
buf->st_rdev =
400144b4: c8 26 60 1c st %g4, [ %i1 + 0x1c ]
<== NOT EXECUTED
400144b8: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
400144bc: 82 16 c0 01 or %i3, %g1, %g1
<== NOT EXECUTED
400144c0: 10 bf ff a8 b 40014360 <rtems_rfs_rtems_fstat+0x54>
<== NOT EXECUTED
400144c4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
<== 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);
400144c8: 40 00 1a 4e call 4001ae00 <rtems_rfs_block_get_size>
400144cc: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
400144d0: 10 bf ff de b 40014448 <rtems_rfs_rtems_fstat+0x13c>
400144d4: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
return rtems_rfs_read_u32 (&handle->node->atime);
400144d8: c8 08 60 13 ldub [ %g1 + 0x13 ], %g4
400144dc: f8 08 60 10 ldub [ %g1 + 0x10 ], %i4
400144e0: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
400144e4: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
400144e8: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
400144ec: c0 26 60 28 clr [ %i1 + 0x28 ]
400144f0: 87 28 e0 10 sll %g3, 0x10, %g3
400144f4: 85 28 a0 08 sll %g2, 8, %g2
400144f8: 86 10 c0 1c or %g3, %i4, %g3
400144fc: 84 10 80 03 or %g2, %g3, %g2
40014500: 84 11 00 02 or %g4, %g2, %g2
40014504: c4 26 60 2c st %g2, [ %i1 + 0x2c ]
return rtems_rfs_read_u32 (&handle->node->mtime);
40014508: c8 08 60 17 ldub [ %g1 + 0x17 ], %g4
4001450c: f8 08 60 14 ldub [ %g1 + 0x14 ], %i4
40014510: c6 08 60 15 ldub [ %g1 + 0x15 ], %g3
40014514: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
40014518: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
4001451c: c0 26 60 38 clr [ %i1 + 0x38 ]
40014520: 87 28 e0 10 sll %g3, 0x10, %g3
40014524: 85 28 a0 08 sll %g2, 8, %g2
40014528: 86 10 c0 1c or %g3, %i4, %g3
4001452c: 84 10 80 03 or %g2, %g3, %g2
40014530: 84 11 00 02 or %g4, %g2, %g2
40014534: c4 26 60 3c st %g2, [ %i1 + 0x3c ]
return rtems_rfs_read_u32 (&handle->node->ctime);
40014538: c8 08 60 1b ldub [ %g1 + 0x1b ], %g4
4001453c: f8 08 60 18 ldub [ %g1 + 0x18 ], %i4
40014540: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
40014544: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
40014548: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
4001454c: c0 26 60 48 clr [ %i1 + 0x48 ]
40014550: 87 28 e0 10 sll %g3, 0x10, %g3
40014554: 85 28 a0 08 sll %g2, 8, %g2
40014558: 86 10 c0 1c or %g3, %i4, %g3
4001455c: 84 10 80 03 or %g2, %g3, %g2
40014560: 84 11 00 02 or %g4, %g2, %g2
40014564: c4 26 60 4c st %g2, [ %i1 + 0x4c ]
return rtems_rfs_read_u32 (&handle->node->block_count);
40014568: f8 08 60 0c ldub [ %g1 + 0xc ], %i4
4001456c: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
40014570: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
40014574: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
40014578: b9 2f 20 18 sll %i4, 0x18, %i4
4001457c: 87 28 e0 10 sll %g3, 0x10, %g3
40014580: 85 28 a0 08 sll %g2, 8, %g2
40014584: 86 10 c0 1c or %g3, %i4, %g3
40014588: 84 10 80 03 or %g2, %g3, %g2
4001458c: 84 11 00 02 or %g4, %g2, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
40014590: c4 26 60 5c st %g2, [ %i1 + 0x5c ]
if (S_ISLNK (buf->st_mode))
40014594: 07 00 00 3c sethi %hi(0xf000), %g3
40014598: c4 06 60 0c ld [ %i1 + 0xc ], %g2
4001459c: 84 08 80 03 and %g2, %g3, %g2
400145a0: 07 00 00 28 sethi %hi(0xa000), %g3
400145a4: 80 a0 80 03 cmp %g2, %g3
400145a8: 12 80 00 09 bne 400145cc <rtems_rfs_rtems_fstat+0x2c0>
<== ALWAYS TAKEN
400145ac: 92 07 bf d8 add %fp, -40, %o1
return rtems_rfs_read_u16 (&handle->node->block_offset);
400145b0: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
<== NOT EXECUTED
400145b4: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
<== NOT EXECUTED
400145b8: 83 28 a0 08 sll %g2, 8, %g1
<== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
400145bc: c0 26 60 20 clr [ %i1 + 0x20 ]
<== NOT EXECUTED
400145c0: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
400145c4: 10 bf ff a1 b 40014448 <rtems_rfs_rtems_fstat+0x13c>
<== NOT EXECUTED
400145c8: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
<== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
400145cc: 7f ff fe b2 call 40014094 <rtems_rfs_inode_get_size>
400145d0: 90 10 00 1d mov %i5, %o0
400145d4: 10 bf ff 9d b 40014448 <rtems_rfs_rtems_fstat+0x13c>
400145d8: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
return rtems_rfs_rtems_error ("stat: closing inode", rc);
400145dc: 40 00 31 a3 call 40020c68 <__errno>
<== NOT EXECUTED
400145e0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400145e4: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
}
400145e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400145ec: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
400145f0: 40 00 31 9e call 40020c68 <__errno>
<== NOT EXECUTED
400145f4: 01 00 00 00 nop
<== NOT EXECUTED
400145f8: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
400145fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40014600: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40014d2c <rtems_rfs_rtems_initialise>:
{
40014d2c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
40014d30: a2 10 20 05 mov 5, %l1
while (options)
40014d34: 80 a6 60 00 cmp %i1, 0
40014d38: 02 80 00 1f be 40014db4 <rtems_rfs_rtems_initialise+0x88>
<== ALWAYS TAKEN
40014d3c: ba 10 20 00 clr %i5
printf ("options=%s\n", options);
40014d40: 37 10 00 c9 sethi %hi(0x40032400), %i3
<== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40014d44: 39 10 00 c9 sethi %hi(0x40032400), %i4
<== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
40014d48: 35 10 00 c9 sethi %hi(0x40032400), %i2
<== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40014d4c: 21 10 00 c9 sethi %hi(0x40032400), %l0
<== NOT EXECUTED
printf ("options=%s\n", options);
40014d50: b6 16 e0 10 or %i3, 0x10, %i3
<== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40014d54: b8 17 20 20 or %i4, 0x20, %i4
<== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
40014d58: b4 16 a0 30 or %i2, 0x30, %i2
<== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40014d5c: a0 14 20 40 or %l0, 0x40, %l0
<== NOT EXECUTED
printf ("options=%s\n", options);
40014d60: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40014d64: 40 00 01 41 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40014d68: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40014d6c: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40014d70: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40014d74: 40 00 38 5f call 40022ef0 <strncmp>
<== NOT EXECUTED
40014d78: 94 10 20 0c mov 0xc, %o2
<== NOT EXECUTED
40014d7c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40014d80: 12 80 00 36 bne 40014e58 <rtems_rfs_rtems_initialise+0x12c>
<== NOT EXECUTED
40014d84: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
40014d88: ba 17 60 01 or %i5, 1, %i5
<== NOT EXECUTED
options = strchr (options, ',');
40014d8c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40014d90: 40 00 35 89 call 400223b4 <strchr>
<== NOT EXECUTED
40014d94: 92 10 20 2c mov 0x2c, %o1
<== NOT EXECUTED
if (options)
40014d98: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40014d9c: 22 80 00 07 be,a 40014db8 <rtems_rfs_rtems_initialise+0x8c>
<== NOT EXECUTED
40014da0: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
if (*options == '\0')
40014da4: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1
<== NOT EXECUTED
40014da8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40014dac: 12 80 00 33 bne 40014e78 <rtems_rfs_rtems_initialise+0x14c>
<== NOT EXECUTED
40014db0: b2 82 20 01 addcc %o0, 1, %i1
<== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40014db4: 92 10 20 01 mov 1, %o1
40014db8: 7f ff d0 c8 call 400090d8 <calloc>
40014dbc: 90 10 20 18 mov 0x18, %o0
if (!rtems)
40014dc0: b8 92 20 00 orcc %o0, 0, %i4
40014dc4: 02 80 00 59 be 40014f28 <rtems_rfs_rtems_initialise+0x1fc>
<== NEVER TAKEN
40014dc8: 01 00 00 00 nop
rc = rtems_rfs_mutex_create (&rtems->access);
40014dcc: 40 00 2c 25 call 4001fe60 <rtems_rfs_mutex_create>
40014dd0: 01 00 00 00 nop
40014dd4: b6 10 00 08 mov %o0, %i3
if (rc > 0)
40014dd8: 80 a6 e0 00 cmp %i3, 0
40014ddc: 14 80 00 4c bg 40014f0c <rtems_rfs_rtems_initialise+0x1e0>
<== NEVER TAKEN
40014de0: 90 10 00 1c mov %i4, %o0
40014de4: 7f ff e4 d9 call 4000e148 <_Mutex_recursive_Acquire>
40014de8: 01 00 00 00 nop
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
40014dec: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
40014df0: 94 10 00 1d mov %i5, %o2
40014df4: 98 07 bf fc add %fp, -4, %o4
40014df8: 96 10 00 11 mov %l1, %o3
40014dfc: 40 00 27 46 call 4001eb14 <rtems_rfs_fs_open>
40014e00: 92 10 00 1c mov %i4, %o1
if (rc)
40014e04: ba 92 20 00 orcc %o0, 0, %i5
40014e08: 12 80 00 2b bne 40014eb4 <rtems_rfs_rtems_initialise+0x188>
<== NEVER TAKEN
40014e0c: c2 07 bf fc ld [ %fp + -4 ], %g1
mt_entry->ops = &rtems_rfs_ops;
40014e10: 05 10 00 c9 sethi %hi(0x40032400), %g2
40014e14: 84 10 a0 50 or %g2, 0x50, %g2 ! 40032450 <rtems_rfs_ops>
mt_entry->fs_info = fs;
40014e18: c2 26 20 08 st %g1, [ %i0 + 8 ]
rtems_rfs_buffers_release (fs);
40014e1c: 90 10 00 01 mov %g1, %o0
mt_entry->ops = &rtems_rfs_ops;
40014e20: c4 26 20 0c st %g2, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40014e24: 84 10 20 01 mov 1, %g2
40014e28: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
40014e2c: c4 20 e0 08 st %g2, [ %g3 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
40014e30: 05 10 00 cf sethi %hi(0x40033c00), %g2
40014e34: 84 10 a2 8c or %g2, 0x28c, %g2 ! 40033e8c <rtems_rfs_rtems_dir_handlers>
40014e38: c4 20 e0 10 st %g2, [ %g3 + 0x10 ]
40014e3c: 40 00 1d 7c call 4001c42c <rtems_rfs_buffers_release>
40014e40: f8 00 60 80 ld [ %g1 + 0x80 ], %i4
_Mutex_recursive_Release( mutex );
40014e44: 7f ff e4 e6 call 4000e1dc <_Mutex_recursive_Release>
40014e48: 90 10 00 1c mov %i4, %o0
}
40014e4c: b0 10 00 1d mov %i5, %i0
40014e50: 81 c7 e0 08 ret
40014e54: 81 e8 00 00 restore
else if (strncmp (options, "no-local-cache",
40014e58: 94 10 20 0e mov 0xe, %o2
<== NOT EXECUTED
40014e5c: 40 00 38 25 call 40022ef0 <strncmp>
<== NOT EXECUTED
40014e60: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40014e64: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40014e68: 12 80 00 08 bne 40014e88 <rtems_rfs_rtems_initialise+0x15c>
<== NOT EXECUTED
40014e6c: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
40014e70: 10 bf ff c7 b 40014d8c <rtems_rfs_rtems_initialise+0x60>
<== NOT EXECUTED
40014e74: ba 17 60 02 or %i5, 2, %i5
<== NOT EXECUTED
while (options)
40014e78: 32 bf ff bb bne,a 40014d64 <rtems_rfs_rtems_initialise+0x38>
<== NOT EXECUTED
40014e7c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40014e80: 10 bf ff ce b 40014db8 <rtems_rfs_rtems_initialise+0x8c>
<== NOT EXECUTED
40014e84: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40014e88: 94 10 20 0d mov 0xd, %o2
<== NOT EXECUTED
40014e8c: 40 00 38 19 call 40022ef0 <strncmp>
<== NOT EXECUTED
40014e90: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40014e94: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40014e98: 12 80 00 17 bne 40014ef4 <rtems_rfs_rtems_initialise+0x1c8>
<== NOT EXECUTED
40014e9c: 94 10 20 00 clr %o2
<== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
40014ea0: 92 10 20 00 clr %o1
<== NOT EXECUTED
40014ea4: 40 00 38 f7 call 40023280 <strtoul>
<== NOT EXECUTED
40014ea8: 90 06 60 0e add %i1, 0xe, %o0
<== NOT EXECUTED
40014eac: 10 bf ff b8 b 40014d8c <rtems_rfs_rtems_initialise+0x60>
<== NOT EXECUTED
40014eb0: a2 10 00 08 mov %o0, %l1
<== NOT EXECUTED
40014eb4: 7f ff e4 ca call 4000e1dc <_Mutex_recursive_Release>
<== NOT EXECUTED
40014eb8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
40014ebc: 40 00 2b f4 call 4001fe8c <rtems_rfs_mutex_destroy>
<== NOT EXECUTED
40014ec0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
free (rtems);
40014ec4: 7f ff d1 54 call 40009414 <free>
<== NOT EXECUTED
40014ec8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
40014ecc: 40 00 2f 67 call 40020c68 <__errno>
<== NOT EXECUTED
40014ed0: 01 00 00 00 nop
<== NOT EXECUTED
40014ed4: 40 00 2f 65 call 40020c68 <__errno>
<== NOT EXECUTED
40014ed8: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
40014edc: c2 07 40 00 ld [ %i5 ], %g1
<== NOT EXECUTED
40014ee0: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
40014ee4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40014ee8: ba 60 20 00 subx %g0, 0, %i5
<== NOT EXECUTED
}
40014eec: 81 c7 e0 08 ret
<== NOT EXECUTED
40014ef0: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
40014ef4: 40 00 2f 5d call 40020c68 <__errno>
<== NOT EXECUTED
40014ef8: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
40014efc: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40014f00: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40014f04: 81 c7 e0 08 ret
<== NOT EXECUTED
40014f08: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
free (rtems);
40014f0c: 7f ff d1 42 call 40009414 <free>
<== NOT EXECUTED
40014f10: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
40014f14: 40 00 2f 55 call 40020c68 <__errno>
<== NOT EXECUTED
40014f18: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
40014f1c: f6 22 00 00 st %i3, [ %o0 ]
<== NOT EXECUTED
40014f20: 81 c7 e0 08 ret
<== NOT EXECUTED
40014f24: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
40014f28: 40 00 2f 50 call 40020c68 <__errno>
<== NOT EXECUTED
40014f2c: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
40014f30: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40014f34: 10 bf ff c6 b 40014e4c <rtems_rfs_rtems_initialise+0x120>
<== NOT EXECUTED
40014f38: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4003249c <rtems_rfs_rtems_link_handlers>:
4003249c: 40 01 84 74 40 01 82 14 40 01 84 84 40 01 85 38 @..t@...@...@..8
400324ac: 40 01 82 9c 40 01 84 20 40 01 43 0c 40 01 82 80 @...@.. @.C.@...
400324bc: 40 01 82 40 40 01 82 40 40 01 82 30 40 01 84 7c @..@@..@@..0@..|
400324cc: 40 01 82 b8 40 01 84 a0 40 01 85 54 40 01 84 3c @...@...@..T@..<
40014f3c <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
40014f3c: 9d e3 bf a0 save %sp, -96, %sp
40014f40: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40014f44: d2 08 60 02 ldub [ %g1 + 2 ], %o1
40014f48: c2 08 60 03 ldub [ %g1 + 3 ], %g1
40014f4c: 93 2a 60 08 sll %o1, 8, %o1
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
40014f50: 05 00 00 10 sethi %hi(0x4000), %g2
40014f54: 92 12 40 01 or %o1, %g1, %o1
40014f58: 82 0a 70 00 and %o1, -4096, %g1
40014f5c: 80 a0 40 02 cmp %g1, %g2
40014f60: 02 80 00 1b be 40014fcc <rtems_rfs_rtems_set_handlers+0x90>
40014f64: 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))
40014f68: 05 3f ff ec sethi %hi(0xffffb000), %g2
40014f6c: 07 00 00 08 sethi %hi(0x2000), %g3
40014f70: 84 0a 40 02 and %o1, %g2, %g2
40014f74: 80 a0 80 03 cmp %g2, %g3
40014f78: 02 80 00 0e be 40014fb0 <rtems_rfs_rtems_set_handlers+0x74>
<== NEVER TAKEN
40014f7c: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
40014f80: 80 a0 40 02 cmp %g1, %g2
40014f84: 02 80 00 20 be 40015004 <rtems_rfs_rtems_set_handlers+0xc8>
<== NEVER TAKEN
40014f88: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
40014f8c: 80 a0 40 02 cmp %g1, %g2
40014f90: 02 80 00 16 be 40014fe8 <rtems_rfs_rtems_set_handlers+0xac>
<== ALWAYS TAKEN
40014f94: 11 10 00 c9 sethi %hi(0x40032400), %o0
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
40014f98: 40 00 00 b4 call 40015268 <__wrap_printf>
<== NOT EXECUTED
40014f9c: 90 12 20 e8 or %o0, 0xe8, %o0 ! 400324e8 <rtems_rfs_rtems_eval_config+0xc>
<== NOT EXECUTED
return false;
40014fa0: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
return true;
}
40014fa4: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
40014fa8: 81 c7 e0 08 ret
<== NOT EXECUTED
40014fac: 81 e8 00 00 restore
<== NOT EXECUTED
return true;
40014fb0: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
40014fb4: 05 10 00 cf sethi %hi(0x40033c00), %g2
<== NOT EXECUTED
40014fb8: 84 10 a2 4c or %g2, 0x24c, %g2 ! 40033e4c <rtems_rfs_rtems_device_handlers>
<== NOT EXECUTED
40014fbc: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
}
40014fc0: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
40014fc4: 81 c7 e0 08 ret
<== NOT EXECUTED
40014fc8: 81 e8 00 00 restore
<== NOT EXECUTED
return true;
40014fcc: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (dir);
40014fd0: 05 10 00 cf sethi %hi(0x40033c00), %g2
40014fd4: 84 10 a2 8c or %g2, 0x28c, %g2 ! 40033e8c <rtems_rfs_rtems_dir_handlers>
40014fd8: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
40014fdc: b0 08 60 01 and %g1, 1, %i0
40014fe0: 81 c7 e0 08 ret
40014fe4: 81 e8 00 00 restore
return true;
40014fe8: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (file);
40014fec: 05 10 00 cf sethi %hi(0x40033c00), %g2
40014ff0: 84 10 a2 cc or %g2, 0x2cc, %g2 ! 40033ecc <rtems_rfs_rtems_file_handlers>
40014ff4: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
40014ff8: b0 08 60 01 and %g1, 1, %i0
40014ffc: 81 c7 e0 08 ret
40015000: 81 e8 00 00 restore
return true;
40015004: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
40015008: 05 10 00 c9 sethi %hi(0x40032400), %g2
<== NOT EXECUTED
4001500c: 84 10 a0 9c or %g2, 0x9c, %g2 ! 4003249c <rtems_rfs_rtems_link_handlers>
<== NOT EXECUTED
40015010: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
}
40015014: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
40015018: 81 c7 e0 08 ret
<== NOT EXECUTED
4001501c: 81 e8 00 00 restore
<== NOT EXECUTED
40014a9c <rtems_rfs_rtems_shutdown>:
/**
* Shutdown the file system.
*/
void
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
40014a9c: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = mt_entry->fs_info;
40014aa0: d0 06 20 08 ld [ %i0 + 8 ], %o0
rtems_rfs_rtems_private* rtems;
rtems = rtems_rfs_fs_user (fs);
/* FIXME: Return value? */
rtems_rfs_fs_close(fs);
40014aa4: 40 00 2a 26 call 4001f33c <rtems_rfs_fs_close>
40014aa8: f0 02 20 80 ld [ %o0 + 0x80 ], %i0
rtems_rfs_mutex_destroy (&rtems->access);
40014aac: 40 00 2c f8 call 4001fe8c <rtems_rfs_mutex_destroy>
40014ab0: 90 10 00 18 mov %i0, %o0
free (rtems);
40014ab4: 7f ff d2 58 call 40009414 <free>
<== NOT EXECUTED
40014ab8: 81 e8 00 00 restore
4001f9f4 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001f9f4: 9d e3 bf 00 save %sp, -256, %sp
<== NOT EXECUTED
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
4001f9f8: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
{
4001f9fc: e2 17 a0 5e lduh [ %fp + 0x5e ], %l1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
4001fa00: 7f ff d5 8d call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001fa04: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001fa08: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001fa0c: 32 80 00 19 bne,a 4001fa70 <rtems_rfs_symlink+0x7c>
<== NOT EXECUTED
4001fa10: 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))
4001fa14: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
4001fa18: 80 a0 40 1c cmp %g1, %i4
<== NOT EXECUTED
4001fa1c: 08 80 00 13 bleu 4001fa68 <rtems_rfs_symlink+0x74>
<== NOT EXECUTED
4001fa20: b4 10 20 5b mov 0x5b, %i2
<== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4001fa24: 40 00 0d 03 call 40022e30 <strlen>
<== NOT EXECUTED
4001fa28: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4001fa2c: 82 07 bf 74 add %fp, -140, %g1
<== NOT EXECUTED
4001fa30: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
<== NOT EXECUTED
4001fa34: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001fa38: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
<== NOT EXECUTED
4001fa3c: 9a 10 20 01 mov 1, %o5
<== NOT EXECUTED
4001fa40: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
<== NOT EXECUTED
4001fa44: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001fa48: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
<== NOT EXECUTED
4001fa4c: 19 00 00 28 sethi %hi(0xa000), %o4
<== NOT EXECUTED
4001fa50: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fa54: 7f ff d0 a3 call 40013ce0 <rtems_rfs_inode_create>
<== NOT EXECUTED
4001fa58: 98 13 21 ff or %o4, 0x1ff, %o4
<== NOT EXECUTED
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
4001fa5c: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001fa60: 04 80 00 20 ble 4001fae0 <rtems_rfs_symlink+0xec>
<== NOT EXECUTED
4001fa64: d2 07 bf 74 ld [ %fp + -140 ], %o1
<== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
4001fa68: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fa6c: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
4001fa70: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001fa74: 7f ff d5 fd call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001fa78: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 40033df0 <status_code_to_errno+0x16ac>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001fa7c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001fa80: 04 80 00 0a ble 4001faa8 <rtems_rfs_symlink+0xb4>
<== NOT EXECUTED
4001fa84: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001fa88: a0 10 00 19 mov %i1, %l0
<== NOT EXECUTED
4001fa8c: b4 06 80 19 add %i2, %i1, %i2
<== NOT EXECUTED
printf ("%c", name[c]);
4001fa90: 7f ff d6 0b call 400152bc <__wrap_putchar>
<== NOT EXECUTED
4001fa94: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
4001fa98: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001fa9c: 80 a4 00 1a cmp %l0, %i2
<== NOT EXECUTED
4001faa0: 12 bf ff fc bne 4001fa90 <rtems_rfs_symlink+0x9c>
<== NOT EXECUTED
4001faa4: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
printf (" link:");
4001faa8: 7f ff d5 f0 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001faac: 90 12 22 18 or %o0, 0x218, %o0 ! 40033e18 <status_code_to_errno+0x16d4>
<== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001fab0: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4001fab4: 04 bf ff d8 ble 4001fa14 <rtems_rfs_symlink+0x20>
<== NOT EXECUTED
4001fab8: a0 07 00 1b add %i4, %i3, %l0
<== NOT EXECUTED
4001fabc: b4 10 00 1b mov %i3, %i2
<== NOT EXECUTED
printf ("%c", link[c]);
4001fac0: 7f ff d5 ff call 400152bc <__wrap_putchar>
<== NOT EXECUTED
4001fac4: d0 4e 80 00 ldsb [ %i2 ], %o0
<== NOT EXECUTED
4001fac8: b4 06 a0 01 inc %i2
<== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001facc: 80 a4 00 1a cmp %l0, %i2
<== NOT EXECUTED
4001fad0: 12 bf ff fc bne 4001fac0 <rtems_rfs_symlink+0xcc>
<== NOT EXECUTED
4001fad4: 01 00 00 00 nop
<== NOT EXECUTED
4001fad8: 10 bf ff d0 b 4001fa18 <rtems_rfs_symlink+0x24>
<== NOT EXECUTED
4001fadc: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001fae0: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001fae4: 94 07 bf 88 add %fp, -120, %o2
<== NOT EXECUTED
4001fae8: 7f ff cf 1e call 40013760 <rtems_rfs_inode_open>
<== NOT EXECUTED
4001faec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001faf0: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001faf4: 14 bf ff dd bg 4001fa68 <rtems_rfs_symlink+0x74>
<== NOT EXECUTED
4001faf8: 80 a7 20 13 cmp %i4, 0x13
<== NOT EXECUTED
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
4001fafc: 18 80 00 1f bgu 4001fb78 <rtems_rfs_symlink+0x184>
<== NOT EXECUTED
4001fb00: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
4001fb04: fa 07 bf 94 ld [ %fp + -108 ], %i5
<== NOT EXECUTED
4001fb08: 82 07 60 1c add %i5, 0x1c, %g1
<== NOT EXECUTED
4001fb0c: 94 10 20 14 mov 0x14, %o2
<== NOT EXECUTED
4001fb10: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4001fb14: 40 00 07 f8 call 40021af4 <memset>
<== NOT EXECUTED
4001fb18: 92 10 20 00 clr %o1
<== NOT EXECUTED
memcpy (inode.node->data.name, link, link_length);
4001fb1c: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001fb20: 40 00 07 6b call 400218cc <memcpy>
<== NOT EXECUTED
4001fb24: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
4001fb28: c0 2f 60 0c clrb [ %i5 + 0xc ]
<== NOT EXECUTED
4001fb2c: c2 07 bf 94 ld [ %fp + -108 ], %g1
<== NOT EXECUTED
4001fb30: c0 28 60 0d clrb [ %g1 + 0xd ]
<== NOT EXECUTED
4001fb34: c2 07 bf 94 ld [ %fp + -108 ], %g1
<== NOT EXECUTED
4001fb38: c0 28 60 0e clrb [ %g1 + 0xe ]
<== NOT EXECUTED
4001fb3c: c2 07 bf 94 ld [ %fp + -108 ], %g1
<== NOT EXECUTED
4001fb40: c0 28 60 0f clrb [ %g1 + 0xf ]
<== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001fb44: 83 2f 20 10 sll %i4, 0x10, %g1
<== NOT EXECUTED
4001fb48: c4 07 bf 94 ld [ %fp + -108 ], %g2
<== NOT EXECUTED
4001fb4c: 83 30 60 18 srl %g1, 0x18, %g1
<== NOT EXECUTED
4001fb50: c2 28 a0 0a stb %g1, [ %g2 + 0xa ]
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
4001fb54: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
4001fb58: c2 07 bf 94 ld [ %fp + -108 ], %g1
<== NOT EXECUTED
4001fb5c: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001fb60: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001fb64: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fb68: 7f ff cf 75 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001fb6c: c2 2f bf 98 stb %g1, [ %fp + -104 ]
<== NOT EXECUTED
return rc;
4001fb70: 10 bf ff be b 4001fa68 <rtems_rfs_symlink+0x74>
<== NOT EXECUTED
4001fb74: b4 10 00 08 mov %o0, %i2
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
4001fb78: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001fb7c: 7f ff ec b4 call 4001ae4c <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001fb80: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001fb84: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001fb88: 04 80 00 05 ble 4001fb9c <rtems_rfs_symlink+0x1a8>
<== NOT EXECUTED
4001fb8c: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001fb90: 7f ff cf 6b call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001fb94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rc;
4001fb98: 30 bf ff b4 b,a 4001fa68 <rtems_rfs_symlink+0x74>
<== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001fb9c: 96 07 bf 78 add %fp, -136, %o3
<== NOT EXECUTED
4001fba0: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4001fba4: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001fba8: 7f ff ed ff call 4001b3a4 <rtems_rfs_block_map_grow>
<== NOT EXECUTED
4001fbac: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001fbb0: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001fbb4: 04 80 00 07 ble 4001fbd0 <rtems_rfs_symlink+0x1dc>
<== NOT EXECUTED
4001fbb8: d4 07 bf 78 ld [ %fp + -136 ], %o2
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001fbbc: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001fbc0: 7f ff ed 02 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001fbc4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001fbc8: 10 bf ff f2 b 4001fb90 <rtems_rfs_symlink+0x19c>
<== NOT EXECUTED
4001fbcc: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
handle->dirty = false;
4001fbd0: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4001fbd4: 96 10 20 00 clr %o3
<== NOT EXECUTED
handle->bnum = 0;
4001fbd8: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001fbdc: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
handle->buffer = NULL;
4001fbe0: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
4001fbe4: 7f ff f0 b4 call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001fbe8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001fbec: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001fbf0: 14 bf ff f4 bg 4001fbc0 <rtems_rfs_symlink+0x1cc>
<== NOT EXECUTED
4001fbf4: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
4001fbf8: c2 07 bf 84 ld [ %fp + -124 ], %g1
<== NOT EXECUTED
4001fbfc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
4001fc00: d4 06 20 08 ld [ %i0 + 8 ], %o2
<== NOT EXECUTED
4001fc04: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4001fc08: 40 00 07 bb call 40021af4 <memset>
<== NOT EXECUTED
4001fc0c: 92 10 20 ff mov 0xff, %o1
<== NOT EXECUTED
memcpy (data, link, link_length);
4001fc10: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001fc14: 40 00 07 2e call 400218cc <memcpy>
<== NOT EXECUTED
4001fc18: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001fc1c: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
4001fc20: 7f ff f1 6c call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001fc24: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
4001fc28: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001fc2c: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
4001fc30: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001fc34: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001fc38: 7f ff ec e4 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001fc3c: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
if (rc > 0)
4001fc40: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001fc44: 04 bf ff c1 ble 4001fb48 <rtems_rfs_symlink+0x154>
<== NOT EXECUTED
4001fc48: 83 2f 20 10 sll %i4, 0x10, %g1
<== NOT EXECUTED
4001fc4c: 10 bf ff d1 b 4001fb90 <rtems_rfs_symlink+0x19c>
<== NOT EXECUTED
4001fc50: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
4001fc54 <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)
{
4001fc54: 9d e3 bf 18 save %sp, -232, %sp
<== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
4001fc58: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
4001fc5c: 7f ff d4 f6 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001fc60: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001fc64: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001fc68: 12 80 00 2f bne 4001fd24 <rtems_rfs_symlink_read+0xd0>
<== NOT EXECUTED
4001fc6c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001fc70: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001fc74: 94 07 bf 88 add %fp, -120, %o2
<== NOT EXECUTED
4001fc78: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001fc7c: 7f ff ce b9 call 40013760 <rtems_rfs_inode_open>
<== NOT EXECUTED
4001fc80: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc)
4001fc84: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001fc88: 12 80 00 25 bne 4001fd1c <rtems_rfs_symlink_read+0xc8>
<== NOT EXECUTED
4001fc8c: d2 07 bf 94 ld [ %fp + -108 ], %o1
<== NOT EXECUTED
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
4001fc90: 05 00 00 3c sethi %hi(0xf000), %g2
<== NOT EXECUTED
return rtems_rfs_read_u16 (&handle->node->mode);
4001fc94: c2 0a 60 02 ldub [ %o1 + 2 ], %g1
<== NOT EXECUTED
4001fc98: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001fc9c: 82 08 40 02 and %g1, %g2, %g1
<== NOT EXECUTED
4001fca0: 05 00 00 28 sethi %hi(0xa000), %g2
<== NOT EXECUTED
4001fca4: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4001fca8: 32 80 00 3e bne,a 4001fda0 <rtems_rfs_symlink_read+0x14c>
<== NOT EXECUTED
4001fcac: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001fcb0: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
<== NOT EXECUTED
4001fcb4: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
<== NOT EXECUTED
4001fcb8: 95 2a a0 08 sll %o2, 8, %o2
<== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4001fcbc: 94 12 80 01 or %o2, %g1, %o2
<== NOT EXECUTED
4001fcc0: 80 a2 80 1b cmp %o2, %i3
<== NOT EXECUTED
4001fcc4: 38 80 00 28 bgu,a 4001fd64 <rtems_rfs_symlink_read+0x110>
<== NOT EXECUTED
4001fcc8: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4001fccc: d4 27 00 00 st %o2, [ %i4 ]
<== NOT EXECUTED
return rtems_rfs_read_u32 (&handle->node->block_count);
4001fcd0: c6 0a 60 0c ldub [ %o1 + 0xc ], %g3
<== NOT EXECUTED
4001fcd4: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
<== NOT EXECUTED
4001fcd8: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
<== NOT EXECUTED
4001fcdc: c8 0a 60 0f ldub [ %o1 + 0xf ], %g4
<== NOT EXECUTED
4001fce0: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
4001fce4: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001fce8: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001fcec: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
4001fcf0: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001fcf4: 80 91 00 01 orcc %g4, %g1, %g0
<== NOT EXECUTED
4001fcf8: 32 80 00 10 bne,a 4001fd38 <rtems_rfs_symlink_read+0xe4>
<== NOT EXECUTED
4001fcfc: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
4001fd00: 92 02 60 1c add %o1, 0x1c, %o1
<== NOT EXECUTED
4001fd04: 40 00 06 f2 call 400218cc <memcpy>
<== NOT EXECUTED
4001fd08: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
4001fd0c: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
4001fd10: 7f ff cf 0b call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001fd14: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fd18: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
return rc;
}
4001fd1c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fd20: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
4001fd24: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001fd28: 7f ff d5 50 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001fd2c: 90 12 22 20 or %o0, 0x220, %o0 ! 40033e20 <status_code_to_errno+0x16dc>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001fd30: 10 bf ff d1 b 4001fc74 <rtems_rfs_symlink_read+0x20>
<== NOT EXECUTED
4001fd34: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
4001fd38: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001fd3c: 7f ff ec 44 call 4001ae4c <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001fd40: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001fd44: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001fd48: 04 80 00 1b ble 4001fdb4 <rtems_rfs_symlink_read+0x160>
<== NOT EXECUTED
4001fd4c: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001fd50: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fd54: 7f ff ce fa call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001fd58: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4001fd5c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fd60: 81 e8 00 00 restore
<== NOT EXECUTED
4001fd64: d4 27 00 00 st %o2, [ %i4 ]
<== NOT EXECUTED
4001fd68: c6 0a 60 0c ldub [ %o1 + 0xc ], %g3
<== NOT EXECUTED
4001fd6c: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
<== NOT EXECUTED
4001fd70: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
<== NOT EXECUTED
4001fd74: c8 0a 60 0f ldub [ %o1 + 0xf ], %g4
<== NOT EXECUTED
4001fd78: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
4001fd7c: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001fd80: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001fd84: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
4001fd88: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001fd8c: 80 91 00 01 orcc %g4, %g1, %g0
<== NOT EXECUTED
4001fd90: 32 bf ff ea bne,a 4001fd38 <rtems_rfs_symlink_read+0xe4>
<== NOT EXECUTED
4001fd94: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
memcpy (path, inode.node->data.name, *length);
4001fd98: 10 bf ff db b 4001fd04 <rtems_rfs_symlink_read+0xb0>
<== NOT EXECUTED
4001fd9c: 92 02 60 1c add %o1, 0x1c, %o1
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001fda0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fda4: 7f ff ce e6 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001fda8: ba 10 20 16 mov 0x16, %i5
<== NOT EXECUTED
}
4001fdac: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fdb0: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001fdb4: 98 07 bf 78 add %fp, -136, %o4
<== NOT EXECUTED
4001fdb8: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001fdbc: 96 10 20 00 clr %o3
<== NOT EXECUTED
4001fdc0: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001fdc4: 7f ff ed 4d call 4001b2f8 <rtems_rfs_block_map_seek>
<== NOT EXECUTED
4001fdc8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001fdcc: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001fdd0: 04 80 00 07 ble 4001fdec <rtems_rfs_symlink_read+0x198>
<== NOT EXECUTED
4001fdd4: d4 07 bf 78 ld [ %fp + -136 ], %o2
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001fdd8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001fddc: 7f ff ec 7b call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001fde0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001fde4: 10 bf ff db b 4001fd50 <rtems_rfs_symlink_read+0xfc>
<== NOT EXECUTED
4001fde8: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
handle->dirty = false;
4001fdec: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4001fdf0: 96 10 20 00 clr %o3
<== NOT EXECUTED
handle->bnum = 0;
4001fdf4: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001fdf8: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
handle->buffer = NULL;
4001fdfc: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
4001fe00: 7f ff f0 2d call 4001beb4 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001fe04: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001fe08: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001fe0c: 14 bf ff f4 bg 4001fddc <rtems_rfs_symlink_read+0x188>
<== NOT EXECUTED
4001fe10: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
memcpy (path, data, *length);
4001fe14: c2 07 bf 84 ld [ %fp + -124 ], %g1
<== NOT EXECUTED
4001fe18: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
<== NOT EXECUTED
4001fe1c: d4 07 00 00 ld [ %i4 ], %o2
<== NOT EXECUTED
4001fe20: 40 00 06 ab call 400218cc <memcpy>
<== NOT EXECUTED
4001fe24: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001fe28: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
4001fe2c: 7f ff f0 e9 call 4001c1d0 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001fe30: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
4001fe34: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001fe38: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
4001fe3c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001fe40: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001fe44: 7f ff ec 61 call 4001afc8 <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001fe48: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
if (rc > 0)
4001fe4c: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001fe50: 04 bf ff b0 ble 4001fd10 <rtems_rfs_symlink_read+0xbc>
<== NOT EXECUTED
4001fe54: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
4001fe58: 10 bf ff bf b 4001fd54 <rtems_rfs_symlink_read+0x100>
<== NOT EXECUTED
4001fe5c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40015034 <rtems_rfs_trace>:
bool
rtems_rfs_trace (rtems_rfs_trace_mask mask)
{
bool result = false;
if (mask & rtems_rfs_trace_flags)
40015034: 03 10 01 39 sethi %hi(0x4004e400), %g1
40015038: 84 10 61 00 or %g1, 0x100, %g2 ! 4004e500 <rtems_rfs_trace_flags>
4001503c: c2 00 61 00 ld [ %g1 + 0x100 ], %g1
40015040: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40015044: 90 08 40 08 and %g1, %o0, %o0
40015048: 92 08 80 09 and %g2, %o1, %o1
4001504c: 90 12 00 09 or %o0, %o1, %o0
result = true;
return result;
}
40015050: 80 a0 00 08 cmp %g0, %o0
40015054: 81 c3 e0 08 retl
40015058: 90 40 20 00 addx %g0, 0, %o0
4001505c: 00 00 00 00 unimp 0
<== NOT EXECUTED
4001f59c <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)
{
4001f59c: 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))
4001f5a0: 90 10 20 00 clr %o0
4001f5a4: 7f ff d6 a4 call 40015034 <rtems_rfs_trace>
4001f5a8: 13 00 80 00 sethi %hi(0x2000000), %o1
4001f5ac: 80 a2 20 00 cmp %o0, 0
4001f5b0: 12 80 00 30 bne 4001f670 <rtems_rfs_unlink+0xd4>
<== NEVER TAKEN
4001f5b4: 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);
4001f5b8: 96 10 20 01 mov 1, %o3
4001f5bc: 94 07 bf d8 add %fp, -40, %o2
4001f5c0: 92 10 00 1a mov %i2, %o1
4001f5c4: 7f ff d0 67 call 40013760 <rtems_rfs_inode_open>
4001f5c8: 90 10 00 18 mov %i0, %o0
if (rc)
4001f5cc: ba 92 20 00 orcc %o0, 0, %i5
4001f5d0: 12 80 00 26 bne 4001f668 <rtems_rfs_unlink+0xcc>
<== NEVER TAKEN
4001f5d4: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001f5d8: 05 00 00 3c sethi %hi(0xf000), %g2
return rtems_rfs_read_u16 (&handle->node->mode);
4001f5dc: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001f5e0: 83 28 60 08 sll %g1, 8, %g1
4001f5e4: 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)
4001f5e8: 05 00 00 10 sethi %hi(0x4000), %g2
4001f5ec: 80 a0 40 02 cmp %g1, %g2
4001f5f0: 12 80 00 0d bne 4001f624 <rtems_rfs_unlink+0x88>
4001f5f4: a1 28 60 10 sll %g1, 0x10, %l0
{
switch (dir_mode)
4001f5f8: 80 a7 20 00 cmp %i4, 0
4001f5fc: 02 80 00 72 be 4001f7c4 <rtems_rfs_unlink+0x228>
<== NEVER TAKEN
4001f600: 80 a7 20 01 cmp %i4, 1
4001f604: 12 80 00 09 bne 4001f628 <rtems_rfs_unlink+0x8c>
<== NEVER TAKEN
4001f608: 96 10 20 01 mov 1, %o3
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
4001f60c: 92 07 bf d8 add %fp, -40, %o1
4001f610: 7f ff f8 7d call 4001d804 <rtems_rfs_dir_empty>
4001f614: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001f618: ba 92 20 00 orcc %o0, 0, %i5
4001f61c: 14 80 00 81 bg 4001f820 <rtems_rfs_unlink+0x284>
4001f620: 90 10 20 00 clr %o0
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001f624: 96 10 20 01 mov 1, %o3
4001f628: 94 07 bf b0 add %fp, -80, %o2
4001f62c: 92 10 00 19 mov %i1, %o1
4001f630: 7f ff d0 4c call 40013760 <rtems_rfs_inode_open>
4001f634: 90 10 00 18 mov %i0, %o0
if (rc)
4001f638: ba 92 20 00 orcc %o0, 0, %i5
4001f63c: 02 80 00 13 be 4001f688 <rtems_rfs_unlink+0xec>
<== ALWAYS TAKEN
4001f640: 96 10 00 1b mov %i3, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f644: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f648: 7f ff d6 7b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f64c: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f650: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f654: 12 80 00 6a bne 4001f7fc <rtems_rfs_unlink+0x260>
<== NOT EXECUTED
4001f658: 01 00 00 00 nop
<== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
4001f65c: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f660: 7f ff d0 b7 call 4001393c <rtems_rfs_inode_close>
4001f664: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
4001f668: 81 c7 e0 08 ret
4001f66c: 91 e8 00 1d restore %g0, %i5, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
4001f670: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001f674: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f678: 7f ff d6 fc call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f67c: 90 12 20 20 or %o0, 0x20, %o0 ! 40033c20 <status_code_to_errno+0x14dc>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001f680: 10 bf ff cf b 4001f5bc <rtems_rfs_unlink+0x20>
<== NOT EXECUTED
4001f684: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
4001f688: 94 10 00 1a mov %i2, %o2
4001f68c: 92 07 bf b0 add %fp, -80, %o1
4001f690: 7f ff f6 5e call 4001d008 <rtems_rfs_dir_del_entry>
4001f694: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001f698: ba 92 20 00 orcc %o0, 0, %i5
4001f69c: 14 80 00 34 bg 4001f76c <rtems_rfs_unlink+0x1d0>
<== NEVER TAKEN
4001f6a0: c2 07 bf e4 ld [ %fp + -28 ], %g1
links = rtems_rfs_read_u16 (&handle->node->links);
4001f6a4: fa 08 40 00 ldub [ %g1 ], %i5
4001f6a8: c2 08 60 01 ldub [ %g1 + 1 ], %g1
4001f6ac: bb 2f 60 08 sll %i5, 8, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f6b0: 90 10 20 00 clr %o0
4001f6b4: ba 17 40 01 or %i5, %g1, %i5
if (links == 0xffff)
4001f6b8: b9 2f 60 10 sll %i5, 0x10, %i4
4001f6bc: 03 00 00 3f sethi %hi(0xfc00), %g1
4001f6c0: b7 37 20 10 srl %i4, 0x10, %i3
4001f6c4: 82 10 63 ff or %g1, 0x3ff, %g1
4001f6c8: 80 a6 c0 01 cmp %i3, %g1
4001f6cc: 02 80 00 69 be 4001f870 <rtems_rfs_unlink+0x2d4>
<== NEVER TAKEN
4001f6d0: 13 00 80 00 sethi %hi(0x2000000), %o1
4001f6d4: 7f ff d6 58 call 40015034 <rtems_rfs_trace>
4001f6d8: 01 00 00 00 nop
4001f6dc: 80 a2 20 00 cmp %o0, 0
4001f6e0: 12 80 00 5e bne 4001f858 <rtems_rfs_unlink+0x2bc>
<== NEVER TAKEN
4001f6e4: 94 10 00 1b mov %i3, %o2
if (links > 1)
4001f6e8: b9 37 20 10 srl %i4, 0x10, %i4
4001f6ec: 80 a7 20 01 cmp %i4, 1
4001f6f0: 08 80 00 6a bleu 4001f898 <rtems_rfs_unlink+0x2fc>
<== ALWAYS TAKEN
4001f6f4: c4 07 bf e4 ld [ %fp + -28 ], %g2
links--;
4001f6f8: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->links, links);
4001f6fc: 83 2f 60 10 sll %i5, 0x10, %g1
<== NOT EXECUTED
4001f700: 83 30 60 18 srl %g1, 0x18, %g1
<== NOT EXECUTED
4001f704: c2 28 80 00 stb %g1, [ %g2 ]
<== NOT EXECUTED
4001f708: c2 07 bf e4 ld [ %fp + -28 ], %g1
<== NOT EXECUTED
4001f70c: fa 28 60 01 stb %i5, [ %g1 + 1 ]
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f710: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001f714: c2 2f bf e8 stb %g1, [ %fp + -24 ]
<== NOT EXECUTED
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001f718: 94 10 20 01 mov 1, %o2
4001f71c: 92 10 20 01 mov 1, %o1
4001f720: 7f ff d0 f7 call 40013afc <rtems_rfs_inode_time_stamp_now>
4001f724: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
4001f728: ba 92 20 00 orcc %o0, 0, %i5
4001f72c: 04 80 00 79 ble 4001f910 <rtems_rfs_unlink+0x374>
<== ALWAYS TAKEN
4001f730: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f734: 7f ff d6 40 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f738: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f73c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f740: 22 80 00 19 be,a 4001f7a4 <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001f744: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
4001f748: 40 00 0d 91 call 40022d8c <strerror>
<== NOT EXECUTED
4001f74c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f750: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f754: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f758: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f75c: 7f ff d6 c3 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f760: 90 12 21 48 or %o0, 0x148, %o0 ! 40033d48 <status_code_to_errno+0x1604>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001f764: 10 80 00 10 b 4001f7a4 <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001f768: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f76c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f770: 7f ff d6 31 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f774: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f778: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f77c: 02 80 00 0a be 4001f7a4 <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001f780: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
4001f784: 40 00 0d 82 call 40022d8c <strerror>
<== NOT EXECUTED
4001f788: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f78c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f790: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f794: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f798: 7f ff d6 b4 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f79c: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40033cc0 <status_code_to_errno+0x157c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001f7a0: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001f7a4: 7f ff d0 66 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f7a8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f7ac: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f7b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001f7b4: 7f ff d0 62 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f7b8: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4001f7bc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f7c0: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f7c4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f7c8: 7f ff d6 1b call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f7cc: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f7d0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f7d4: 02 80 00 06 be 4001f7ec <rtems_rfs_unlink+0x250>
<== NOT EXECUTED
4001f7d8: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
4001f7dc: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f7e0: 7f ff d6 b1 call 400152a4 <__wrap_puts>
<== NOT EXECUTED
4001f7e4: 90 12 20 50 or %o0, 0x50, %o0 ! 40033c50 <status_code_to_errno+0x150c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f7e8: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001f7ec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001f7f0: 7f ff d0 53 call 4001393c <rtems_rfs_inode_close>
<== NOT EXECUTED
4001f7f4: ba 10 20 15 mov 0x15, %i5
<== NOT EXECUTED
return EISDIR;
4001f7f8: 30 bf ff 9c b,a 4001f668 <rtems_rfs_unlink+0xcc>
<== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
4001f7fc: 40 00 0d 64 call 40022d8c <strerror>
<== NOT EXECUTED
4001f800: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f804: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f808: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f80c: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f810: 7f ff d6 96 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f814: 90 12 20 90 or %o0, 0x90, %o0 ! 40033c90 <status_code_to_errno+0x154c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f818: 10 bf ff 92 b 4001f660 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001f81c: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f820: 7f ff d6 05 call 40015034 <rtems_rfs_trace>
4001f824: 13 00 80 00 sethi %hi(0x2000000), %o1
4001f828: 80 a2 20 00 cmp %o0, 0
4001f82c: 22 bf ff 8d be,a 4001f660 <rtems_rfs_unlink+0xc4>
<== ALWAYS TAKEN
4001f830: 92 07 bf d8 add %fp, -40, %o1
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4001f834: 40 00 0d 56 call 40022d8c <strerror>
<== NOT EXECUTED
4001f838: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f83c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f840: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f844: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f848: 7f ff d6 88 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f84c: 90 12 20 70 or %o0, 0x70, %o0 ! 40033c70 <status_code_to_errno+0x152c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f850: 10 bf ff 84 b 4001f660 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001f854: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001f858: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001f85c: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f860: 7f ff d6 82 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f864: 90 12 20 f0 or %o0, 0xf0, %o0 ! 40033cf0 <status_code_to_errno+0x15ac>
<== NOT EXECUTED
if (links > 1)
4001f868: 10 bf ff a1 b 4001f6ec <rtems_rfs_unlink+0x150>
<== NOT EXECUTED
4001f86c: b9 37 20 10 srl %i4, 0x10, %i4
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f870: 7f ff d5 f1 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f874: 01 00 00 00 nop
<== NOT EXECUTED
4001f878: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f87c: 02 80 00 08 be 4001f89c <rtems_rfs_unlink+0x300>
<== NOT EXECUTED
4001f880: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001f884: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f888: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001f88c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001f890: 7f ff d6 76 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f894: 90 12 20 f0 or %o0, 0xf0, %o0
<== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
4001f898: 92 07 bf d8 add %fp, -40, %o1
4001f89c: 7f ff d0 4e call 400139d4 <rtems_rfs_inode_delete>
4001f8a0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001f8a4: ba 92 20 00 orcc %o0, 0, %i5
4001f8a8: 14 80 00 41 bg 4001f9ac <rtems_rfs_unlink+0x410>
<== NEVER TAKEN
4001f8ac: 03 10 00 00 sethi %hi(0x40000000), %g1
if (dir)
4001f8b0: 80 a4 00 01 cmp %l0, %g1
4001f8b4: 12 bf ff 9a bne 4001f71c <rtems_rfs_unlink+0x180>
4001f8b8: 94 10 20 01 mov 1, %o2
4001f8bc: c4 07 bf bc ld [ %fp + -68 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
4001f8c0: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001f8c4: c2 08 80 00 ldub [ %g2 ], %g1
4001f8c8: 83 28 60 08 sll %g1, 8, %g1
4001f8cc: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
4001f8d0: 07 00 00 3f sethi %hi(0xfc00), %g3
4001f8d4: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_Configuration_Interrupt_stack_size+0x7fff>
4001f8d8: 80 a0 40 03 cmp %g1, %g3
4001f8dc: 02 80 00 43 be 4001f9e8 <rtems_rfs_unlink+0x44c>
<== NEVER TAKEN
4001f8e0: 80 a0 60 01 cmp %g1, 1
if (links > 1)
4001f8e4: 08 80 00 05 bleu 4001f8f8 <rtems_rfs_unlink+0x35c>
<== NEVER TAKEN
4001f8e8: 86 10 20 00 clr %g3
links--;
4001f8ec: 82 00 7f ff add %g1, -1, %g1
4001f8f0: 87 28 60 10 sll %g1, 0x10, %g3
4001f8f4: 87 30 e0 18 srl %g3, 0x18, %g3
rtems_rfs_write_u16 (&handle->node->links, links);
4001f8f8: c6 28 80 00 stb %g3, [ %g2 ]
4001f8fc: c4 07 bf bc ld [ %fp + -68 ], %g2
4001f900: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f904: 82 10 20 01 mov 1, %g1
4001f908: 10 bf ff 84 b 4001f718 <rtems_rfs_unlink+0x17c>
4001f90c: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001f910: 92 07 bf b0 add %fp, -80, %o1
4001f914: 7f ff d0 0a call 4001393c <rtems_rfs_inode_close>
4001f918: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001f91c: ba 92 20 00 orcc %o0, 0, %i5
4001f920: 04 80 00 10 ble 4001f960 <rtems_rfs_unlink+0x3c4>
<== ALWAYS TAKEN
4001f924: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f928: 7f ff d5 c3 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f92c: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f930: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f934: 22 bf ff 4b be,a 4001f660 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001f938: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
4001f93c: 40 00 0d 14 call 40022d8c <strerror>
<== NOT EXECUTED
4001f940: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f944: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f948: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f94c: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f950: 7f ff d6 46 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f954: 90 12 21 80 or %o0, 0x180, %o0 ! 40033d80 <status_code_to_errno+0x163c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001f958: 10 bf ff 42 b 4001f660 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001f95c: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &target_inode);
4001f960: 92 07 bf d8 add %fp, -40, %o1
4001f964: 7f ff cf f6 call 4001393c <rtems_rfs_inode_close>
4001f968: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f96c: ba 92 20 00 orcc %o0, 0, %i5
4001f970: 04 bf ff 3e ble 4001f668 <rtems_rfs_unlink+0xcc>
<== ALWAYS TAKEN
4001f974: 90 10 20 00 clr %o0
4001f978: 7f ff d5 af call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f97c: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f980: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f984: 02 bf ff 39 be 4001f668 <rtems_rfs_unlink+0xcc>
<== NOT EXECUTED
4001f988: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
4001f98c: 40 00 0d 00 call 40022d8c <strerror>
<== NOT EXECUTED
4001f990: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f994: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f998: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f99c: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f9a0: 7f ff d6 32 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f9a4: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 40033db8 <status_code_to_errno+0x1674>
<== NOT EXECUTED
4001f9a8: 30 bf ff 30 b,a 4001f668 <rtems_rfs_unlink+0xcc>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001f9ac: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f9b0: 7f ff d5 a1 call 40015034 <rtems_rfs_trace>
<== NOT EXECUTED
4001f9b4: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001f9b8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f9bc: 22 bf ff 7a be,a 4001f7a4 <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001f9c0: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
4001f9c4: 40 00 0c f2 call 40022d8c <strerror>
<== NOT EXECUTED
4001f9c8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001f9cc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001f9d0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001f9d4: 11 10 00 cf sethi %hi(0x40033c00), %o0
<== NOT EXECUTED
4001f9d8: 7f ff d6 24 call 40015268 <__wrap_printf>
<== NOT EXECUTED
4001f9dc: 90 12 21 18 or %o0, 0x118, %o0 ! 40033d18 <status_code_to_errno+0x15d4>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001f9e0: 10 bf ff 71 b 4001f7a4 <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001f9e4: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
if (links == 0xffff)
4001f9e8: 82 10 20 00 clr %g1
<== NOT EXECUTED
4001f9ec: 10 bf ff c3 b 4001f8f8 <rtems_rfs_unlink+0x35c>
<== NOT EXECUTED
4001f9f0: 86 10 20 00 clr %g3
<== NOT EXECUTED