RTEMS-5
Annotated Report
Fri Aug 10 13:42:31 2018
4000f374 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
4000f374: 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);
4000f378: 90 10 00 18 mov %i0, %o0
{
4000f37c: ba 10 00 18 mov %i0, %i5
rc = rtems_rfs_bitmap_load_map (control, &map);
4000f380: 7f ff fe 53 call 4000eccc <rtems_rfs_bitmap_load_map>
4000f384: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4000f388: b0 92 20 00 orcc %o0, 0, %i0
4000f38c: 24 80 00 04 ble,a 4000f39c <rtems_rfs_bitmap_create_search+0x28>
4000f390: c0 27 60 10 clr [ %i5 + 0x10 ]
bit++;
map++;
}
return 0;
}
4000f394: 81 c7 e0 08 ret
4000f398: 81 e8 00 00 restore
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4000f39c: 82 10 3f ff mov -1, %g1
search_map = control->search_bits;
4000f3a0: f0 07 60 14 ld [ %i5 + 0x14 ], %i0
size = control->size;
4000f3a4: c6 07 60 0c ld [ %i5 + 0xc ], %g3
while (size)
4000f3a8: 80 a0 e0 00 cmp %g3, 0
4000f3ac: 02 80 00 31 be 4000f470 <rtems_rfs_bitmap_create_search+0xfc>
<== NEVER TAKEN
4000f3b0: c2 26 00 00 st %g1, [ %i0 ]
4000f3b4: f8 07 bf fc ld [ %fp + -4 ], %i4
bit = 0;
4000f3b8: b4 10 20 00 clr %i2
available = rtems_rfs_bitmap_element_bits ();
4000f3bc: 9a 10 20 20 mov 0x20, %o5
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4000f3c0: 9e 10 3f ff mov -1, %o7
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4000f3c4: 10 80 00 10 b 4000f404 <rtems_rfs_bitmap_create_search+0x90>
4000f3c8: b2 10 20 01 mov 1, %i1
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4000f3cc: 82 23 40 03 sub %o5, %g3, %g1
available = size;
4000f3d0: b6 10 00 03 mov %g3, %i3
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4000f3d4: 83 33 c0 01 srl %o7, %g1, %g1
4000f3d8: 84 08 80 01 and %g2, %g1, %g2
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4000f3dc: 80 a0 a0 00 cmp %g2, 0
4000f3e0: 12 80 00 10 bne 4000f420 <rtems_rfs_bitmap_create_search+0xac>
4000f3e4: 86 10 20 00 clr %g3
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
4000f3e8: 80 a6 a0 1f cmp %i2, 0x1f
4000f3ec: 22 80 00 1c be,a 4000f45c <rtems_rfs_bitmap_create_search+0xe8>
4000f3f0: de 26 20 04 st %o7, [ %i0 + 4 ]
bit++;
4000f3f4: b4 06 a0 01 inc %i2
while (size)
4000f3f8: 80 a0 e0 00 cmp %g3, 0
4000f3fc: 02 80 00 1d be 4000f470 <rtems_rfs_bitmap_create_search+0xfc>
4000f400: b8 07 20 04 add %i4, 4, %i4
if (size < rtems_rfs_bitmap_element_bits ())
4000f404: 80 a0 e0 1f cmp %g3, 0x1f
4000f408: 08 bf ff f1 bleu 4000f3cc <rtems_rfs_bitmap_create_search+0x58>
4000f40c: c4 07 00 00 ld [ %i4 ], %g2
4000f410: 86 00 ff e0 add %g3, -32, %g3
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4000f414: 80 a0 a0 00 cmp %g2, 0
4000f418: 02 bf ff f4 be 4000f3e8 <rtems_rfs_bitmap_create_search+0x74>
4000f41c: b6 10 20 20 mov 0x20, %i3
for (b = 0; b < available; b++)
4000f420: 82 10 20 00 clr %g1
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4000f424: 89 2e 40 01 sll %i1, %g1, %g4
if (!rtems_rfs_bitmap_test (bits, b))
4000f428: 80 89 00 02 btst %g4, %g2
4000f42c: 02 80 00 05 be 4000f440 <rtems_rfs_bitmap_create_search+0xcc>
4000f430: 82 00 60 01 inc %g1
control->free++;
4000f434: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
4000f438: 88 01 20 01 inc %g4
4000f43c: c8 27 60 10 st %g4, [ %i5 + 0x10 ]
for (b = 0; b < available; b++)
4000f440: 80 a6 c0 01 cmp %i3, %g1
4000f444: 12 bf ff f9 bne 4000f428 <rtems_rfs_bitmap_create_search+0xb4>
4000f448: 89 2e 40 01 sll %i1, %g1, %g4
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
4000f44c: 80 a6 a0 1f cmp %i2, 0x1f
4000f450: 12 bf ff ea bne 4000f3f8 <rtems_rfs_bitmap_create_search+0x84>
4000f454: b4 06 a0 01 inc %i2
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4000f458: de 26 20 04 st %o7, [ %i0 + 4 ]
bit = 0;
4000f45c: b4 10 20 00 clr %i2
search_map++;
4000f460: b0 06 20 04 add %i0, 4, %i0
while (size)
4000f464: 80 a0 e0 00 cmp %g3, 0
4000f468: 12 bf ff e7 bne 4000f404 <rtems_rfs_bitmap_create_search+0x90>
4000f46c: b8 07 20 04 add %i4, 4, %i4
}
4000f470: 81 c7 e0 08 ret
4000f474: 91 e8 20 00 restore %g0, 0, %o0
4000f270 <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)
{
4000f270: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
4000f274: 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;
4000f278: 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))
4000f27c: 80 a6 60 00 cmp %i1, 0
4000f280: 06 80 00 1e bl 4000f2f8 <rtems_rfs_bitmap_map_alloc+0x88>
4000f284: 80 a7 60 00 cmp %i5, 0
4000f288: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000f28c: 80 a0 40 19 cmp %g1, %i1
4000f290: 08 80 00 1a bleu 4000f2f8 <rtems_rfs_bitmap_map_alloc+0x88>
4000f294: 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;
4000f298: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4000f29c: 96 10 20 01 mov 1, %o3
4000f2a0: 94 10 00 1a mov %i2, %o2
4000f2a4: 92 10 00 1b mov %i3, %o1
4000f2a8: 7f ff fe 9d call 4000ed1c <rtems_rfs_search_map_for_clear_bit.constprop.0>
4000f2ac: 90 10 00 18 mov %i0, %o0
window, 1);
if ((rc > 0) || *allocated)
4000f2b0: 80 a2 20 00 cmp %o0, 0
4000f2b4: 14 80 00 2c bg 4000f364 <rtems_rfs_bitmap_map_alloc+0xf4>
<== NEVER TAKEN
4000f2b8: 01 00 00 00 nop
4000f2bc: c2 0e 80 00 ldub [ %i2 ], %g1
4000f2c0: 80 a0 60 00 cmp %g1, 0
4000f2c4: 12 80 00 28 bne 4000f364 <rtems_rfs_bitmap_map_alloc+0xf4>
4000f2c8: 80 a7 60 00 cmp %i5, 0
break;
}
if (lower_seed >= 0)
4000f2cc: 36 80 00 14 bge,a 4000f31c <rtems_rfs_bitmap_map_alloc+0xac>
4000f2d0: 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)
4000f2d4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000f2d8: 80 a6 40 01 cmp %i1, %g1
4000f2dc: 1a bf ff e9 bcc 4000f280 <rtems_rfs_bitmap_map_alloc+0x10>
<== NEVER TAKEN
4000f2e0: 80 a6 60 00 cmp %i1, 0
upper_seed += window;
4000f2e4: b2 06 68 00 add %i1, 0x800, %i1
while (((upper_seed >= 0) && (upper_seed < control->size))
4000f2e8: 80 a6 60 00 cmp %i1, 0
4000f2ec: 16 bf ff e9 bge 4000f290 <rtems_rfs_bitmap_map_alloc+0x20>
<== ALWAYS TAKEN
4000f2f0: 80 a0 40 19 cmp %g1, %i1
|| ((lower_seed >= 0) && (lower_seed < control->size)))
4000f2f4: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000f2f8: 06 80 00 1b bl 4000f364 <rtems_rfs_bitmap_map_alloc+0xf4>
4000f2fc: 01 00 00 00 nop
4000f300: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000f304: 80 a0 40 1d cmp %g1, %i5
4000f308: 08 80 00 17 bleu 4000f364 <rtems_rfs_bitmap_map_alloc+0xf4>
4000f30c: 80 a6 40 01 cmp %i1, %g1
if (upper_seed < control->size)
4000f310: 2a bf ff e3 bcs,a 4000f29c <rtems_rfs_bitmap_map_alloc+0x2c>
<== NEVER TAKEN
4000f314: f2 26 c0 00 st %i1, [ %i3 ]
<== NOT EXECUTED
*bit = lower_seed;
4000f318: fa 26 c0 00 st %i5, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4000f31c: 96 10 3f ff mov -1, %o3
4000f320: 94 10 00 1a mov %i2, %o2
4000f324: 92 10 00 1b mov %i3, %o1
4000f328: 7f ff fe 7d call 4000ed1c <rtems_rfs_search_map_for_clear_bit.constprop.0>
4000f32c: 90 10 00 18 mov %i0, %o0
if ((rc > 0) || *allocated)
4000f330: 80 a2 20 00 cmp %o0, 0
4000f334: 14 80 00 0c bg 4000f364 <rtems_rfs_bitmap_map_alloc+0xf4>
<== NEVER TAKEN
4000f338: 01 00 00 00 nop
4000f33c: c2 0e 80 00 ldub [ %i2 ], %g1
4000f340: 80 a0 60 00 cmp %g1, 0
4000f344: 12 80 00 08 bne 4000f364 <rtems_rfs_bitmap_map_alloc+0xf4>
4000f348: 01 00 00 00 nop
if (upper_seed < control->size)
4000f34c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000f350: 80 a6 40 01 cmp %i1, %g1
4000f354: 2a 80 00 06 bcs,a 4000f36c <rtems_rfs_bitmap_map_alloc+0xfc>
4000f358: b2 06 68 00 add %i1, 0x800, %i1
if (lower_seed >= 0)
lower_seed -= window;
4000f35c: 10 bf ff c8 b 4000f27c <rtems_rfs_bitmap_map_alloc+0xc>
4000f360: ba 07 78 00 add %i5, -2048, %i5
}
return 0;
}
4000f364: 81 c7 e0 08 ret
4000f368: 91 e8 20 00 restore %g0, 0, %o0
lower_seed -= window;
4000f36c: 10 bf ff c4 b 4000f27c <rtems_rfs_bitmap_map_alloc+0xc>
4000f370: ba 07 78 00 add %i5, -2048, %i5
4000f014 <rtems_rfs_bitmap_map_clear>:
{
4000f014: 9d e3 bf 98 save %sp, -104, %sp
rc = rtems_rfs_bitmap_load_map (control, &map);
4000f018: 92 07 bf fc add %fp, -4, %o1
4000f01c: 7f ff ff 2c call 4000eccc <rtems_rfs_bitmap_load_map>
4000f020: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4000f024: 80 a2 20 00 cmp %o0, 0
4000f028: 24 80 00 04 ble,a 4000f038 <rtems_rfs_bitmap_map_clear+0x24>
4000f02c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
}
4000f030: 81 c7 e0 08 ret
4000f034: 91 e8 00 08 restore %g0, %o0, %o0
if (bit >= control->size)
4000f038: 80 a0 40 19 cmp %g1, %i1
4000f03c: 08 bf ff fd bleu 4000f030 <rtems_rfs_bitmap_map_clear+0x1c>
4000f040: 90 10 20 16 mov 0x16, %o0
element = map[index];
4000f044: f8 07 bf fc ld [ %fp + -4 ], %i4
index = rtems_rfs_bitmap_map_index (bit);
4000f048: 85 3e 60 05 sra %i1, 5, %g2
element = map[index];
4000f04c: bb 28 a0 02 sll %g2, 2, %i5
4000f050: c8 07 00 1d ld [ %i4 + %i5 ], %g4
search_map = control->search_bits;
4000f054: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
4000f058: 86 10 20 01 mov 1, %g3
4000f05c: 83 28 c0 19 sll %g3, %i1, %g1
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4000f060: 82 10 40 04 or %g1, %g4, %g1
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
4000f064: c2 27 00 1d st %g1, [ %i4 + %i5 ]
if (rtems_rfs_bitmap_match(element, map[index]))
4000f068: 80 a1 00 01 cmp %g4, %g1
4000f06c: 02 bf ff f1 be 4000f030 <rtems_rfs_bitmap_map_clear+0x1c>
<== NEVER TAKEN
4000f070: 90 10 20 00 clr %o0
index = rtems_rfs_bitmap_map_index (bit);
4000f074: b3 3e 60 0a sra %i1, 0xa, %i1
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4000f078: b3 2e 60 02 sll %i1, 2, %i1
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4000f07c: c2 06 c0 19 ld [ %i3 + %i1 ], %g1
rtems_rfs_buffer_mark_dirty (control->buffer);
4000f080: c8 06 00 00 ld [ %i0 ], %g4
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4000f084: 85 28 c0 02 sll %g3, %g2, %g2
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4000f088: 84 10 40 02 or %g1, %g2, %g2
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4000f08c: c4 26 c0 19 st %g2, [ %i3 + %i1 ]
control->free++;
4000f090: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_rfs_buffer_mark_dirty (control->buffer);
4000f094: c6 29 00 00 stb %g3, [ %g4 ]
control->free++;
4000f098: 82 00 60 01 inc %g1
4000f09c: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
}
4000f0a0: 81 c7 e0 08 ret
4000f0a4: 91 e8 00 08 restore %g0, %o0, %o0
4001927c <rtems_rfs_block_map_close>:
{
4001927c: 9d e3 bf a0 save %sp, -96, %sp
if (map->dirty && map->inode)
40019280: c2 0e 40 00 ldub [ %i1 ], %g1
40019284: 80 a0 60 00 cmp %g1, 0
40019288: 02 80 00 5f be 40019404 <rtems_rfs_block_map_close+0x188>
4001928c: ba 10 00 18 mov %i0, %i5
40019290: d2 06 60 04 ld [ %i1 + 4 ], %o1
40019294: 80 a2 60 00 cmp %o1, 0
40019298: 02 80 00 5b be 40019404 <rtems_rfs_block_map_close+0x188>
<== NEVER TAKEN
4001929c: 90 10 00 18 mov %i0, %o0
brc = rtems_rfs_inode_load (fs, map->inode);
400192a0: 7f ff e1 4a call 400117c8 <rtems_rfs_inode_load>
400192a4: b8 06 60 38 add %i1, 0x38, %i4
if (brc > 0)
400192a8: 80 a2 20 00 cmp %o0, 0
400192ac: 14 80 00 58 bg 4001940c <rtems_rfs_block_map_close+0x190>
<== NEVER TAKEN
400192b0: b0 10 00 08 mov %o0, %i0
400192b4: 9e 10 3f f8 mov -8, %o7
400192b8: 84 06 60 24 add %i1, 0x24, %g2
400192bc: 9e 23 c0 19 sub %o7, %i1, %o7
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400192c0: b0 10 20 01 mov 1, %i0
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
400192c4: c2 06 60 04 ld [ %i1 + 4 ], %g1
400192c8: c6 00 80 00 ld [ %g2 ], %g3
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
400192cc: f6 00 60 0c ld [ %g1 + 0xc ], %i3
400192d0: 88 03 c0 02 add %o7, %g2, %g4
400192d4: b5 30 e0 18 srl %g3, 0x18, %i2
400192d8: f4 2e c0 04 stb %i2, [ %i3 + %g4 ]
400192dc: b5 30 e0 10 srl %g3, 0x10, %i2
400192e0: f6 00 60 0c ld [ %g1 + 0xc ], %i3
400192e4: b6 06 c0 04 add %i3, %g4, %i3
400192e8: f4 2e e0 01 stb %i2, [ %i3 + 1 ]
400192ec: b5 30 e0 08 srl %g3, 8, %i2
400192f0: f6 00 60 0c ld [ %g1 + 0xc ], %i3
400192f4: b6 06 c0 04 add %i3, %g4, %i3
400192f8: f4 2e e0 02 stb %i2, [ %i3 + 2 ]
400192fc: 84 00 a0 04 add %g2, 4, %g2
40019300: f6 00 60 0c ld [ %g1 + 0xc ], %i3
40019304: 88 06 c0 04 add %i3, %g4, %g4
40019308: c6 29 20 03 stb %g3, [ %g4 + 3 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001930c: 80 a7 00 02 cmp %i4, %g2
40019310: 12 bf ff ed bne 400192c4 <rtems_rfs_block_map_close+0x48>
40019314: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
40019318: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001931c: c4 06 60 08 ld [ %i1 + 8 ], %g2
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
40019320: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40019324: 89 30 a0 18 srl %g2, 0x18, %g4
40019328: c8 28 e0 0c stb %g4, [ %g3 + 0xc ]
4001932c: 89 30 a0 10 srl %g2, 0x10, %g4
40019330: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40019334: c8 28 e0 0d stb %g4, [ %g3 + 0xd ]
40019338: 89 30 a0 08 srl %g2, 8, %g4
4001933c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40019340: c8 28 e0 0e stb %g4, [ %g3 + 0xe ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40019344: 94 10 20 01 mov 1, %o2
40019348: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4001934c: c4 28 e0 0f stb %g2, [ %g3 + 0xf ]
40019350: 90 10 00 1d mov %i5, %o0
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
40019354: c6 06 60 04 ld [ %i1 + 4 ], %g3
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
40019358: c8 0e 60 0e ldub [ %i1 + 0xe ], %g4
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001935c: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
40019360: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
40019364: c4 06 60 0c ld [ %i1 + 0xc ], %g2
40019368: c8 28 60 0a stb %g4, [ %g1 + 0xa ]
4001936c: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
40019370: c4 28 60 0b stb %g2, [ %g1 + 0xb ]
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
40019374: c4 06 60 04 ld [ %i1 + 4 ], %g2
40019378: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001937c: f0 28 e0 10 stb %i0, [ %g3 + 0x10 ]
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
40019380: 89 30 60 18 srl %g1, 0x18, %g4
40019384: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
40019388: c8 28 e0 30 stb %g4, [ %g3 + 0x30 ]
4001938c: 89 30 60 10 srl %g1, 0x10, %g4
40019390: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
40019394: c8 28 e0 31 stb %g4, [ %g3 + 0x31 ]
40019398: 89 30 60 08 srl %g1, 8, %g4
4001939c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
400193a0: c8 28 e0 32 stb %g4, [ %g3 + 0x32 ]
400193a4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
400193a8: c2 28 e0 33 stb %g1, [ %g3 + 0x33 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
400193ac: c2 06 60 04 ld [ %i1 + 4 ], %g1
400193b0: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400193b4: f0 28 a0 10 stb %i0, [ %g2 + 0x10 ]
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
400193b8: 89 30 e0 18 srl %g3, 0x18, %g4
400193bc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400193c0: c8 28 a0 34 stb %g4, [ %g2 + 0x34 ]
400193c4: 89 30 e0 10 srl %g3, 0x10, %g4
400193c8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400193cc: c8 28 a0 35 stb %g4, [ %g2 + 0x35 ]
400193d0: 89 30 e0 08 srl %g3, 8, %g4
400193d4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400193d8: c8 28 a0 36 stb %g4, [ %g2 + 0x36 ]
400193dc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400193e0: c6 28 a0 37 stb %g3, [ %g2 + 0x37 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400193e4: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
400193e8: 7f ff e1 5e call 40011960 <rtems_rfs_inode_unload>
400193ec: d2 06 60 04 ld [ %i1 + 4 ], %o1
map->dirty = false;
400193f0: c0 2e 40 00 clrb [ %i1 ]
400193f4: 82 38 00 08 xnor %g0, %o0, %g1
400193f8: 83 38 60 1f sra %g1, 0x1f, %g1
400193fc: 10 80 00 04 b 4001940c <rtems_rfs_block_map_close+0x190>
40019400: b0 0a 00 01 and %o0, %g1, %i0
int rc = 0;
40019404: b0 10 20 00 clr %i0
40019408: b8 06 60 38 add %i1, 0x38, %i4
map->inode = NULL;
4001940c: c0 26 60 04 clr [ %i1 + 4 ]
rtems_rfs_buffer_handle_release (fs, handle);
40019410: 92 10 00 1c mov %i4, %o1
40019414: 7f ff d9 f4 call 4000fbe4 <rtems_rfs_buffer_handle_release>
40019418: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
4001941c: c0 2e 60 38 clrb [ %i1 + 0x38 ]
rtems_rfs_buffer_handle_release (fs, handle);
40019420: 92 06 60 44 add %i1, 0x44, %o1
handle->bnum = 0;
40019424: c0 26 60 3c clr [ %i1 + 0x3c ]
rtems_rfs_buffer_handle_release (fs, handle);
40019428: 90 10 00 1d mov %i5, %o0
4001942c: 7f ff d9 ee call 4000fbe4 <rtems_rfs_buffer_handle_release>
40019430: c0 26 60 40 clr [ %i1 + 0x40 ]
handle->dirty = false;
40019434: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
40019438: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
4001943c: c0 26 60 4c clr [ %i1 + 0x4c ]
}
40019440: 81 c7 e0 08 ret
40019444: 81 e8 00 00 restore
40019448 <rtems_rfs_block_map_find>:
{
40019448: 9d e3 bf 98 save %sp, -104, %sp
*block = 0;
4001944c: c0 26 c0 00 clr [ %i3 ]
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
40019450: c2 06 80 00 ld [ %i2 ], %g1
40019454: 80 a0 60 00 cmp %g1, 0
40019458: 02 80 00 05 be 4001946c <rtems_rfs_block_map_find+0x24>
4001945c: c4 06 60 08 ld [ %i1 + 8 ], %g2
40019460: 80 a0 a0 00 cmp %g2, 0
40019464: 02 80 00 1a be 400194cc <rtems_rfs_block_map_find+0x84>
<== NEVER TAKEN
40019468: 90 10 20 06 mov 6, %o0
4001946c: 80 a0 40 02 cmp %g1, %g2
40019470: 1a 80 00 17 bcc 400194cc <rtems_rfs_block_map_find+0x84>
40019474: 90 10 20 06 mov 6, %o0
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
40019478: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
4001947c: 80 a0 40 03 cmp %g1, %g3
40019480: 22 80 00 39 be,a 40019564 <rtems_rfs_block_map_find+0x11c>
40019484: c6 06 60 18 ld [ %i1 + 0x18 ], %g3
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
40019488: 80 a0 a0 05 cmp %g2, 5
4001948c: 38 80 00 12 bgu,a 400194d4 <rtems_rfs_block_map_find+0x8c>
40019490: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
*block = map->blocks[bpos->bno];
40019494: 82 00 60 08 add %g1, 8, %g1
40019498: 83 28 60 02 sll %g1, 2, %g1
4001949c: 82 06 40 01 add %i1, %g1, %g1
400194a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
400194a4: c2 26 c0 00 st %g1, [ %i3 ]
map->bpos.block = *block;
400194a8: 90 10 20 00 clr %o0
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
400194ac: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400194b0: c4 06 80 00 ld [ %i2 ], %g2
400194b4: c6 06 a0 08 ld [ %i2 + 8 ], %g3
400194b8: c6 26 60 18 st %g3, [ %i1 + 0x18 ]
400194bc: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
400194c0: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
map->bpos.block = *block;
400194c4: c2 06 c0 00 ld [ %i3 ], %g1
400194c8: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
400194cc: 81 c7 e0 08 ret
400194d0: 91 e8 00 08 restore %g0, %o0, %o0
direct = bpos->bno % fs->blocks_per_block;
400194d4: 81 80 20 00 wr %g0, %y
400194d8: 01 00 00 00 nop
400194dc: 01 00 00 00 nop
400194e0: 01 00 00 00 nop
400194e4: 96 70 40 03 udiv %g1, %g3, %o3
singly = bpos->bno / fs->blocks_per_block;
400194e8: d6 27 bf fc st %o3, [ %fp + -4 ]
direct = bpos->bno % fs->blocks_per_block;
400194ec: ba 5a c0 03 smul %o3, %g3, %i5
if (map->size.count <= fs->block_map_singly_blocks)
400194f0: c8 06 20 38 ld [ %i0 + 0x38 ], %g4
400194f4: 80 a1 00 02 cmp %g4, %g2
400194f8: 1a 80 00 20 bcc 40019578 <rtems_rfs_block_map_find+0x130>
400194fc: ba 20 40 1d sub %g1, %i5, %i5
singly %= fs->blocks_per_block;
40019500: 81 80 20 00 wr %g0, %y
40019504: 01 00 00 00 nop
40019508: 01 00 00 00 nop
4001950c: 01 00 00 00 nop
40019510: 82 72 c0 03 udiv %o3, %g3, %g1
40019514: 86 58 40 03 smul %g1, %g3, %g3
40019518: 96 22 c0 03 sub %o3, %g3, %o3
4001951c: d6 27 bf fc st %o3, [ %fp + -4 ]
if (map->size.count < fs->block_map_doubly_blocks)
40019520: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
40019524: 80 a0 c0 02 cmp %g3, %g2
40019528: 08 bf ff e9 bleu 400194cc <rtems_rfs_block_map_find+0x84>
<== NEVER TAKEN
4001952c: 90 10 20 06 mov 6, %o0
rc = rtems_rfs_block_find_indirect (fs,
40019530: 82 00 60 08 add %g1, 8, %g1
40019534: 83 28 60 02 sll %g1, 2, %g1
40019538: 82 06 40 01 add %i1, %g1, %g1
4001953c: d4 00 60 04 ld [ %g1 + 4 ], %o2
40019540: 98 07 bf fc add %fp, -4, %o4
40019544: 92 06 60 44 add %i1, 0x44, %o1
40019548: 7f ff fe 5e call 40018ec0 <rtems_rfs_block_find_indirect>
4001954c: 90 10 00 18 mov %i0, %o0
if (rc == 0)
40019550: 80 a2 20 00 cmp %o0, 0
40019554: 12 bf ff de bne 400194cc <rtems_rfs_block_map_find+0x84>
<== NEVER TAKEN
40019558: d4 07 bf fc ld [ %fp + -4 ], %o2
rc = rtems_rfs_block_find_indirect (fs,
4001955c: 10 80 00 0c b 4001958c <rtems_rfs_block_map_find+0x144>
40019560: 98 10 00 1b mov %i3, %o4
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
40019564: 80 a0 e0 00 cmp %g3, 0
40019568: 02 bf ff c9 be 4001948c <rtems_rfs_block_map_find+0x44>
4001956c: 80 a0 a0 05 cmp %g2, 5
*block = map->bpos.block;
40019570: 10 bf ff ce b 400194a8 <rtems_rfs_block_map_find+0x60>
40019574: c6 26 c0 00 st %g3, [ %i3 ]
rc = rtems_rfs_block_find_indirect (fs,
40019578: 96 02 e0 08 add %o3, 8, %o3
4001957c: 97 2a e0 02 sll %o3, 2, %o3
40019580: 96 06 40 0b add %i1, %o3, %o3
40019584: d4 02 e0 04 ld [ %o3 + 4 ], %o2
rc = rtems_rfs_block_find_indirect (fs,
40019588: 98 10 00 1b mov %i3, %o4
4001958c: 96 10 00 1d mov %i5, %o3
40019590: 92 06 60 38 add %i1, 0x38, %o1
40019594: 7f ff fe 4b call 40018ec0 <rtems_rfs_block_find_indirect>
40019598: 90 10 00 18 mov %i0, %o0
if (rc == 0)
4001959c: 80 a2 20 00 cmp %o0, 0
400195a0: 22 bf ff c3 be,a 400194ac <rtems_rfs_block_map_find+0x64>
<== ALWAYS TAKEN
400195a4: 90 10 20 00 clr %o0
400195a8: 30 bf ff c9 b,a 400194cc <rtems_rfs_block_map_find+0x84>
<== NOT EXECUTED
40019658 <rtems_rfs_block_map_grow>:
{
40019658: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001965c: 90 10 20 00 clr %o0
40019660: 7f ff e6 bc call 40013150 <rtems_rfs_trace>
40019664: 13 00 00 08 sethi %hi(0x2000), %o1
40019668: 80 a2 20 00 cmp %o0, 0
4001966c: 32 80 00 eb bne,a 40019a18 <rtems_rfs_block_map_grow+0x3c0>
<== NEVER TAKEN
40019670: d4 06 60 08 ld [ %i1 + 8 ], %o2
<== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
40019674: c2 06 60 08 ld [ %i1 + 8 ], %g1
40019678: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
4001967c: 82 06 80 01 add %i2, %g1, %g1
40019680: 80 a0 40 02 cmp %g1, %g2
40019684: 1a 80 00 68 bcc 40019824 <rtems_rfs_block_map_grow+0x1cc>
<== NEVER TAKEN
40019688: b8 10 20 1b mov 0x1b, %i4
for (b = 0; b < blocks; b++)
4001968c: 80 a6 a0 00 cmp %i2, 0
40019690: 02 80 00 65 be 40019824 <rtems_rfs_block_map_grow+0x1cc>
<== NEVER TAKEN
40019694: b8 10 20 00 clr %i4
40019698: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
4001969c: a8 10 20 00 clr %l4
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
400196a0: a0 10 20 01 mov 1, %l0
rc = rtems_rfs_buffer_handle_request (fs,
400196a4: a4 06 60 44 add %i1, 0x44, %l2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
400196a8: 10 80 00 10 b 400196e8 <rtems_rfs_block_map_grow+0x90>
400196ac: a2 06 60 38 add %i1, 0x38, %l1
map->blocks[map->size.count] = block;
400196b0: 84 00 60 08 add %g1, 8, %g2
400196b4: 85 28 a0 02 sll %g2, 2, %g2
400196b8: 84 06 40 02 add %i1, %g2, %g2
400196bc: d2 20 a0 04 st %o1, [ %g2 + 4 ]
map->size.count++;
400196c0: 82 00 60 01 inc %g1
map->size.offset = 0;
400196c4: c0 26 60 0c clr [ %i1 + 0xc ]
if (b == 0)
400196c8: 80 a5 20 00 cmp %l4, 0
400196cc: 02 80 00 4f be 40019808 <rtems_rfs_block_map_grow+0x1b0>
<== ALWAYS TAKEN
400196d0: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->last_data_block = block;
400196d4: d2 26 60 20 st %o1, [ %i1 + 0x20 ]
<== NOT EXECUTED
for (b = 0; b < blocks; b++)
400196d8: a8 05 20 01 inc %l4
<== NOT EXECUTED
400196dc: 80 a5 00 1a cmp %l4, %i2
<== NOT EXECUTED
400196e0: 02 80 00 50 be 40019820 <rtems_rfs_block_map_grow+0x1c8>
<== NOT EXECUTED
400196e4: e0 2e 40 00 stb %l0, [ %i1 ]
<== NOT EXECUTED
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
400196e8: 96 07 bf f8 add %fp, -8, %o3
400196ec: 94 10 20 00 clr %o2
400196f0: 7f ff df 11 call 40011334 <rtems_rfs_group_bitmap_alloc>
400196f4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400196f8: b8 92 20 00 orcc %o0, 0, %i4
400196fc: 14 80 00 4a bg 40019824 <rtems_rfs_block_map_grow+0x1cc>
40019700: 01 00 00 00 nop
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
40019704: c2 06 60 08 ld [ %i1 + 8 ], %g1
40019708: 80 a0 60 04 cmp %g1, 4
4001970c: 08 bf ff e9 bleu 400196b0 <rtems_rfs_block_map_grow+0x58>
40019710: d2 07 bf f8 ld [ %fp + -8 ], %o1
direct = map->size.count % fs->blocks_per_block;
40019714: e6 06 20 34 ld [ %i0 + 0x34 ], %l3
if (map->size.count < fs->block_map_singly_blocks)
40019718: c4 06 20 38 ld [ %i0 + 0x38 ], %g2
direct = map->size.count % fs->blocks_per_block;
4001971c: 81 80 20 00 wr %g0, %y
40019720: 01 00 00 00 nop
40019724: 01 00 00 00 nop
40019728: 01 00 00 00 nop
4001972c: 96 70 40 13 udiv %g1, %l3, %o3
if (map->size.count < fs->block_map_singly_blocks)
40019730: 80 a0 40 02 cmp %g1, %g2
direct = map->size.count % fs->blocks_per_block;
40019734: ba 5a c0 13 smul %o3, %l3, %i5
if (map->size.count < fs->block_map_singly_blocks)
40019738: 1a 80 00 3d bcc 4001982c <rtems_rfs_block_map_grow+0x1d4>
4001973c: ba 20 40 1d sub %g1, %i5, %i5
if ((direct == 0) ||
40019740: 80 a7 60 00 cmp %i5, 0
40019744: 02 80 00 06 be 4001975c <rtems_rfs_block_map_grow+0x104>
40019748: 80 a2 e0 00 cmp %o3, 0
4001974c: 12 80 00 95 bne 400199a0 <rtems_rfs_block_map_grow+0x348>
40019750: 80 a7 60 05 cmp %i5, 5
40019754: 32 80 00 94 bne,a 400199a4 <rtems_rfs_block_map_grow+0x34c>
40019758: 82 02 e0 08 add %o3, 8, %g1
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
4001975c: 82 18 60 05 xor %g1, 5, %g1
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40019760: 80 a0 00 01 cmp %g0, %g1
&map->blocks[singly],
40019764: 96 02 e0 09 add %o3, 9, %o3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40019768: 98 60 3f ff subx %g0, -1, %o4
&map->blocks[singly],
4001976c: 97 2a e0 02 sll %o3, 2, %o3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40019770: 94 10 00 11 mov %l1, %o2
40019774: 96 06 40 0b add %i1, %o3, %o3
40019778: 92 10 00 19 mov %i1, %o1
4001977c: 7f ff fd 7e call 40018d74 <rtems_rfs_block_map_indirect_alloc>
40019780: 90 10 00 18 mov %i0, %o0
40019784: b8 10 00 08 mov %o0, %i4
if (rc > 0)
40019788: 80 a7 20 00 cmp %i4, 0
4001978c: 14 80 00 aa bg 40019a34 <rtems_rfs_block_map_grow+0x3dc>
<== NEVER TAKEN
40019790: d4 07 bf f8 ld [ %fp + -8 ], %o2
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
40019794: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
40019798: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
4001979c: c6 0f bf f8 ldub [ %fp + -8 ], %g3
400197a0: 83 2f 60 02 sll %i5, 2, %g1
400197a4: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
if (b == 0)
400197a8: 80 a5 20 00 cmp %l4, 0
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
400197ac: c4 06 60 40 ld [ %i1 + 0x40 ], %g2
400197b0: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400197b4: c6 17 bf f8 lduh [ %fp + -8 ], %g3
400197b8: 84 00 80 01 add %g2, %g1, %g2
400197bc: c6 28 a0 01 stb %g3, [ %g2 + 1 ]
400197c0: c4 06 60 40 ld [ %i1 + 0x40 ], %g2
400197c4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400197c8: c6 07 bf f8 ld [ %fp + -8 ], %g3
400197cc: 84 00 80 01 add %g2, %g1, %g2
400197d0: 87 30 e0 08 srl %g3, 8, %g3
400197d4: c6 28 a0 02 stb %g3, [ %g2 + 2 ]
400197d8: c4 06 60 40 ld [ %i1 + 0x40 ], %g2
400197dc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400197e0: 82 00 80 01 add %g2, %g1, %g1
400197e4: c4 07 bf f8 ld [ %fp + -8 ], %g2
400197e8: c4 28 60 03 stb %g2, [ %g1 + 3 ]
400197ec: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.count++;
400197f0: 82 00 60 01 inc %g1
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
400197f4: e0 2e 60 38 stb %l0, [ %i1 + 0x38 ]
map->size.offset = 0;
400197f8: c0 26 60 0c clr [ %i1 + 0xc ]
map->size.count++;
400197fc: c2 26 60 08 st %g1, [ %i1 + 8 ]
if (b == 0)
40019800: 12 bf ff b5 bne 400196d4 <rtems_rfs_block_map_grow+0x7c>
<== NEVER TAKEN
40019804: d2 07 bf f8 ld [ %fp + -8 ], %o1
*new_block = block;
40019808: d2 26 c0 00 st %o1, [ %i3 ]
for (b = 0; b < blocks; b++)
4001980c: a8 05 20 01 inc %l4
map->last_data_block = block;
40019810: d2 26 60 20 st %o1, [ %i1 + 0x20 ]
for (b = 0; b < blocks; b++)
40019814: 80 a5 00 1a cmp %l4, %i2
40019818: 12 bf ff b4 bne 400196e8 <rtems_rfs_block_map_grow+0x90>
<== NEVER TAKEN
4001981c: e0 2e 40 00 stb %l0, [ %i1 ]
return 0;
40019820: b8 10 20 00 clr %i4
}
40019824: 81 c7 e0 08 ret
40019828: 91 e8 00 1c restore %g0, %i4, %o0
doubly = singly / fs->blocks_per_block;
4001982c: 81 80 20 00 wr %g0, %y
40019830: 01 00 00 00 nop
40019834: 01 00 00 00 nop
40019838: 01 00 00 00 nop
4001983c: aa 72 c0 13 udiv %o3, %l3, %l5
if (direct == 0)
40019840: 80 a7 60 00 cmp %i5, 0
singly %= fs->blocks_per_block;
40019844: a6 5d 40 13 smul %l5, %l3, %l3
if (direct == 0)
40019848: 12 80 00 37 bne 40019924 <rtems_rfs_block_map_grow+0x2cc>
4001984c: a6 22 c0 13 sub %o3, %l3, %l3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40019850: 98 10 20 00 clr %o4
40019854: 96 07 bf fc add %fp, -4, %o3
40019858: 94 10 00 11 mov %l1, %o2
4001985c: 92 10 00 19 mov %i1, %o1
40019860: 7f ff fd 45 call 40018d74 <rtems_rfs_block_map_indirect_alloc>
40019864: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40019868: b8 92 20 00 orcc %o0, 0, %i4
4001986c: 14 80 00 71 bg 40019a30 <rtems_rfs_block_map_grow+0x3d8>
<== NEVER TAKEN
40019870: 80 a4 e0 00 cmp %l3, 0
if ((singly == 0) ||
40019874: 02 80 00 06 be 4001988c <rtems_rfs_block_map_grow+0x234>
<== NEVER TAKEN
40019878: 80 a5 60 00 cmp %l5, 0
4001987c: 12 80 00 53 bne 400199c8 <rtems_rfs_block_map_grow+0x370>
<== NEVER TAKEN
40019880: 80 a4 e0 05 cmp %l3, 5
40019884: 12 80 00 52 bne 400199cc <rtems_rfs_block_map_grow+0x374>
40019888: 82 05 60 08 add %l5, 8, %g1
upping = map->size.count == fs->block_map_singly_blocks;
4001988c: c2 06 60 08 ld [ %i1 + 8 ], %g1
40019890: c4 06 20 38 ld [ %i0 + 0x38 ], %g2
40019894: 82 18 40 02 xor %g1, %g2, %g1
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40019898: 80 a0 00 01 cmp %g0, %g1
&map->blocks[doubly],
4001989c: 96 05 60 09 add %l5, 9, %o3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
400198a0: 98 60 3f ff subx %g0, -1, %o4
&map->blocks[doubly],
400198a4: 97 2a e0 02 sll %o3, 2, %o3
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
400198a8: 94 10 00 12 mov %l2, %o2
400198ac: 96 06 40 0b add %i1, %o3, %o3
400198b0: 92 10 00 19 mov %i1, %o1
400198b4: 7f ff fd 30 call 40018d74 <rtems_rfs_block_map_indirect_alloc>
400198b8: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400198bc: b8 92 20 00 orcc %o0, 0, %i4
400198c0: 14 80 00 4e bg 400199f8 <rtems_rfs_block_map_grow+0x3a0>
<== NEVER TAKEN
400198c4: d4 07 bf fc ld [ %fp + -4 ], %o2
rtems_rfs_block_set_number (&map->doubly_buffer,
400198c8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
400198cc: c4 0f bf fc ldub [ %fp + -4 ], %g2
400198d0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400198d4: 97 2c e0 02 sll %l3, 2, %o3
400198d8: c4 28 40 0b stb %g2, [ %g1 + %o3 ]
400198dc: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
400198e0: c4 17 bf fc lduh [ %fp + -4 ], %g2
400198e4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400198e8: 82 00 40 0b add %g1, %o3, %g1
400198ec: c4 28 60 01 stb %g2, [ %g1 + 1 ]
400198f0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
400198f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400198f8: c4 07 bf fc ld [ %fp + -4 ], %g2
400198fc: 82 00 40 0b add %g1, %o3, %g1
40019900: 85 30 a0 08 srl %g2, 8, %g2
40019904: c4 28 60 02 stb %g2, [ %g1 + 2 ]
40019908: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
4001990c: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
40019910: c2 07 bf fc ld [ %fp + -4 ], %g1
40019914: 96 04 c0 0b add %l3, %o3, %o3
40019918: c2 2a e0 03 stb %g1, [ %o3 + 3 ]
4001991c: 10 bf ff 9e b 40019794 <rtems_rfs_block_map_grow+0x13c>
40019920: e0 2e 60 44 stb %l0, [ %i1 + 0x44 ]
rc = rtems_rfs_buffer_handle_request (fs,
40019924: aa 05 60 08 add %l5, 8, %l5
40019928: ab 2d 60 02 sll %l5, 2, %l5
4001992c: aa 06 40 15 add %i1, %l5, %l5
40019930: d4 05 60 04 ld [ %l5 + 4 ], %o2
40019934: 96 10 20 01 mov 1, %o3
40019938: 92 10 00 12 mov %l2, %o1
4001993c: 7f ff d7 e3 call 4000f8c8 <rtems_rfs_buffer_handle_request>
40019940: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40019944: b8 92 20 00 orcc %o0, 0, %i4
40019948: 14 80 00 3a bg 40019a30 <rtems_rfs_block_map_grow+0x3d8>
<== NEVER TAKEN
4001994c: 97 2c e0 02 sll %l3, 2, %o3
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
40019950: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
40019954: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
40019958: d4 08 80 0b ldub [ %g2 + %o3 ], %o2
4001995c: 82 00 80 0b add %g2, %o3, %g1
40019960: c6 08 60 03 ldub [ %g1 + 3 ], %g3
40019964: c4 08 60 01 ldub [ %g1 + 1 ], %g2
40019968: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001996c: 85 28 a0 10 sll %g2, 0x10, %g2
40019970: 83 28 60 08 sll %g1, 8, %g1
40019974: 95 2a a0 18 sll %o2, 0x18, %o2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019978: 96 10 20 01 mov 1, %o3
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001997c: 94 12 80 03 or %o2, %g3, %o2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019980: 92 10 00 11 mov %l1, %o1
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
40019984: 94 12 80 02 or %o2, %g2, %o2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019988: 90 10 00 18 mov %i0, %o0
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001998c: 94 12 80 01 or %o2, %g1, %o2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019990: 7f ff d7 ce call 4000f8c8 <rtems_rfs_buffer_handle_request>
40019994: d4 27 bf fc st %o2, [ %fp + -4 ]
40019998: 10 bf ff 7c b 40019788 <rtems_rfs_block_map_grow+0x130>
4001999c: b8 10 00 08 mov %o0, %i4
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
400199a0: 82 02 e0 08 add %o3, 8, %g1
400199a4: 83 28 60 02 sll %g1, 2, %g1
400199a8: 82 06 40 01 add %i1, %g1, %g1
400199ac: d4 00 60 04 ld [ %g1 + 4 ], %o2
400199b0: 96 10 20 01 mov 1, %o3
400199b4: 92 10 00 11 mov %l1, %o1
400199b8: 7f ff d7 c4 call 4000f8c8 <rtems_rfs_buffer_handle_request>
400199bc: 90 10 00 18 mov %i0, %o0
400199c0: 10 bf ff 72 b 40019788 <rtems_rfs_block_map_grow+0x130>
400199c4: b8 10 00 08 mov %o0, %i4
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
400199c8: 82 05 60 08 add %l5, 8, %g1
<== NOT EXECUTED
400199cc: 83 28 60 02 sll %g1, 2, %g1
400199d0: 82 06 40 01 add %i1, %g1, %g1
400199d4: d4 00 60 04 ld [ %g1 + 4 ], %o2
400199d8: 96 10 20 01 mov 1, %o3
400199dc: 92 10 00 12 mov %l2, %o1
400199e0: 7f ff d7 ba call 4000f8c8 <rtems_rfs_buffer_handle_request>
400199e4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400199e8: b8 92 20 00 orcc %o0, 0, %i4
400199ec: 24 bf ff b8 ble,a 400198cc <rtems_rfs_block_map_grow+0x274>
<== ALWAYS TAKEN
400199f0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
rtems_rfs_group_bitmap_free (fs, false, singly_block);
400199f4: d4 07 bf fc ld [ %fp + -4 ], %o2
<== NOT EXECUTED
400199f8: 92 10 20 00 clr %o1
<== NOT EXECUTED
400199fc: 7f ff de fc call 400115ec <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40019a00: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
40019a04: d4 07 bf f8 ld [ %fp + -8 ], %o2
<== NOT EXECUTED
40019a08: 92 10 20 00 clr %o1
<== NOT EXECUTED
40019a0c: 7f ff de f8 call 400115ec <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40019a10: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rc;
40019a14: 30 bf ff 84 b,a 40019824 <rtems_rfs_block_map_grow+0x1cc>
<== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
40019a18: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40019a1c: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
40019a20: 7f ff e6 5a call 40013388 <__wrap_printf>
<== NOT EXECUTED
40019a24: 90 12 22 50 or %o0, 0x250, %o0 ! 40023650 <status_code_to_errno+0x134>
<== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
40019a28: 10 bf ff 14 b 40019678 <rtems_rfs_block_map_grow+0x20>
<== NOT EXECUTED
40019a2c: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
40019a30: d4 07 bf f8 ld [ %fp + -8 ], %o2
<== NOT EXECUTED
40019a34: 92 10 20 00 clr %o1
<== NOT EXECUTED
40019a38: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40019a3c: 7f ff de ec call 400115ec <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40019a40: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
}
40019a44: 81 c7 e0 08 ret
<== NOT EXECUTED
40019a48: 81 e8 00 00 restore
<== NOT EXECUTED
40019100 <rtems_rfs_block_map_open>:
{
40019100: 9d e3 bf a0 save %sp, -96, %sp
map->dirty = false;
40019104: c0 2e 80 00 clrb [ %i2 ]
rc = rtems_rfs_inode_load (fs, inode);
40019108: 92 10 00 19 mov %i1, %o1
map->inode = NULL;
4001910c: c0 26 a0 04 clr [ %i2 + 4 ]
rc = rtems_rfs_inode_load (fs, inode);
40019110: 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;
40019114: c0 26 a0 08 clr [ %i2 + 8 ]
{
40019118: ba 10 00 1a mov %i2, %i5
size->offset = 0;
4001911c: c0 26 a0 0c clr [ %i2 + 0xc ]
bpos->bno = 0;
40019120: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
40019124: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
40019128: c0 26 a0 18 clr [ %i2 + 0x18 ]
handle->dirty = false;
4001912c: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
40019130: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
40019134: c0 26 a0 40 clr [ %i2 + 0x40 ]
handle->dirty = false;
40019138: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
4001913c: c0 26 a0 48 clr [ %i2 + 0x48 ]
rc = rtems_rfs_inode_load (fs, inode);
40019140: 7f ff e1 a2 call 400117c8 <rtems_rfs_inode_load>
40019144: c0 26 a0 4c clr [ %i2 + 0x4c ]
if (rc > 0)
40019148: b8 92 20 00 orcc %o0, 0, %i4
4001914c: 14 80 00 3d bg 40019240 <rtems_rfs_block_map_open+0x140>
<== NEVER TAKEN
40019150: 88 06 a0 24 add %i2, 0x24, %g4
40019154: de 06 60 0c ld [ %i1 + 0xc ], %o7
map->inode = inode;
40019158: f2 26 a0 04 st %i1, [ %i2 + 4 ]
4001915c: 82 03 e0 1c add %o7, 0x1c, %g1
40019160: b4 06 a0 38 add %i2, 0x38, %i2
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
40019164: f6 08 40 00 ldub [ %g1 ], %i3
40019168: c6 08 60 01 ldub [ %g1 + 1 ], %g3
4001916c: c4 08 60 02 ldub [ %g1 + 2 ], %g2
40019170: f8 08 60 03 ldub [ %g1 + 3 ], %i4
40019174: b7 2e e0 18 sll %i3, 0x18, %i3
40019178: 87 28 e0 10 sll %g3, 0x10, %g3
4001917c: 85 28 a0 08 sll %g2, 8, %g2
40019180: 86 10 c0 1b or %g3, %i3, %g3
40019184: 84 10 80 03 or %g2, %g3, %g2
40019188: 84 17 00 02 or %i4, %g2, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
4001918c: c4 21 00 00 st %g2, [ %g4 ]
40019190: 88 01 20 04 add %g4, 4, %g4
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
40019194: 80 a6 80 04 cmp %i2, %g4
40019198: 12 bf ff f3 bne 40019164 <rtems_rfs_block_map_open+0x64>
4001919c: 82 00 60 04 add %g1, 4, %g1
return rtems_rfs_read_u32 (&handle->node->block_count);
400191a0: c6 0b e0 0f ldub [ %o7 + 0xf ], %g3
400191a4: c8 0b e0 0c ldub [ %o7 + 0xc ], %g4
400191a8: c4 0b e0 0d ldub [ %o7 + 0xd ], %g2
400191ac: c2 0b e0 0e ldub [ %o7 + 0xe ], %g1
400191b0: 89 29 20 18 sll %g4, 0x18, %g4
400191b4: 85 28 a0 10 sll %g2, 0x10, %g2
400191b8: 83 28 60 08 sll %g1, 8, %g1
400191bc: 84 10 80 04 or %g2, %g4, %g2
400191c0: 82 10 40 02 or %g1, %g2, %g1
400191c4: 82 10 c0 01 or %g3, %g1, %g1
map->size.count = rtems_rfs_inode_get_block_count (inode);
400191c8: c2 27 60 08 st %g1, [ %i5 + 8 ]
return rtems_rfs_read_u16 (&handle->node->block_offset);
400191cc: c4 0b e0 0b ldub [ %o7 + 0xb ], %g2
400191d0: c2 0b e0 0a ldub [ %o7 + 0xa ], %g1
400191d4: 83 28 60 08 sll %g1, 8, %g1
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
400191d8: 82 10 40 02 or %g1, %g2, %g1
400191dc: c2 27 60 0c st %g1, [ %i5 + 0xc ]
return rtems_rfs_read_u32 (&handle->node->last_map_block);
400191e0: c6 0b e0 33 ldub [ %o7 + 0x33 ], %g3
400191e4: c8 0b e0 30 ldub [ %o7 + 0x30 ], %g4
400191e8: c4 0b e0 31 ldub [ %o7 + 0x31 ], %g2
400191ec: c2 0b e0 32 ldub [ %o7 + 0x32 ], %g1
400191f0: 89 29 20 18 sll %g4, 0x18, %g4
400191f4: 85 28 a0 10 sll %g2, 0x10, %g2
400191f8: 83 28 60 08 sll %g1, 8, %g1
400191fc: 84 10 80 04 or %g2, %g4, %g2
40019200: 82 10 40 02 or %g1, %g2, %g1
40019204: 82 10 c0 01 or %g3, %g1, %g1
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
40019208: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
return rtems_rfs_read_u32 (&handle->node->last_data_block);
4001920c: c8 0b e0 34 ldub [ %o7 + 0x34 ], %g4
40019210: c4 0b e0 35 ldub [ %o7 + 0x35 ], %g2
40019214: c2 0b e0 36 ldub [ %o7 + 0x36 ], %g1
40019218: c6 0b e0 37 ldub [ %o7 + 0x37 ], %g3
4001921c: 89 29 20 18 sll %g4, 0x18, %g4
40019220: 85 28 a0 10 sll %g2, 0x10, %g2
40019224: 83 28 60 08 sll %g1, 8, %g1
40019228: 84 10 80 04 or %g2, %g4, %g2
4001922c: 82 10 40 02 or %g1, %g2, %g1
40019230: 82 10 c0 01 or %g3, %g1, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
40019234: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
40019238: 7f ff e1 ca call 40011960 <rtems_rfs_inode_unload>
4001923c: 95 e8 20 00 restore %g0, 0, %o2
rtems_rfs_buffer_handle_release (fs, handle);
40019240: 92 06 a0 38 add %i2, 0x38, %o1
<== NOT EXECUTED
40019244: 7f ff da 68 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40019248: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->dirty = false;
4001924c: c0 2e a0 38 clrb [ %i2 + 0x38 ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40019250: 92 06 a0 44 add %i2, 0x44, %o1
<== NOT EXECUTED
handle->bnum = 0;
40019254: c0 26 a0 3c clr [ %i2 + 0x3c ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40019258: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->buffer = NULL;
4001925c: c0 26 a0 40 clr [ %i2 + 0x40 ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40019260: 7f ff da 61 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40019264: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
handle->dirty = false;
40019268: c0 2e a0 44 clrb [ %i2 + 0x44 ]
<== NOT EXECUTED
handle->bnum = 0;
4001926c: c0 26 a0 48 clr [ %i2 + 0x48 ]
<== NOT EXECUTED
handle->buffer = NULL;
40019270: c0 26 a0 4c clr [ %i2 + 0x4c ]
<== NOT EXECUTED
}
40019274: 81 c7 e0 08 ret
<== NOT EXECUTED
40019278: 81 e8 00 00 restore
<== NOT EXECUTED
40019a4c <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
40019a4c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
40019a50: 90 10 20 00 clr %o0
40019a54: 7f ff e5 bf call 40013150 <rtems_rfs_trace>
40019a58: 13 00 00 10 sethi %hi(0x4000), %o1
40019a5c: 80 a2 20 00 cmp %o0, 0
40019a60: 32 80 00 a3 bne,a 40019cec <rtems_rfs_block_map_shrink+0x2a0>
<== NEVER TAKEN
40019a64: 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)
40019a68: c2 06 60 08 ld [ %i1 + 8 ], %g1
40019a6c: 80 a0 60 00 cmp %g1, 0
40019a70: 02 80 00 9a be 40019cd8 <rtems_rfs_block_map_shrink+0x28c>
40019a74: 80 a0 40 1a cmp %g1, %i2
40019a78: 18 80 00 9b bgu 40019ce4 <rtems_rfs_block_map_shrink+0x298>
40019a7c: b6 10 00 01 mov %g1, %i3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
40019a80: 80 a6 e0 00 cmp %i3, 0
40019a84: 02 80 00 8e be 40019cbc <rtems_rfs_block_map_shrink+0x270>
<== NEVER TAKEN
40019a88: 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,
40019a8c: 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,
40019a90: a6 06 60 4c add %i1, 0x4c, %l3
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
40019a94: 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;
40019a98: 10 80 00 13 b 40019ae4 <rtems_rfs_block_map_shrink+0x98>
40019a9c: b4 10 20 01 mov 1, %i2
40019aa0: 82 06 40 01 add %i1, %g1, %g1
block_to_free = map->blocks[block];
40019aa4: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
map->blocks[block] = 0;
40019aa8: c0 20 60 20 clr [ %g1 + 0x20 ]
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
40019aac: 94 10 00 1d mov %i5, %o2
40019ab0: 92 10 20 00 clr %o1
40019ab4: 7f ff de ce call 400115ec <rtems_rfs_group_bitmap_free>
40019ab8: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40019abc: 80 a2 20 00 cmp %o0, 0
40019ac0: 14 80 00 61 bg 40019c44 <rtems_rfs_block_map_shrink+0x1f8>
<== NEVER TAKEN
40019ac4: b6 86 ff ff addcc %i3, -1, %i3
map->size.count--;
40019ac8: c2 06 60 08 ld [ %i1 + 8 ], %g1
40019acc: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
40019ad0: c0 26 60 0c clr [ %i1 + 0xc ]
map->size.count--;
40019ad4: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->last_data_block = block_to_free;
40019ad8: fa 26 60 20 st %i5, [ %i1 + 0x20 ]
while (blocks)
40019adc: 02 80 00 8a be 40019d04 <rtems_rfs_block_map_shrink+0x2b8>
40019ae0: f4 2e 40 00 stb %i2, [ %i1 ]
block = map->size.count - 1;
40019ae4: 84 00 7f ff add %g1, -1, %g2
if (block < RTEMS_RFS_INODE_BLOCKS)
40019ae8: 80 a0 a0 04 cmp %g2, 4
40019aec: 28 bf ff ed bleu,a 40019aa0 <rtems_rfs_block_map_shrink+0x54>
<== ALWAYS TAKEN
40019af0: 83 28 60 02 sll %g1, 2, %g1
direct = block % fs->blocks_per_block;
40019af4: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
<== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
40019af8: c8 06 20 38 ld [ %i0 + 0x38 ], %g4
<== NOT EXECUTED
direct = block % fs->blocks_per_block;
40019afc: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40019b00: 01 00 00 00 nop
<== NOT EXECUTED
40019b04: 01 00 00 00 nop
<== NOT EXECUTED
40019b08: 01 00 00 00 nop
<== NOT EXECUTED
40019b0c: aa 70 80 03 udiv %g2, %g3, %l5
<== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
40019b10: 80 a1 00 02 cmp %g4, %g2
<== NOT EXECUTED
direct = block % fs->blocks_per_block;
40019b14: ac 5d 40 03 smul %l5, %g3, %l6
<== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
40019b18: 18 80 00 4d bgu 40019c4c <rtems_rfs_block_map_shrink+0x200>
<== NOT EXECUTED
40019b1c: ac 20 80 16 sub %g2, %l6, %l6
<== NOT EXECUTED
else if (block < fs->block_map_doubly_blocks)
40019b20: c8 06 20 3c ld [ %i0 + 0x3c ], %g4
<== NOT EXECUTED
40019b24: 80 a1 00 02 cmp %g4, %g2
<== NOT EXECUTED
40019b28: 08 80 00 77 bleu 40019d04 <rtems_rfs_block_map_shrink+0x2b8>
<== NOT EXECUTED
40019b2c: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
doubly = singly / fs->blocks_per_block;
40019b30: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40019b34: 01 00 00 00 nop
<== NOT EXECUTED
40019b38: 01 00 00 00 nop
<== NOT EXECUTED
40019b3c: 01 00 00 00 nop
<== NOT EXECUTED
40019b40: ae 75 40 03 udiv %l5, %g3, %l7
<== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
40019b44: 86 5d c0 03 smul %l7, %g3, %g3
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
40019b48: 82 05 e0 08 add %l7, 8, %g1
<== NOT EXECUTED
40019b4c: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
40019b50: 82 06 40 01 add %i1, %g1, %g1
<== NOT EXECUTED
40019b54: d4 00 60 04 ld [ %g1 + 4 ], %o2
<== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
40019b58: aa 25 40 03 sub %l5, %g3, %l5
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
40019b5c: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
40019b60: 7f ff d7 5a call 4000f8c8 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
40019b64: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
40019b68: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019b6c: 14 80 00 36 bg 40019c44 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
40019b70: 85 2d 60 02 sll %l5, 2, %g2
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
40019b74: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
<== NOT EXECUTED
40019b78: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
<== NOT EXECUTED
40019b7c: e8 08 c0 02 ldub [ %g3 + %g2 ], %l4
<== NOT EXECUTED
40019b80: 82 00 c0 02 add %g3, %g2, %g1
<== NOT EXECUTED
40019b84: c6 08 60 03 ldub [ %g1 + 3 ], %g3
<== NOT EXECUTED
40019b88: c4 08 60 01 ldub [ %g1 + 1 ], %g2
<== NOT EXECUTED
40019b8c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
40019b90: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
40019b94: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
40019b98: a9 2d 20 18 sll %l4, 0x18, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019b9c: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
40019ba0: a8 15 00 03 or %l4, %g3, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019ba4: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
40019ba8: a8 15 00 02 or %l4, %g2, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019bac: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
40019bb0: a8 15 00 01 or %l4, %g1, %l4
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019bb4: 7f ff d7 45 call 4000f8c8 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
40019bb8: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
if (rc > 0)
40019bbc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019bc0: 14 80 00 21 bg 40019c44 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
40019bc4: 85 2d a0 02 sll %l6, 2, %g2
<== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
40019bc8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
<== NOT EXECUTED
40019bcc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
<== NOT EXECUTED
40019bd0: 82 00 c0 02 add %g3, %g2, %g1
<== NOT EXECUTED
40019bd4: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
<== NOT EXECUTED
40019bd8: c6 08 60 03 ldub [ %g1 + 3 ], %g3
<== NOT EXECUTED
40019bdc: c4 08 60 01 ldub [ %g1 + 1 ], %g2
<== NOT EXECUTED
40019be0: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
40019be4: bb 2f 60 18 sll %i5, 0x18, %i5
<== NOT EXECUTED
40019be8: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
40019bec: ba 17 40 03 or %i5, %g3, %i5
<== NOT EXECUTED
40019bf0: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
40019bf4: ba 17 40 02 or %i5, %g2, %i5
<== NOT EXECUTED
if (direct == 0)
40019bf8: 80 a5 a0 00 cmp %l6, 0
<== NOT EXECUTED
40019bfc: 12 bf ff ac bne 40019aac <rtems_rfs_block_map_shrink+0x60>
<== NOT EXECUTED
40019c00: ba 17 40 01 or %i5, %g1, %i5
<== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
40019c04: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
40019c08: 92 10 20 00 clr %o1
<== NOT EXECUTED
40019c0c: 7f ff de 78 call 400115ec <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40019c10: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
40019c14: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019c18: 14 80 00 0b bg 40019c44 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
40019c1c: 98 10 00 15 mov %l5, %o4
<== NOT EXECUTED
map->last_map_block = singly;
40019c20: e8 26 60 1c st %l4, [ %i1 + 0x1c ]
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
40019c24: 96 10 00 17 mov %l7, %o3
<== NOT EXECUTED
40019c28: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
40019c2c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40019c30: 7f ff fc d7 call 40018f8c <rtems_rfs_block_map_indirect_shrink.isra.12>
<== NOT EXECUTED
40019c34: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc)
40019c38: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019c3c: 02 bf ff 9d be 40019ab0 <rtems_rfs_block_map_shrink+0x64>
<== NOT EXECUTED
40019c40: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
40019c44: 81 c7 e0 08 ret
<== NOT EXECUTED
40019c48: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40019c4c: 82 05 60 08 add %l5, 8, %g1
<== NOT EXECUTED
40019c50: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
40019c54: 82 06 40 01 add %i1, %g1, %g1
<== NOT EXECUTED
40019c58: d4 00 60 04 ld [ %g1 + 4 ], %o2
<== NOT EXECUTED
40019c5c: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
40019c60: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
40019c64: 7f ff d7 19 call 4000f8c8 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
40019c68: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
40019c6c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019c70: 14 bf ff f5 bg 40019c44 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
40019c74: 85 2d a0 02 sll %l6, 2, %g2
<== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
40019c78: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
<== NOT EXECUTED
40019c7c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
<== NOT EXECUTED
40019c80: 82 00 c0 02 add %g3, %g2, %g1
<== NOT EXECUTED
40019c84: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
<== NOT EXECUTED
40019c88: c6 08 60 03 ldub [ %g1 + 3 ], %g3
<== NOT EXECUTED
40019c8c: c4 08 60 01 ldub [ %g1 + 1 ], %g2
<== NOT EXECUTED
40019c90: c2 08 60 02 ldub [ %g1 + 2 ], %g1
<== NOT EXECUTED
40019c94: bb 2f 60 18 sll %i5, 0x18, %i5
<== NOT EXECUTED
40019c98: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
40019c9c: ba 17 40 03 or %i5, %g3, %i5
<== NOT EXECUTED
40019ca0: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
40019ca4: ba 17 40 02 or %i5, %g2, %i5
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
40019ca8: 98 10 00 16 mov %l6, %o4
<== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
40019cac: ba 17 40 01 or %i5, %g1, %i5
<== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
40019cb0: 96 10 00 15 mov %l5, %o3
<== NOT EXECUTED
40019cb4: 10 bf ff de b 40019c2c <rtems_rfs_block_map_shrink+0x1e0>
<== NOT EXECUTED
40019cb8: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
40019cbc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
40019cc0: 80 a0 40 02 cmp %g1, %g2
40019cc4: 08 80 00 25 bleu 40019d58 <rtems_rfs_block_map_shrink+0x30c>
<== NEVER TAKEN
40019cc8: 86 00 7f ff add %g1, -1, %g3
40019ccc: 80 a0 c0 02 cmp %g3, %g2
40019cd0: 22 80 00 1c be,a 40019d40 <rtems_rfs_block_map_shrink+0x2f4>
<== ALWAYS TAKEN
40019cd4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
return 0;
40019cd8: 90 10 20 00 clr %o0
}
40019cdc: 81 c7 e0 08 ret
40019ce0: 91 e8 00 08 restore %g0, %o0, %o0
40019ce4: 10 bf ff 67 b 40019a80 <rtems_rfs_block_map_shrink+0x34>
40019ce8: b6 10 00 1a mov %i2, %i3
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
40019cec: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40019cf0: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
40019cf4: 7f ff e5 a5 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40019cf8: 90 12 22 88 or %o0, 0x288, %o0 ! 40023688 <status_code_to_errno+0x16c>
<== NOT EXECUTED
if (map->size.count == 0)
40019cfc: 10 bf ff 5c b 40019a6c <rtems_rfs_block_map_shrink+0x20>
<== NOT EXECUTED
40019d00: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
if (map->size.count == 0)
40019d04: 80 a0 60 00 cmp %g1, 0
40019d08: 32 bf ff ee bne,a 40019cc0 <rtems_rfs_block_map_shrink+0x274>
40019d0c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
map->last_map_block = 0;
40019d10: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
40019d14: c0 26 60 20 clr [ %i1 + 0x20 ]
40019d18: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
40019d1c: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
40019d20: 80 a0 a0 00 cmp %g2, 0
40019d24: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
40019d28: 02 bf ff ec be 40019cd8 <rtems_rfs_block_map_shrink+0x28c>
<== ALWAYS TAKEN
40019d2c: c0 26 60 18 clr [ %i1 + 0x18 ]
40019d30: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
return 0;
40019d34: 90 10 20 00 clr %o0
<== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
40019d38: 10 bf ff c3 b 40019c44 <rtems_rfs_block_map_shrink+0x1f8>
<== NOT EXECUTED
40019d3c: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
<== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
40019d40: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
40019d44: 80 a0 c0 02 cmp %g3, %g2
40019d48: 38 bf ff f6 bgu,a 40019d20 <rtems_rfs_block_map_shrink+0x2d4>
<== ALWAYS TAKEN
40019d4c: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
return 0;
40019d50: 10 bf ff e3 b 40019cdc <rtems_rfs_block_map_shrink+0x290>
<== NOT EXECUTED
40019d54: 90 10 20 00 clr %o0
<== NOT EXECUTED
40019d58: 10 bf ff f1 b 40019d1c <rtems_rfs_block_map_shrink+0x2d0>
<== NOT EXECUTED
40019d5c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
<== NOT EXECUTED
40019dc0 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
40019dc0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
40019dc4: 90 10 20 00 clr %o0
40019dc8: 7f ff e4 e2 call 40013150 <rtems_rfs_trace>
40019dcc: 92 10 20 40 mov 0x40, %o1
40019dd0: 80 a2 20 00 cmp %o0, 0
40019dd4: 02 80 00 0b be 40019e00 <rtems_rfs_buffer_bdbuf_release+0x40>
<== ALWAYS TAKEN
40019dd8: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40019ddc: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
40019de0: 12 80 00 18 bne 40019e40 <rtems_rfs_buffer_bdbuf_release+0x80>
<== NOT EXECUTED
40019de4: d4 06 20 18 ld [ %i0 + 0x18 ], %o2
<== NOT EXECUTED
40019de8: 17 10 00 84 sethi %hi(0x40021000), %o3
<== NOT EXECUTED
40019dec: 96 12 e1 c0 or %o3, 0x1c0, %o3 ! 400211c0 <_rodata_start+0x8e0>
<== NOT EXECUTED
40019df0: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
40019df4: 7f ff e5 65 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40019df8: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400236d8 <status_code_to_errno+0x1bc>
<== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
40019dfc: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40019e00: 02 80 00 09 be 40019e24 <rtems_rfs_buffer_bdbuf_release+0x64>
40019e04: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
40019e08: 7f ff ef 51 call 40015b4c <rtems_bdbuf_release_modified>
40019e0c: 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;
40019e10: 80 a0 00 08 cmp %g0, %o0
40019e14: b0 40 3f ff addx %g0, -1, %i0
40019e18: b0 0e 3f fb and %i0, -5, %i0
}
return rc;
}
40019e1c: 81 c7 e0 08 ret
40019e20: 91 ee 20 05 restore %i0, 5, %o0
sc = rtems_bdbuf_release (buffer);
40019e24: 7f ff ef 04 call 40015a34 <rtems_bdbuf_release>
40019e28: 01 00 00 00 nop
rc = EIO;
40019e2c: 80 a0 00 08 cmp %g0, %o0
40019e30: b0 40 3f ff addx %g0, -1, %i0
40019e34: b0 0e 3f fb and %i0, -5, %i0
}
40019e38: 81 c7 e0 08 ret
40019e3c: 91 ee 20 05 restore %i0, 5, %o0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40019e40: 17 10 00 8d sethi %hi(0x40023400), %o3
<== NOT EXECUTED
40019e44: 10 bf ff eb b 40019df0 <rtems_rfs_buffer_bdbuf_release+0x30>
<== NOT EXECUTED
40019e48: 96 12 e2 c8 or %o3, 0x2c8, %o3 ! 400236c8 <status_code_to_errno+0x1ac>
<== NOT EXECUTED
4000ffd4 <rtems_rfs_buffer_close>:
{
4000ffd4: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4000ffd8: 90 10 20 00 clr %o0
4000ffdc: 92 10 20 10 mov 0x10, %o1
4000ffe0: 40 00 0c 5c call 40013150 <rtems_rfs_trace>
4000ffe4: ba 10 00 18 mov %i0, %i5
4000ffe8: 80 a2 20 00 cmp %o0, 0
4000ffec: 12 80 00 2f bne 400100a8 <rtems_rfs_buffer_close+0xd4>
<== NEVER TAKEN
4000fff0: 11 10 00 88 sethi %hi(0x40022000), %o0
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
4000fff4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000fff8: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
4000fffc: 7f ff ff b5 call 4000fed0 <rtems_rfs_buffer_setblksize>
40010000: 90 10 00 1d mov %i5, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
40010004: b0 92 20 00 orcc %o0, 0, %i0
40010008: 14 80 00 1b bg 40010074 <rtems_rfs_buffer_close+0xa0>
<== NEVER TAKEN
4001000c: 90 10 20 00 clr %o0
if (close (fs->device) < 0)
40010010: 40 00 1a c3 call 40016b1c <close>
40010014: d0 07 60 0c ld [ %i5 + 0xc ], %o0
40010018: 80 a2 20 00 cmp %o0, 0
4001001c: 06 80 00 04 bl 4001002c <rtems_rfs_buffer_close+0x58>
<== NEVER TAKEN
40010020: 01 00 00 00 nop
}
40010024: 81 c7 e0 08 ret
40010028: 81 e8 00 00 restore
rc = errno;
4001002c: 40 00 39 48 call 4001e54c <__errno>
<== NOT EXECUTED
40010030: 01 00 00 00 nop
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
40010034: 92 10 20 10 mov 0x10, %o1 ! 10 <_TLS_Alignment+0xf>
<== NOT EXECUTED
rc = errno;
40010038: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001003c: 40 00 0c 45 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
40010040: 90 10 20 00 clr %o0
<== NOT EXECUTED
40010044: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40010048: 02 80 00 09 be 4001006c <rtems_rfs_buffer_close+0x98>
<== NOT EXECUTED
4001004c: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
40010050: 40 00 3d 14 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010054: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40010058: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001005c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010060: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
40010064: 40 00 0c c9 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010068: 90 12 22 38 or %o0, 0x238, %o0 ! 40022238 <ramdisk_ops+0x520>
<== NOT EXECUTED
}
4001006c: 81 c7 e0 08 ret
<== NOT EXECUTED
40010070: 81 e8 00 00 restore
<== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
40010074: 40 00 0c 37 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
40010078: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
4001007c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40010080: 02 bf ff e4 be 40010010 <rtems_rfs_buffer_close+0x3c>
<== NOT EXECUTED
40010084: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
40010088: 40 00 3d 06 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001008c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40010090: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010094: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010098: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4001009c: 40 00 0c bb call 40013388 <__wrap_printf>
<== NOT EXECUTED
400100a0: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400221f8 <ramdisk_ops+0x4e0>
<== NOT EXECUTED
400100a4: 30 bf ff db b,a 40010010 <rtems_rfs_buffer_close+0x3c>
<== NOT EXECUTED
printf ("rtems-rfs: buffer-close: closing\n");
400100a8: 40 00 0c c7 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
400100ac: 90 12 21 d0 or %o0, 0x1d0, %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
400100b0: 10 bf ff d2 b 4000fff8 <rtems_rfs_buffer_close+0x24>
<== NOT EXECUTED
400100b4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000f8c8 <rtems_rfs_buffer_handle_request>:
{
4000f8c8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_buffer_handle_has_block (handle))
4000f8cc: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000f8d0: 80 a0 60 00 cmp %g1, 0
4000f8d4: 02 80 00 1b be 4000f940 <rtems_rfs_buffer_handle_request+0x78>
4000f8d8: ba 10 00 18 mov %i0, %i5
if (block && (rtems_rfs_buffer_bnum (handle) == block))
4000f8dc: 80 a6 a0 00 cmp %i2, 0
4000f8e0: 02 80 00 06 be 4000f8f8 <rtems_rfs_buffer_handle_request+0x30>
<== NEVER TAKEN
4000f8e4: 90 10 20 00 clr %o0
4000f8e8: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000f8ec: 80 a0 40 1a cmp %g1, %i2
4000f8f0: 02 80 00 7a be 4000fad8 <rtems_rfs_buffer_handle_request+0x210>
4000f8f4: 01 00 00 00 nop
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000f8f8: 40 00 0e 16 call 40013150 <rtems_rfs_trace>
4000f8fc: 92 10 21 00 mov 0x100, %o1 ! 100 <_TLS_Alignment+0xff>
4000f900: 80 a2 20 00 cmp %o0, 0
4000f904: 32 80 00 4f bne,a 4000fa40 <rtems_rfs_buffer_handle_request+0x178>
<== NEVER TAKEN
4000f908: d2 06 60 04 ld [ %i1 + 4 ], %o1
<== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
4000f90c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000f910: 80 a0 60 00 cmp %g1, 0
4000f914: 22 80 00 0a be,a 4000f93c <rtems_rfs_buffer_handle_request+0x74>
<== NEVER TAKEN
4000f918: c0 2e 40 00 clrb [ %i1 ]
<== NOT EXECUTED
4000f91c: 92 10 00 19 mov %i1, %o1
4000f920: 7f ff ff 5b call 4000f68c <rtems_rfs_buffer_handle_release.part.2>
4000f924: 90 10 00 1d mov %i5, %o0
if (rc > 0)
4000f928: b0 92 20 00 orcc %o0, 0, %i0
4000f92c: 24 80 00 04 ble,a 4000f93c <rtems_rfs_buffer_handle_request+0x74>
<== ALWAYS TAKEN
4000f930: c0 2e 40 00 clrb [ %i1 ]
}
4000f934: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f938: 81 e8 00 00 restore
<== NOT EXECUTED
handle->bnum = 0;
4000f93c: c0 26 60 04 clr [ %i1 + 4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000f940: 90 10 20 00 clr %o0
4000f944: 40 00 0e 03 call 40013150 <rtems_rfs_trace>
4000f948: 92 10 21 00 mov 0x100, %o1
4000f94c: 80 a2 20 00 cmp %o0, 0
4000f950: 32 80 00 59 bne,a 4000fab4 <rtems_rfs_buffer_handle_request+0x1ec>
<== NEVER TAKEN
4000f954: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
if (fs->buffers_count)
4000f958: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4000f95c: 80 a0 60 00 cmp %g1, 0
4000f960: 12 80 00 41 bne 4000fa64 <rtems_rfs_buffer_handle_request+0x19c>
4000f964: 94 10 00 1a mov %i2, %o2
if (!rtems_rfs_fs_no_local_cache (fs) &&
4000f968: c4 07 40 00 ld [ %i5 ], %g2
4000f96c: 80 88 a0 02 btst 2, %g2
4000f970: 12 80 00 26 bne 4000fa08 <rtems_rfs_buffer_handle_request+0x140>
4000f974: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000f978: 80 a0 60 00 cmp %g1, 0
4000f97c: 22 80 00 69 be,a 4000fb20 <rtems_rfs_buffer_handle_request+0x258>
4000f980: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
rtems_rfs_buffer_refs_up (handle);
4000f984: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
old_last = tail->previous;
4000f988: c6 07 60 4c ld [ %i5 + 0x4c ], %g3
return &the_chain->Tail.Node;
4000f98c: 88 07 60 48 add %i5, 0x48, %g4
4000f990: 84 00 a0 01 inc %g2
the_node->next = tail;
4000f994: c8 20 40 00 st %g4, [ %g1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000f998: 90 10 20 00 clr %o0
rtems_rfs_buffer_refs_up (handle);
4000f99c: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000f9a0: 92 10 21 00 mov 0x100, %o1
tail->previous = the_node;
4000f9a4: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
old_last->next = the_node;
4000f9a8: c2 20 c0 00 st %g1, [ %g3 ]
fs->buffers_count++;
4000f9ac: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
the_node->previous = old_last;
4000f9b0: c6 20 60 04 st %g3, [ %g1 + 4 ]
4000f9b4: 84 00 a0 01 inc %g2
4000f9b8: c4 27 60 50 st %g2, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
4000f9bc: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000f9c0: 40 00 0d e4 call 40013150 <rtems_rfs_trace>
4000f9c4: f4 26 60 04 st %i2, [ %i1 + 4 ]
4000f9c8: 80 a2 20 00 cmp %o0, 0
4000f9cc: 02 80 00 43 be 4000fad8 <rtems_rfs_buffer_handle_request+0x210>
<== ALWAYS TAKEN
4000f9d0: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4000f9d4: 12 80 00 43 bne 4000fae0 <rtems_rfs_buffer_handle_request+0x218>
<== NOT EXECUTED
4000f9d8: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4000f9dc: d8 00 60 30 ld [ %g1 + 0x30 ], %o4
<== NOT EXECUTED
4000f9e0: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
<== NOT EXECUTED
return 0;
4000f9e4: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4000f9e8: 15 10 00 87 sethi %hi(0x40021c00), %o2
<== NOT EXECUTED
4000f9ec: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000f9f0: 94 12 a2 48 or %o2, 0x248, %o2
<== NOT EXECUTED
4000f9f4: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000f9f8: 40 00 0e 64 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000f9fc: 90 12 23 20 or %o0, 0x320, %o0 ! 40021f20 <ramdisk_ops+0x208>
<== NOT EXECUTED
4000fa00: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fa04: 81 e8 00 00 restore
<== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (handle))
4000fa08: 80 a0 60 00 cmp %g1, 0
4000fa0c: 32 bf ff df bne,a 4000f988 <rtems_rfs_buffer_handle_request+0xc0>
<== NEVER TAKEN
4000fa10: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
<== NOT EXECUTED
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4000fa14: 96 06 60 08 add %i1, 8, %o3
4000fa18: 94 10 00 1b mov %i3, %o2
4000fa1c: 92 10 00 1a mov %i2, %o1
4000fa20: 40 00 28 d4 call 40019d70 <rtems_rfs_buffer_bdbuf_request>
4000fa24: 90 10 00 1d mov %i5, %o0
if (rc > 0)
4000fa28: b0 92 20 00 orcc %o0, 0, %i0
4000fa2c: 14 80 00 4f bg 4000fb68 <rtems_rfs_buffer_handle_request+0x2a0>
<== NEVER TAKEN
4000fa30: 90 10 20 00 clr %o0
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
4000fa34: c2 06 60 08 ld [ %i1 + 8 ], %g1
node->next = NULL;
4000fa38: 10 bf ff d3 b 4000f984 <rtems_rfs_buffer_handle_request+0xbc>
4000fa3c: c0 20 40 00 clr [ %g1 ]
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
4000fa40: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000fa44: 40 00 0e 51 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fa48: 90 12 22 50 or %o0, 0x250, %o0 ! 40021e50 <ramdisk_ops+0x138>
<== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
4000fa4c: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4000fa50: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000fa54: 32 bf ff b3 bne,a 4000f920 <rtems_rfs_buffer_handle_request+0x58>
<== NOT EXECUTED
4000fa58: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
handle->dirty = false;
4000fa5c: 10 bf ff b8 b 4000f93c <rtems_rfs_buffer_handle_request+0x74>
<== NOT EXECUTED
4000fa60: c0 2e 40 00 clrb [ %i1 ]
<== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4000fa64: 92 07 60 50 add %i5, 0x50, %o1
4000fa68: 7f ff fe 9a call 4000f4d0 <rtems_rfs_scan_chain>
4000fa6c: 90 07 60 44 add %i5, 0x44, %o0
if (rtems_rfs_buffer_handle_has_block (handle) &&
4000fa70: 80 a2 20 00 cmp %o0, 0
4000fa74: 02 80 00 26 be 4000fb0c <rtems_rfs_buffer_handle_request+0x244>
4000fa78: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000fa7c: 90 10 20 00 clr %o0
4000fa80: 40 00 0d b4 call 40013150 <rtems_rfs_trace>
4000fa84: 92 10 21 00 mov 0x100, %o1
if (rtems_rfs_buffer_handle_has_block (handle) &&
4000fa88: 80 a2 20 00 cmp %o0, 0
4000fa8c: 22 bf ff b8 be,a 4000f96c <rtems_rfs_buffer_handle_request+0xa4>
<== ALWAYS TAKEN
4000fa90: c4 07 40 00 ld [ %i5 ], %g2
rtems_rfs_buffer_refs (handle) + 1);
4000fa94: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
4000fa98: d2 00 60 30 ld [ %g1 + 0x30 ], %o1
<== NOT EXECUTED
4000fa9c: 92 02 60 01 inc %o1
<== NOT EXECUTED
4000faa0: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000faa4: 40 00 0e 39 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000faa8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40021eb0 <ramdisk_ops+0x198>
<== NOT EXECUTED
if (!rtems_rfs_fs_no_local_cache (fs) &&
4000faac: 10 bf ff b0 b 4000f96c <rtems_rfs_buffer_handle_request+0xa4>
<== NOT EXECUTED
4000fab0: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
4000fab4: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000fab8: 40 00 0e 34 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fabc: 90 12 22 88 or %o0, 0x288, %o0 ! 40021e88 <ramdisk_ops+0x170>
<== NOT EXECUTED
if (fs->buffers_count)
4000fac0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
4000fac4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000fac8: 22 bf ff a9 be,a 4000f96c <rtems_rfs_buffer_handle_request+0xa4>
<== NOT EXECUTED
4000facc: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4000fad0: 10 bf ff e5 b 4000fa64 <rtems_rfs_buffer_handle_request+0x19c>
<== NOT EXECUTED
4000fad4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
return 0;
4000fad8: 81 c7 e0 08 ret
4000fadc: 91 e8 20 00 restore %g0, 0, %o0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4000fae0: d8 00 60 30 ld [ %g1 + 0x30 ], %o4
<== NOT EXECUTED
4000fae4: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
<== NOT EXECUTED
return 0;
4000fae8: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4000faec: 15 10 00 87 sethi %hi(0x40021c00), %o2
<== NOT EXECUTED
4000faf0: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000faf4: 94 12 a2 40 or %o2, 0x240, %o2
<== NOT EXECUTED
4000faf8: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000fafc: 40 00 0e 23 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fb00: 90 12 23 20 or %o0, 0x320, %o0 ! 40021f20 <ramdisk_ops+0x208>
<== NOT EXECUTED
4000fb04: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fb08: 81 e8 00 00 restore
<== NOT EXECUTED
if (!rtems_rfs_fs_no_local_cache (fs) &&
4000fb0c: c2 07 40 00 ld [ %i5 ], %g1
4000fb10: 80 88 60 02 btst 2, %g1
4000fb14: 12 bf ff c1 bne 4000fa18 <rtems_rfs_buffer_handle_request+0x150>
4000fb18: 96 06 60 08 add %i1, 8, %o3
if (fs->release_count)
4000fb1c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4000fb20: 80 a0 60 00 cmp %g1, 0
4000fb24: 12 80 00 25 bne 4000fbb8 <rtems_rfs_buffer_handle_request+0x2f0>
4000fb28: 94 10 00 1a mov %i2, %o2
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4000fb2c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4000fb30: 80 a0 60 00 cmp %g1, 0
4000fb34: 02 bf ff b9 be 4000fa18 <rtems_rfs_buffer_handle_request+0x150>
4000fb38: 96 06 60 08 add %i1, 8, %o3
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
4000fb3c: 94 10 00 1a mov %i2, %o2
4000fb40: 92 07 60 70 add %i5, 0x70, %o1
4000fb44: 7f ff fe 63 call 4000f4d0 <rtems_rfs_scan_chain>
4000fb48: 90 07 60 64 add %i5, 0x64, %o0
4000fb4c: d0 26 60 08 st %o0, [ %i1 + 8 ]
if (rtems_rfs_buffer_handle_has_block (handle))
4000fb50: 80 a2 20 00 cmp %o0, 0
4000fb54: 02 bf ff b0 be 4000fa14 <rtems_rfs_buffer_handle_request+0x14c>
4000fb58: 82 10 00 08 mov %o0, %g1
rtems_rfs_buffer_mark_dirty (handle);
4000fb5c: 84 10 20 01 mov 1, %g2
4000fb60: 10 bf ff 89 b 4000f984 <rtems_rfs_buffer_handle_request+0xbc>
4000fb64: c4 2e 40 00 stb %g2, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4000fb68: 40 00 0d 7a call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000fb6c: 92 10 21 00 mov 0x100, %o1
<== NOT EXECUTED
4000fb70: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fb74: 02 bf ff 70 be 4000f934 <rtems_rfs_buffer_handle_request+0x6c>
<== NOT EXECUTED
4000fb78: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4000fb7c: 12 80 00 18 bne 4000fbdc <rtems_rfs_buffer_handle_request+0x314>
<== NOT EXECUTED
4000fb80: 3b 10 00 87 sethi %hi(0x40021c00), %i5
<== NOT EXECUTED
4000fb84: 3b 10 00 87 sethi %hi(0x40021c00), %i5
<== NOT EXECUTED
4000fb88: ba 17 62 48 or %i5, 0x248, %i5 ! 40021e48 <ramdisk_ops+0x130>
<== NOT EXECUTED
4000fb8c: 40 00 3e 45 call 4001f4a0 <strerror>
<== NOT EXECUTED
4000fb90: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000fb94: 96 10 00 18 mov %i0, %o3
<== NOT EXECUTED
4000fb98: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4000fb9c: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000fba0: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000fba4: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000fba8: 40 00 0d f8 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fbac: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40021ee8 <ramdisk_ops+0x1d0>
<== NOT EXECUTED
4000fbb0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fbb4: 81 e8 00 00 restore
<== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
4000fbb8: 92 07 60 60 add %i5, 0x60, %o1
4000fbbc: 7f ff fe 45 call 4000f4d0 <rtems_rfs_scan_chain>
4000fbc0: 90 07 60 54 add %i5, 0x54, %o0
4000fbc4: d0 26 60 08 st %o0, [ %i1 + 8 ]
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4000fbc8: 80 a2 20 00 cmp %o0, 0
4000fbcc: 12 bf ff 6e bne 4000f984 <rtems_rfs_buffer_handle_request+0xbc>
4000fbd0: 82 10 00 08 mov %o0, %g1
4000fbd4: 10 bf ff d7 b 4000fb30 <rtems_rfs_buffer_handle_request+0x268>
4000fbd8: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4000fbdc: 10 bf ff ec b 4000fb8c <rtems_rfs_buffer_handle_request+0x2c4>
<== NOT EXECUTED
4000fbe0: ba 17 62 40 or %i5, 0x240, %i5
<== NOT EXECUTED
4000fc08 <rtems_rfs_buffer_open>:
{
4000fc08: 9d e3 bf 40 save %sp, -192, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4000fc0c: 90 10 20 00 clr %o0
4000fc10: 40 00 0d 50 call 40013150 <rtems_rfs_trace>
4000fc14: 92 10 20 20 mov 0x20, %o1
4000fc18: 80 a2 20 00 cmp %o0, 0
4000fc1c: 12 80 00 26 bne 4000fcb4 <rtems_rfs_buffer_open+0xac>
<== NEVER TAKEN
4000fc20: 92 10 00 18 mov %i0, %o1
fs->device = open (name, O_RDWR);
4000fc24: 92 10 20 02 mov 2, %o1
4000fc28: 7f ff dc df call 40006fa4 <open>
4000fc2c: 90 10 00 18 mov %i0, %o0
if (fs->device < 0)
4000fc30: 80 a2 20 00 cmp %o0, 0
4000fc34: 06 80 00 15 bl 4000fc88 <rtems_rfs_buffer_open+0x80>
<== NEVER TAKEN
4000fc38: d0 26 60 0c st %o0, [ %i1 + 0xc ]
if (fstat (fs->device, &st) < 0)
4000fc3c: 40 00 1c 00 call 40016c3c <fstat>
4000fc40: 92 07 bf a0 add %fp, -96, %o1
4000fc44: 80 a2 20 00 cmp %o0, 0
4000fc48: 06 80 00 32 bl 4000fd10 <rtems_rfs_buffer_open+0x108>
<== NEVER TAKEN
4000fc4c: 05 00 00 3c sethi %hi(0xf000), %g2
if (!S_ISBLK (st.st_mode))
4000fc50: c2 07 bf ac ld [ %fp + -84 ], %g1
4000fc54: 82 08 40 02 and %g1, %g2, %g1
4000fc58: 05 00 00 18 sethi %hi(0x6000), %g2
4000fc5c: 80 a0 40 02 cmp %g1, %g2
4000fc60: 22 80 00 1a be,a 4000fcc8 <rtems_rfs_buffer_open+0xc0>
<== ALWAYS TAKEN
4000fc64: d0 06 60 0c ld [ %i1 + 0xc ], %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4000fc68: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000fc6c: 40 00 0d 39 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000fc70: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4000fc74: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fc78: 12 80 00 38 bne 4000fd58 <rtems_rfs_buffer_open+0x150>
<== NOT EXECUTED
4000fc7c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
return ENXIO;
4000fc80: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fc84: 91 e8 20 06 restore %g0, 6, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4000fc88: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000fc8c: 40 00 0d 31 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000fc90: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4000fc94: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fc98: 02 bf ff fa be 4000fc80 <rtems_rfs_buffer_open+0x78>
<== NOT EXECUTED
4000fc9c: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
return ENXIO;
4000fca0: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
4000fca4: 40 00 0d c8 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4000fca8: 90 12 23 88 or %o0, 0x388, %o0
<== NOT EXECUTED
4000fcac: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fcb0: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
4000fcb4: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000fcb8: 40 00 0d b4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fcbc: 90 12 23 60 or %o0, 0x360, %o0 ! 40021f60 <ramdisk_ops+0x248>
<== NOT EXECUTED
fs->device = open (name, O_RDWR);
4000fcc0: 10 bf ff da b 4000fc28 <rtems_rfs_buffer_open+0x20>
<== NOT EXECUTED
4000fcc4: 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);
4000fcc8: 94 06 60 10 add %i1, 0x10, %o2
4000fccc: 13 10 01 10 sethi %hi(0x40044000), %o1
4000fcd0: 40 00 1c 56 call 40016e28 <ioctl>
4000fcd4: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x1b4f9>
4000fcd8: b0 10 00 08 mov %o0, %i0
if (rv != 0)
4000fcdc: 80 a6 20 00 cmp %i0, 0
4000fce0: 02 80 00 24 be 4000fd70 <rtems_rfs_buffer_open+0x168>
<== ALWAYS TAKEN
4000fce4: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4000fce8: 40 00 0d 1a call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000fcec: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4000fcf0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fcf4: 02 bf ff e3 be 4000fc80 <rtems_rfs_buffer_open+0x78>
<== NOT EXECUTED
4000fcf8: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
return ENXIO;
4000fcfc: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
4000fd00: 40 00 0d b1 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4000fd04: 90 12 20 20 or %o0, 0x20, %o0
<== NOT EXECUTED
4000fd08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fd0c: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4000fd10: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000fd14: 40 00 0d 0f call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000fd18: 92 10 20 08 mov 8, %o1
<== NOT EXECUTED
4000fd1c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fd20: 02 bf ff d8 be 4000fc80 <rtems_rfs_buffer_open+0x78>
<== NOT EXECUTED
4000fd24: 01 00 00 00 nop
<== NOT EXECUTED
name, strerror (errno));
4000fd28: 40 00 3a 09 call 4001e54c <__errno>
<== NOT EXECUTED
4000fd2c: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
4000fd30: 40 00 3d dc call 4001f4a0 <strerror>
<== NOT EXECUTED
4000fd34: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4000fd38: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000fd3c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return ENXIO;
4000fd40: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
4000fd44: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
4000fd48: 40 00 0d 90 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fd4c: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40021fb8 <ramdisk_ops+0x2a0>
<== NOT EXECUTED
4000fd50: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fd54: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4000fd58: 11 10 00 87 sethi %hi(0x40021c00), %o0
<== NOT EXECUTED
return ENXIO;
4000fd5c: b0 10 20 06 mov 6, %i0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4000fd60: 40 00 0d 8a call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fd64: 90 12 23 e8 or %o0, 0x3e8, %o0
<== NOT EXECUTED
4000fd68: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fd6c: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4000fd70: 40 00 0c f8 call 40013150 <rtems_rfs_trace>
4000fd74: 92 10 20 20 mov 0x20, %o1
4000fd78: 80 a2 20 00 cmp %o0, 0
4000fd7c: 32 80 00 04 bne,a 4000fd8c <rtems_rfs_buffer_open+0x184>
<== NEVER TAKEN
4000fd80: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
}
4000fd84: 81 c7 e0 08 ret
4000fd88: 81 e8 00 00 restore
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
4000fd8c: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
<== NOT EXECUTED
4000fd90: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
<== NOT EXECUTED
4000fd94: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4000fd98: 40 00 0d 7c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fd9c: 90 12 20 50 or %o0, 0x50, %o0 ! 40022050 <ramdisk_ops+0x338>
<== NOT EXECUTED
}
4000fda0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fda4: 81 e8 00 00 restore
<== NOT EXECUTED
4000fed0 <rtems_rfs_buffer_setblksize>:
{
4000fed0: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4000fed4: 90 10 20 00 clr %o0
{
4000fed8: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4000fedc: 40 00 0c 9d call 40013150 <rtems_rfs_trace>
4000fee0: 92 10 24 00 mov 0x400, %o1
4000fee4: 80 a2 20 00 cmp %o0, 0
4000fee8: 12 80 00 37 bne 4000ffc4 <rtems_rfs_buffer_setblksize+0xf4>
<== NEVER TAKEN
4000feec: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
rc = rtems_rfs_buffers_release (fs);
4000fef0: 7f ff ff d4 call 4000fe40 <rtems_rfs_buffers_release>
4000fef4: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4000fef8: ba 92 20 00 orcc %o0, 0, %i5
4000fefc: 14 80 00 25 bg 4000ff90 <rtems_rfs_buffer_setblksize+0xc0>
<== NEVER TAKEN
4000ff00: 90 10 20 00 clr %o0
rc = rtems_rfs_buffer_sync (fs);
4000ff04: 7f ff ff a9 call 4000fda8 <rtems_rfs_buffer_sync>
4000ff08: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4000ff0c: ba 92 20 00 orcc %o0, 0, %i5
4000ff10: 14 80 00 12 bg 4000ff58 <rtems_rfs_buffer_setblksize+0x88>
<== NEVER TAKEN
4000ff14: 90 10 20 00 clr %o0
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4000ff18: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4000ff1c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000ff20: 94 07 a0 48 add %fp, 0x48, %o2
4000ff24: 13 20 01 10 sethi %hi(0x80044000), %o1
4000ff28: 9f c0 40 00 call %g1
4000ff2c: 92 12 62 04 or %o1, 0x204, %o1 ! 80044204 <RAM_END+0x3fc44204>
if (rc < 0)
4000ff30: b0 92 20 00 orcc %o0, 0, %i0
4000ff34: 06 80 00 04 bl 4000ff44 <rtems_rfs_buffer_setblksize+0x74>
<== NEVER TAKEN
4000ff38: 01 00 00 00 nop
}
4000ff3c: 81 c7 e0 08 ret
4000ff40: 81 e8 00 00 restore
rc = errno;
4000ff44: 40 00 39 82 call 4001e54c <__errno>
<== NOT EXECUTED
4000ff48: 01 00 00 00 nop
<== NOT EXECUTED
4000ff4c: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
}
4000ff50: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ff54: 81 e8 00 00 restore
<== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4000ff58: 40 00 0c 7e call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000ff5c: 92 10 24 00 mov 0x400, %o1
<== NOT EXECUTED
4000ff60: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000ff64: 22 bf ff ee be,a 4000ff1c <rtems_rfs_buffer_setblksize+0x4c>
<== NOT EXECUTED
4000ff68: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
4000ff6c: 40 00 3d 4d call 4001f4a0 <strerror>
<== NOT EXECUTED
4000ff70: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000ff74: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000ff78: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4000ff7c: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4000ff80: 40 00 0d 02 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000ff84: 90 12 21 90 or %o0, 0x190, %o0 ! 40022190 <ramdisk_ops+0x478>
<== NOT EXECUTED
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4000ff88: 10 bf ff e5 b 4000ff1c <rtems_rfs_buffer_setblksize+0x4c>
<== NOT EXECUTED
4000ff8c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
<== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4000ff90: 40 00 0c 70 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000ff94: 92 10 24 00 mov 0x400, %o1
<== NOT EXECUTED
4000ff98: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000ff9c: 02 bf ff da be 4000ff04 <rtems_rfs_buffer_setblksize+0x34>
<== NOT EXECUTED
4000ffa0: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
4000ffa4: 40 00 3d 3f call 4001f4a0 <strerror>
<== NOT EXECUTED
4000ffa8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000ffac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000ffb0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4000ffb4: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4000ffb8: 40 00 0c f4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000ffbc: 90 12 21 50 or %o0, 0x150, %o0 ! 40022150 <ramdisk_ops+0x438>
<== NOT EXECUTED
4000ffc0: 30 bf ff d1 b,a 4000ff04 <rtems_rfs_buffer_setblksize+0x34>
<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size);
4000ffc4: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4000ffc8: 40 00 0c f0 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000ffcc: 90 12 21 20 or %o0, 0x120, %o0 ! 40022120 <ramdisk_ops+0x408>
<== NOT EXECUTED
4000ffd0: 30 bf ff c8 b,a 4000fef0 <rtems_rfs_buffer_setblksize+0x20>
<== NOT EXECUTED
4000fda8 <rtems_rfs_buffer_sync>:
{
4000fda8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4000fdac: 90 10 20 00 clr %o0
4000fdb0: 92 10 20 20 mov 0x20, %o1
4000fdb4: 40 00 0c e7 call 40013150 <rtems_rfs_trace>
4000fdb8: ba 10 00 18 mov %i0, %i5
4000fdbc: 80 a2 20 00 cmp %o0, 0
4000fdc0: 12 80 00 1d bne 4000fe34 <rtems_rfs_buffer_sync+0x8c>
<== NEVER TAKEN
4000fdc4: 11 10 00 88 sethi %hi(0x40022000), %o0
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
4000fdc8: 40 00 17 83 call 40015bd4 <rtems_bdbuf_syncdev>
4000fdcc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
int result = 0;
4000fdd0: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4000fdd4: 80 a2 20 00 cmp %o0, 0
4000fdd8: 12 80 00 06 bne 4000fdf0 <rtems_rfs_buffer_sync+0x48>
<== NEVER TAKEN
4000fddc: b8 10 00 08 mov %o0, %i4
rtems_disk_release (fs->disk);
4000fde0: 7f ff d3 18 call 40004a40 <rtems_disk_release>
4000fde4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
}
4000fde8: 81 c7 e0 08 ret
4000fdec: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4000fdf0: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000fdf4: 92 10 20 20 mov 0x20, %o1
<== NOT EXECUTED
4000fdf8: 40 00 0c d6 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4000fdfc: b0 10 20 05 mov 5, %i0
<== NOT EXECUTED
4000fe00: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fe04: 02 bf ff f7 be 4000fde0 <rtems_rfs_buffer_sync+0x38>
<== NOT EXECUTED
4000fe08: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
4000fe0c: 40 00 1e 2a call 400176b4 <rtems_status_text>
<== NOT EXECUTED
4000fe10: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000fe14: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4000fe18: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4000fe1c: 40 00 0d 5b call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fe20: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400220a0 <ramdisk_ops+0x388>
<== NOT EXECUTED
rtems_disk_release (fs->disk);
4000fe24: 7f ff d3 07 call 40004a40 <rtems_disk_release>
<== NOT EXECUTED
4000fe28: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
<== NOT EXECUTED
}
4000fe2c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fe30: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: syncing\n");
4000fe34: 40 00 0d 64 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4000fe38: 90 12 20 80 or %o0, 0x80, %o0
<== NOT EXECUTED
4000fe3c: 30 bf ff e3 b,a 4000fdc8 <rtems_rfs_buffer_sync+0x20>
<== NOT EXECUTED
4000fe40 <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
4000fe40: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4000fe44: 90 10 20 00 clr %o0
4000fe48: 92 10 20 40 mov 0x40, %o1
4000fe4c: 40 00 0c c1 call 40013150 <rtems_rfs_trace>
4000fe50: ba 10 00 18 mov %i0, %i5
4000fe54: 80 a2 20 00 cmp %o0, 0
4000fe58: 32 80 00 17 bne,a 4000feb4 <rtems_rfs_buffers_release+0x74>
<== NEVER TAKEN
4000fe5c: 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,
4000fe60: 94 10 20 00 clr %o2
4000fe64: 92 07 60 60 add %i5, 0x60, %o1
4000fe68: 7f ff fd e1 call 4000f5ec <rtems_rfs_release_chain>
4000fe6c: 90 07 60 54 add %i5, 0x54, %o0
4000fe70: 92 07 60 70 add %i5, 0x70, %o1
4000fe74: 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,
4000fe78: 94 10 20 01 mov 1, %o2
if ((rc > 0) && (rrc == 0))
4000fe7c: 80 a6 20 00 cmp %i0, 0
4000fe80: 04 80 00 06 ble 4000fe98 <rtems_rfs_buffers_release+0x58>
<== ALWAYS TAKEN
4000fe84: 90 07 60 64 add %i5, 0x64, %o0
rc = rtems_rfs_release_chain (&fs->release_modified,
4000fe88: 7f ff fd d9 call 4000f5ec <rtems_rfs_release_chain>
<== NOT EXECUTED
4000fe8c: 01 00 00 00 nop
<== NOT EXECUTED
true);
if ((rc > 0) && (rrc == 0))
rrc = rc;
return rrc;
}
4000fe90: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fe94: 81 e8 00 00 restore
<== NOT EXECUTED
rc = rtems_rfs_release_chain (&fs->release_modified,
4000fe98: 7f ff fd d5 call 4000f5ec <rtems_rfs_release_chain>
4000fe9c: 01 00 00 00 nop
4000fea0: 82 38 00 08 xnor %g0, %o0, %g1
4000fea4: 83 38 60 1f sra %g1, 0x1f, %g1
4000fea8: b0 0a 00 01 and %o0, %g1, %i0
4000feac: 81 c7 e0 08 ret
4000feb0: 81 e8 00 00 restore
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
4000feb4: d4 06 20 60 ld [ %i0 + 0x60 ], %o2
<== NOT EXECUTED
4000feb8: d2 06 20 50 ld [ %i0 + 0x50 ], %o1
<== NOT EXECUTED
4000febc: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4000fec0: 40 00 0d 32 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4000fec4: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400220d0 <ramdisk_ops+0x3b8>
<== NOT EXECUTED
rc = rtems_rfs_release_chain (&fs->release,
4000fec8: 10 bf ff e7 b 4000fe64 <rtems_rfs_buffers_release+0x24>
<== NOT EXECUTED
4000fecc: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001a38c <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)
{
4001a38c: 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))
4001a390: 90 10 20 00 clr %o0
4001a394: 7f ff e3 6f call 40013150 <rtems_rfs_trace>
4001a398: 13 08 00 00 sethi %hi(0x20000000), %o1
4001a39c: 80 a2 20 00 cmp %o0, 0
4001a3a0: 12 80 00 3e bne 4001a498 <rtems_rfs_dir_add_entry+0x10c>
<== NEVER TAKEN
4001a3a4: 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);
4001a3a8: 94 07 bf b0 add %fp, -80, %o2
4001a3ac: 7f ff fb 55 call 40019100 <rtems_rfs_block_map_open>
4001a3b0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a3b4: a0 92 20 00 orcc %o0, 0, %l0
4001a3b8: 24 80 00 04 ble,a 4001a3c8 <rtems_rfs_dir_add_entry+0x3c>
<== ALWAYS TAKEN
4001a3bc: c0 2f bf a4 clrb [ %fp + -92 ]
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001a3c0: 81 c7 e0 08 ret
4001a3c4: 91 e8 00 10 restore %g0, %l0, %o0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a3c8: 27 00 00 3f sethi %hi(0xfc00), %l3
handle->bnum = 0;
4001a3cc: c0 27 bf a8 clr [ %fp + -88 ]
4001a3d0: a6 14 e3 ff or %l3, 0x3ff, %l3
handle->buffer = NULL;
4001a3d4: c0 27 bf ac clr [ %fp + -84 ]
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001a3d8: a4 06 e0 0a add %i3, 0xa, %l2
bpos->bno = 0;
4001a3dc: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
4001a3e0: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
4001a3e4: c0 27 bf a0 clr [ %fp + -96 ]
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
4001a3e8: 96 07 bf 94 add %fp, -108, %o3
4001a3ec: 94 07 bf 98 add %fp, -104, %o2
4001a3f0: 92 07 bf b0 add %fp, -80, %o1
4001a3f4: 7f ff fc 15 call 40019448 <rtems_rfs_block_map_find>
4001a3f8: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a3fc: a0 92 20 00 orcc %o0, 0, %l0
4001a400: 04 80 00 88 ble 4001a620 <rtems_rfs_dir_add_entry+0x294>
4001a404: 80 a4 20 06 cmp %l0, 6
if (rc != ENXIO)
4001a408: 12 80 00 d9 bne 4001a76c <rtems_rfs_dir_add_entry+0x3e0>
<== NEVER TAKEN
4001a40c: 96 07 bf 94 add %fp, -108, %o3
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001a410: 94 10 20 01 mov 1, %o2
4001a414: 92 07 bf b0 add %fp, -80, %o1
4001a418: 7f ff fc 90 call 40019658 <rtems_rfs_block_map_grow>
4001a41c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a420: a0 92 20 00 orcc %o0, 0, %l0
4001a424: 14 80 00 c1 bg 4001a728 <rtems_rfs_dir_add_entry+0x39c>
<== NEVER TAKEN
4001a428: c2 07 bf 98 ld [ %fp + -104 ], %g1
bpos.bno++;
4001a42c: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001a430: d4 07 bf 94 ld [ %fp + -108 ], %o2
4001a434: 96 10 20 00 clr %o3
bpos.bno++;
4001a438: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001a43c: 92 07 bf a4 add %fp, -92, %o1
4001a440: 7f ff d5 22 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001a444: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a448: a0 92 20 00 orcc %o0, 0, %l0
4001a44c: 04 80 00 27 ble 4001a4e8 <rtems_rfs_dir_add_entry+0x15c>
<== ALWAYS TAKEN
4001a450: c2 07 bf ac ld [ %fp + -84 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001a454: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a458: 7f ff e3 3e call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a45c: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001a460: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a464: 32 80 00 a7 bne,a 4001a700 <rtems_rfs_dir_add_entry+0x374>
<== NOT EXECUTED
4001a468: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a46c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001a470: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001a474: 7f ff d5 dc call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001a478: 01 00 00 00 nop
rtems_rfs_block_map_close (fs, &map);
4001a47c: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001a480: c0 2f bf a4 clrb [ %fp + -92 ]
4001a484: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001a488: c0 27 bf a8 clr [ %fp + -88 ]
4001a48c: 7f ff fb 7c call 4001927c <rtems_rfs_block_map_close>
4001a490: c0 27 bf ac clr [ %fp + -84 ]
return rc;
4001a494: 30 bf ff cb b,a 4001a3c0 <rtems_rfs_dir_add_entry+0x34>
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
4001a498: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a49c: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a4a0: 7f ff e3 ba call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a4a4: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400239e0 <status_code_to_errno+0x4c4>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001a4a8: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4001a4ac: 02 80 00 09 be 4001a4d0 <rtems_rfs_dir_add_entry+0x144>
<== NOT EXECUTED
4001a4b0: a0 06 c0 1a add %i3, %i2, %l0
<== NOT EXECUTED
4001a4b4: ba 10 00 1a mov %i2, %i5
<== NOT EXECUTED
printf ("%c", name[c]);
4001a4b8: 7f ff e3 c9 call 400133dc <__wrap_putchar>
<== NOT EXECUTED
4001a4bc: d0 4f 40 00 ldsb [ %i5 ], %o0
<== NOT EXECUTED
4001a4c0: ba 07 60 01 inc %i5
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001a4c4: 80 a4 00 1d cmp %l0, %i5
<== NOT EXECUTED
4001a4c8: 12 bf ff fc bne 4001a4b8 <rtems_rfs_dir_add_entry+0x12c>
<== NOT EXECUTED
4001a4cc: 01 00 00 00 nop
<== NOT EXECUTED
printf (", len=%zd\n", length);
4001a4d0: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001a4d4: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a4d8: 7f ff e3 ac call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a4dc: 90 12 22 10 or %o0, 0x210, %o0 ! 40023a10 <status_code_to_errno+0x4f4>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001a4e0: 10 bf ff b2 b 4001a3a8 <rtems_rfs_dir_add_entry+0x1c>
<== NOT EXECUTED
4001a4e4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
entry = rtems_rfs_buffer_data (&buffer);
4001a4e8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
4001a4ec: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001a4f0: 92 10 20 ff mov 0xff, %o1
4001a4f4: 40 00 10 ce call 4001e82c <memset>
4001a4f8: 90 10 00 1d mov %i5, %o0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001a4fc: c8 06 20 08 ld [ %i0 + 8 ], %g4
4001a500: 86 81 3f f6 addcc %g4, -10, %g3
4001a504: 02 bf ff ba be 4001a3ec <rtems_rfs_dir_add_entry+0x60>
<== NEVER TAKEN
4001a508: 96 07 bf 94 add %fp, -108, %o3
elength = rtems_rfs_dir_entry_length (entry);
4001a50c: d4 0f 60 08 ldub [ %i5 + 8 ], %o2
4001a510: e0 0f 60 09 ldub [ %i5 + 9 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001a514: c4 0f 40 00 ldub [ %i5 ], %g2
4001a518: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001a51c: e2 0f 60 02 ldub [ %i5 + 2 ], %l1
4001a520: d6 0f 60 03 ldub [ %i5 + 3 ], %o3
elength = rtems_rfs_dir_entry_length (entry);
4001a524: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001a528: 85 28 a0 18 sll %g2, 0x18, %g2
elength = rtems_rfs_dir_entry_length (entry);
4001a52c: a0 14 00 0a or %l0, %o2, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001a530: 83 28 60 10 sll %g1, 0x10, %g1
4001a534: a3 2c 60 08 sll %l1, 8, %l1
4001a538: 82 10 40 02 or %g1, %g2, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a53c: 80 a4 00 13 cmp %l0, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001a540: a2 14 40 01 or %l1, %g1, %l1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a544: 02 80 00 4d be 4001a678 <rtems_rfs_dir_add_entry+0x2ec>
4001a548: a2 12 c0 11 or %o3, %l1, %l1
offset = 0;
4001a54c: 10 80 00 1f b 4001a5c8 <rtems_rfs_dir_add_entry+0x23c>
4001a550: a8 10 20 00 clr %l4
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001a554: 80 a0 40 10 cmp %g1, %l0
4001a558: 08 80 00 1f bleu 4001a5d4 <rtems_rfs_dir_add_entry+0x248>
<== NEVER TAKEN
4001a55c: 80 a4 60 00 cmp %l1, 0
4001a560: 02 80 00 1e be 4001a5d8 <rtems_rfs_dir_add_entry+0x24c>
<== NEVER TAKEN
4001a564: 90 10 20 00 clr %o0
4001a568: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001a56c: 80 a0 40 11 cmp %g1, %l1
4001a570: 0a 80 00 1a bcs 4001a5d8 <rtems_rfs_dir_add_entry+0x24c>
<== NEVER TAKEN
4001a574: 01 00 00 00 nop
offset += elength;
4001a578: a8 05 00 10 add %l4, %l0, %l4
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001a57c: 80 a0 c0 14 cmp %g3, %l4
4001a580: 08 bf ff 9a bleu 4001a3e8 <rtems_rfs_dir_add_entry+0x5c>
<== NEVER TAKEN
4001a584: ba 07 40 10 add %i5, %l0, %i5
elength = rtems_rfs_dir_entry_length (entry);
4001a588: d4 0f 60 08 ldub [ %i5 + 8 ], %o2
4001a58c: e0 0f 60 09 ldub [ %i5 + 9 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001a590: c4 0f 40 00 ldub [ %i5 ], %g2
4001a594: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001a598: d6 0f 60 02 ldub [ %i5 + 2 ], %o3
4001a59c: e2 0f 60 03 ldub [ %i5 + 3 ], %l1
elength = rtems_rfs_dir_entry_length (entry);
4001a5a0: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001a5a4: 85 28 a0 18 sll %g2, 0x18, %g2
elength = rtems_rfs_dir_entry_length (entry);
4001a5a8: a0 14 00 0a or %l0, %o2, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001a5ac: 83 28 60 10 sll %g1, 0x10, %g1
4001a5b0: 97 2a e0 08 sll %o3, 8, %o3
4001a5b4: 82 10 40 02 or %g1, %g2, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a5b8: 80 a4 00 13 cmp %l0, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001a5bc: 96 12 c0 01 or %o3, %g1, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a5c0: 02 80 00 2d be 4001a674 <rtems_rfs_dir_add_entry+0x2e8>
4001a5c4: a2 14 40 0b or %l1, %o3, %l1
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001a5c8: 80 a4 20 0a cmp %l0, 0xa
4001a5cc: 34 bf ff e2 bg,a 4001a554 <rtems_rfs_dir_add_entry+0x1c8>
<== ALWAYS TAKEN
4001a5d0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001a5d4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a5d8: 7f ff e2 de call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a5dc: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001a5e0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a5e4: 32 80 00 1c bne,a 4001a654 <rtems_rfs_dir_add_entry+0x2c8>
<== NOT EXECUTED
4001a5e8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a5ec: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001a5f0: 7f ff d5 7d call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001a5f4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001a5f8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001a5fc: c0 2f bf a4 clrb [ %fp + -92 ]
<== NOT EXECUTED
4001a600: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001a604: c0 27 bf a8 clr [ %fp + -88 ]
<== NOT EXECUTED
return EIO;
4001a608: a0 10 20 05 mov 5, %l0
<== NOT EXECUTED
handle->buffer = NULL;
4001a60c: c0 27 bf ac clr [ %fp + -84 ]
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001a610: 7f ff fb 1b call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001a614: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
}
4001a618: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a61c: 81 e8 00 00 restore
<== NOT EXECUTED
bpos.bno++;
4001a620: c2 07 bf 98 ld [ %fp + -104 ], %g1
4001a624: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001a628: d4 07 bf 94 ld [ %fp + -108 ], %o2
4001a62c: 96 10 20 01 mov 1, %o3
bpos.bno++;
4001a630: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001a634: 92 07 bf a4 add %fp, -92, %o1
4001a638: 7f ff d4 a4 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001a63c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a640: a0 92 20 00 orcc %o0, 0, %l0
4001a644: 14 bf ff 84 bg 4001a454 <rtems_rfs_dir_add_entry+0xc8>
<== NEVER TAKEN
4001a648: c2 07 bf ac ld [ %fp + -84 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
4001a64c: 10 bf ff ac b 4001a4fc <rtems_rfs_dir_add_entry+0x170>
4001a650: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
printf ("rtems-rfs: dir-add-entry: "
4001a654: 98 10 00 14 mov %l4, %o4
<== NOT EXECUTED
4001a658: 96 10 00 11 mov %l1, %o3
<== NOT EXECUTED
4001a65c: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001a660: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a664: 7f ff e3 49 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a668: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 40023af8 <status_code_to_errno+0x5dc>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a66c: 10 bf ff e1 b 4001a5f0 <rtems_rfs_dir_add_entry+0x264>
<== NOT EXECUTED
4001a670: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001a674: 88 21 00 14 sub %g4, %l4, %g4
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001a678: 80 a4 80 04 cmp %l2, %g4
4001a67c: 1a bf ff 5c bcc 4001a3ec <rtems_rfs_dir_add_entry+0x60>
<== NEVER TAKEN
4001a680: 96 07 bf 94 add %fp, -108, %o3
hash = rtems_rfs_dir_hash (name, length);
4001a684: 92 10 00 1b mov %i3, %o1
4001a688: 40 00 0f 0c call 4001e2b8 <rtems_rfs_dir_hash>
4001a68c: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
4001a690: 87 32 20 18 srl %o0, 0x18, %g3
4001a694: 85 32 20 10 srl %o0, 0x10, %g2
4001a698: 83 32 20 08 srl %o0, 8, %g1
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a69c: 89 37 20 18 srl %i4, 0x18, %g4
rtems_rfs_dir_set_entry_hash (entry, hash);
4001a6a0: c6 2f 60 04 stb %g3, [ %i5 + 4 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a6a4: 87 37 20 10 srl %i4, 0x10, %g3
rtems_rfs_dir_set_entry_hash (entry, hash);
4001a6a8: c4 2f 60 05 stb %g2, [ %i5 + 5 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a6ac: 85 37 20 08 srl %i4, 8, %g2
rtems_rfs_dir_set_entry_hash (entry, hash);
4001a6b0: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_length (entry,
4001a6b4: 83 2c a0 10 sll %l2, 0x10, %g1
rtems_rfs_dir_set_entry_hash (entry, hash);
4001a6b8: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_length (entry,
4001a6bc: 83 30 60 18 srl %g1, 0x18, %g1
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a6c0: c8 2f 40 00 stb %g4, [ %i5 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001a6c4: 92 10 00 1a mov %i2, %o1
rtems_rfs_dir_set_entry_length (entry,
4001a6c8: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001a6cc: 94 10 00 1b mov %i3, %o2
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a6d0: c6 2f 60 01 stb %g3, [ %i5 + 1 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001a6d4: 90 07 60 0a add %i5, 0xa, %o0
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a6d8: c4 2f 60 02 stb %g2, [ %i5 + 2 ]
return 0;
4001a6dc: a0 10 20 00 clr %l0
rtems_rfs_dir_set_entry_ino (entry, ino);
4001a6e0: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001a6e4: 40 00 0f c8 call 4001e604 <memcpy>
4001a6e8: e4 2f 60 09 stb %l2, [ %i5 + 9 ]
rtems_rfs_buffer_mark_dirty (&buffer);
4001a6ec: 82 10 20 01 mov 1, %g1
4001a6f0: 92 07 bf a4 add %fp, -92, %o1
4001a6f4: 90 10 00 18 mov %i0, %o0
4001a6f8: 10 bf ff 5f b 4001a474 <rtems_rfs_dir_add_entry+0xe8>
4001a6fc: c2 2f bf a4 stb %g1, [ %fp + -92 ]
printf ("rtems-rfs: dir-add-entry: "
4001a700: 40 00 13 68 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a704: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4001a708: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001a70c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001a710: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001a714: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a718: 7f ff e3 1c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a71c: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40023ab0 <status_code_to_errno+0x594>
<== NOT EXECUTED
4001a720: 10 bf ff 54 b 4001a470 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001a724: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001a728: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a72c: 7f ff e2 89 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a730: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001a734: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a738: 22 bf ff 4e be,a 4001a470 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001a73c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001a740: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001a744: 40 00 13 57 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a748: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4001a74c: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001a750: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001a754: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001a758: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a75c: 7f ff e3 0b call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a760: 90 12 22 68 or %o0, 0x268, %o0 ! 40023a68 <status_code_to_errno+0x54c>
<== NOT EXECUTED
4001a764: 10 bf ff 43 b 4001a470 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001a768: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001a76c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a770: 7f ff e2 78 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a774: 13 08 00 00 sethi %hi(0x20000000), %o1
<== NOT EXECUTED
4001a778: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a77c: 22 bf ff 3d be,a 4001a470 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001a780: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001a784: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001a788: 40 00 13 46 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a78c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4001a790: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
4001a794: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001a798: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001a79c: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a7a0: 7f ff e2 fa call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a7a4: 90 12 22 20 or %o0, 0x220, %o0 ! 40023a20 <status_code_to_errno+0x504>
<== NOT EXECUTED
4001a7a8: 10 bf ff 32 b 4001a470 <rtems_rfs_dir_add_entry+0xe4>
<== NOT EXECUTED
4001a7ac: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001a7b0 <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)
{
4001a7b0: 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))
4001a7b4: 90 10 20 00 clr %o0
4001a7b8: 7f ff e2 66 call 40013150 <rtems_rfs_trace>
4001a7bc: 13 10 00 00 sethi %hi(0x40000000), %o1
4001a7c0: 80 a2 20 00 cmp %o0, 0
4001a7c4: 12 80 00 0a bne 4001a7ec <rtems_rfs_dir_del_entry+0x3c>
<== NEVER TAKEN
4001a7c8: 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);
4001a7cc: 94 07 bf b0 add %fp, -80, %o2
4001a7d0: 7f ff fa 4c call 40019100 <rtems_rfs_block_map_open>
4001a7d4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a7d8: a4 92 20 00 orcc %o0, 0, %l2
4001a7dc: 04 80 00 11 ble 4001a820 <rtems_rfs_dir_del_entry+0x70>
<== ALWAYS TAKEN
4001a7e0: 94 10 20 00 clr %o2
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001a7e4: 81 c7 e0 08 ret
4001a7e8: 91 e8 00 12 restore %g0, %l2, %o0
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
4001a7ec: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a7f0: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4001a7f4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001a7f8: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a7fc: 7f ff e2 e3 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a800: 90 12 23 40 or %o0, 0x340, %o0 ! 40023b40 <status_code_to_errno+0x624>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001a804: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001a808: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001a80c: 7f ff fa 3d call 40019100 <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001a810: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001a814: a4 92 20 00 orcc %o0, 0, %l2
<== NOT EXECUTED
4001a818: 14 bf ff f3 bg 4001a7e4 <rtems_rfs_dir_del_entry+0x34>
<== NOT EXECUTED
4001a81c: 94 10 20 00 clr %o2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001a820: 98 07 bf a0 add %fp, -96, %o4
4001a824: 96 10 00 1b mov %i3, %o3
4001a828: 92 07 bf b0 add %fp, -80, %o1
4001a82c: 7f ff fb 60 call 400195ac <rtems_rfs_block_map_seek>
4001a830: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a834: a4 92 20 00 orcc %o0, 0, %l2
4001a838: 04 80 00 0a ble 4001a860 <rtems_rfs_dir_del_entry+0xb0>
<== ALWAYS TAKEN
4001a83c: 80 a4 a0 06 cmp %l2, 6
if (rc == ENXIO)
4001a840: 22 80 00 02 be,a 4001a848 <rtems_rfs_dir_del_entry+0x98>
<== NOT EXECUTED
4001a844: a4 10 20 02 mov 2, %l2
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001a848: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001a84c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001a850: 7f ff fa 8b call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001a854: b0 10 00 12 mov %l2, %i0
<== NOT EXECUTED
}
4001a858: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a85c: 81 e8 00 00 restore
<== NOT EXECUTED
handle->dirty = false;
4001a860: c0 2f bf a4 clrb [ %fp + -92 ]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a864: 27 00 00 3f sethi %hi(0xfc00), %l3
handle->bnum = 0;
4001a868: c0 27 bf a8 clr [ %fp + -88 ]
4001a86c: a6 14 e3 ff or %l3, 0x3ff, %l3
handle->buffer = NULL;
4001a870: c0 27 bf ac clr [ %fp + -84 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001a874: 96 10 20 01 mov 1, %o3
4001a878: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001a87c: 92 07 bf a4 add %fp, -92, %o1
4001a880: 7f ff d4 12 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001a884: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001a888: a4 92 20 00 orcc %o0, 0, %l2
4001a88c: 14 80 00 c5 bg 4001aba0 <rtems_rfs_dir_del_entry+0x3f0>
<== NEVER TAKEN
4001a890: 80 a6 e0 00 cmp %i3, 0
if (search)
4001a894: 02 80 00 46 be 4001a9ac <rtems_rfs_dir_del_entry+0x1fc>
<== NEVER TAKEN
4001a898: c8 06 20 08 ld [ %i0 + 8 ], %g4
eoffset = offset % rtems_rfs_fs_block_size (fs);
4001a89c: 81 80 20 00 wr %g0, %y
4001a8a0: 01 00 00 00 nop
4001a8a4: 01 00 00 00 nop
4001a8a8: 01 00 00 00 nop
4001a8ac: 82 76 c0 04 udiv %i3, %g4, %g1
4001a8b0: 82 58 40 04 smul %g1, %g4, %g1
4001a8b4: 82 26 c0 01 sub %i3, %g1, %g1
4001a8b8: a2 10 00 01 mov %g1, %l1
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001a8bc: c4 07 bf ac ld [ %fp + -84 ], %g2
4001a8c0: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001a8c4: 9e 01 3f f6 add %g4, -10, %o7
4001a8c8: 80 a3 c0 01 cmp %o7, %g1
4001a8cc: 08 80 00 2b bleu 4001a978 <rtems_rfs_dir_del_entry+0x1c8>
<== NEVER TAKEN
4001a8d0: ba 00 80 01 add %g2, %g1, %i5
elength = rtems_rfs_dir_entry_length (entry);
4001a8d4: c6 0f 60 08 ldub [ %i5 + 8 ], %g3
4001a8d8: f8 0f 60 09 ldub [ %i5 + 9 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001a8dc: 10 80 00 1a b 4001a944 <rtems_rfs_dir_del_entry+0x194>
4001a8e0: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001a8e4: 80 a7 20 0a cmp %i4, 0xa
4001a8e8: 04 80 00 34 ble 4001a9b8 <rtems_rfs_dir_del_entry+0x208>
<== NEVER TAKEN
4001a8ec: 90 10 20 00 clr %o0
4001a8f0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001a8f4: 80 a0 40 1c cmp %g1, %i4
4001a8f8: 08 80 00 30 bleu 4001a9b8 <rtems_rfs_dir_del_entry+0x208>
<== NEVER TAKEN
4001a8fc: 80 a4 20 00 cmp %l0, 0
4001a900: 02 80 00 2f be 4001a9bc <rtems_rfs_dir_del_entry+0x20c>
<== NEVER TAKEN
4001a904: 13 10 00 00 sethi %hi(0x40000000), %o1
4001a908: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001a90c: 80 a0 40 10 cmp %g1, %l0
4001a910: 0a 80 00 2a bcs 4001a9b8 <rtems_rfs_dir_del_entry+0x208>
<== NEVER TAKEN
4001a914: 80 a6 80 10 cmp %i2, %l0
if (ino == rtems_rfs_dir_entry_ino (entry))
4001a918: 02 80 00 43 be 4001aa24 <rtems_rfs_dir_del_entry+0x274>
<== ALWAYS TAKEN
4001a91c: 80 a6 e0 00 cmp %i3, 0
if (!search)
4001a920: 32 80 00 19 bne,a 4001a984 <rtems_rfs_dir_del_entry+0x1d4>
<== NOT EXECUTED
4001a924: a4 10 20 05 mov 5, %l2
<== NOT EXECUTED
eoffset += elength;
4001a928: a2 04 40 1c add %l1, %i4, %l1
<== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001a92c: 80 a4 40 0f cmp %l1, %o7
<== NOT EXECUTED
4001a930: 1a 80 00 12 bcc 4001a978 <rtems_rfs_dir_del_entry+0x1c8>
<== NOT EXECUTED
4001a934: ba 07 40 1c add %i5, %i4, %i5
<== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
4001a938: c6 0f 60 08 ldub [ %i5 + 8 ], %g3
<== NOT EXECUTED
4001a93c: f8 0f 60 09 ldub [ %i5 + 9 ], %i4
<== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001a940: c4 0f 40 00 ldub [ %i5 ], %g2
<== NOT EXECUTED
4001a944: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4001a948: d6 0f 60 02 ldub [ %i5 + 2 ], %o3
4001a94c: e0 0f 60 03 ldub [ %i5 + 3 ], %l0
elength = rtems_rfs_dir_entry_length (entry);
4001a950: 87 28 e0 08 sll %g3, 8, %g3
eino = rtems_rfs_dir_entry_ino (entry);
4001a954: 85 28 a0 18 sll %g2, 0x18, %g2
elength = rtems_rfs_dir_entry_length (entry);
4001a958: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001a95c: 83 28 60 10 sll %g1, 0x10, %g1
4001a960: 97 2a e0 08 sll %o3, 8, %o3
4001a964: 82 10 40 02 or %g1, %g2, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a968: 80 a7 00 13 cmp %i4, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001a96c: 96 12 c0 01 or %o3, %g1, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a970: 12 bf ff dd bne 4001a8e4 <rtems_rfs_dir_del_entry+0x134>
<== ALWAYS TAKEN
4001a974: a0 14 00 0b or %l0, %o3, %l0
if (rc == 0)
4001a978: 80 a4 a0 00 cmp %l2, 0
<== NOT EXECUTED
4001a97c: 02 80 00 1f be 4001a9f8 <rtems_rfs_dir_del_entry+0x248>
<== NOT EXECUTED
4001a980: 94 07 bf a0 add %fp, -96, %o2
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a984: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001a988: 7f ff d4 97 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001a98c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001a990: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001a994: c0 2f bf a4 clrb [ %fp + -92 ]
<== NOT EXECUTED
4001a998: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001a99c: c0 27 bf a8 clr [ %fp + -88 ]
<== NOT EXECUTED
4001a9a0: 7f ff fa 37 call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001a9a4: c0 27 bf ac clr [ %fp + -84 ]
<== NOT EXECUTED
return rc;
4001a9a8: 30 bf ff 8f b,a 4001a7e4 <rtems_rfs_dir_del_entry+0x34>
<== NOT EXECUTED
4001a9ac: 82 10 20 00 clr %g1
<== NOT EXECUTED
eoffset = 0;
4001a9b0: 10 bf ff c3 b 4001a8bc <rtems_rfs_dir_del_entry+0x10c>
<== NOT EXECUTED
4001a9b4: a2 10 20 00 clr %l1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001a9b8: 13 10 00 00 sethi %hi(0x40000000), %o1
<== NOT EXECUTED
4001a9bc: 7f ff e1 e5 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a9c0: a4 10 20 05 mov 5, %l2
<== NOT EXECUTED
4001a9c4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a9c8: 22 bf ff f0 be,a 4001a988 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001a9cc: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001a9d0: d8 07 bf a0 ld [ %fp + -96 ], %o4
<== NOT EXECUTED
4001a9d4: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a9d8: 9a 10 00 11 mov %l1, %o5
<== NOT EXECUTED
4001a9dc: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
4001a9e0: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001a9e4: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a9e8: 7f ff e2 68 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a9ec: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40023bc8 <status_code_to_errno+0x6ac>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a9f0: 10 bf ff e6 b 4001a988 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001a9f4: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001a9f8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001a9fc: 7f ff fb 0a call 40019624 <rtems_rfs_block_map_next_block>
<== NOT EXECUTED
4001aa00: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc == ENXIO)
4001aa04: 80 a2 20 06 cmp %o0, 6
<== NOT EXECUTED
4001aa08: 02 80 00 77 be 4001abe4 <rtems_rfs_dir_del_entry+0x434>
<== NOT EXECUTED
4001aa0c: a4 10 00 08 mov %o0, %l2
<== NOT EXECUTED
while (rc == 0)
4001aa10: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001aa14: 02 bf ff 99 be 4001a878 <rtems_rfs_dir_del_entry+0xc8>
<== NOT EXECUTED
4001aa18: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
4001aa1c: 10 bf ff db b 4001a988 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001aa20: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
memmove (entry, entry + elength, remaining);
4001aa24: 92 07 40 1c add %i5, %i4, %o1
4001aa28: 90 10 00 1d mov %i5, %o0
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001aa2c: b6 04 40 1c add %l1, %i4, %i3
4001aa30: b6 21 00 1b sub %g4, %i3, %i3
memmove (entry, entry + elength, remaining);
4001aa34: 40 00 0f 30 call 4001e6f4 <memmove>
4001aa38: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
4001aa3c: 94 10 00 1c mov %i4, %o2
4001aa40: 92 10 20 ff mov 0xff, %o1
4001aa44: 40 00 0f 7a call 4001e82c <memset>
4001aa48: 90 07 40 1b add %i5, %i3, %o0
elength = rtems_rfs_dir_entry_length (entry);
4001aa4c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
4001aa50: 83 28 60 08 sll %g1, 8, %g1
4001aa54: fa 0f 60 09 ldub [ %i5 + 9 ], %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001aa58: 90 10 20 00 clr %o0
4001aa5c: 13 10 00 00 sethi %hi(0x40000000), %o1
4001aa60: 7f ff e1 bc call 40013150 <rtems_rfs_trace>
4001aa64: ba 17 40 01 or %i5, %g1, %i5
4001aa68: 80 a2 20 00 cmp %o0, 0
4001aa6c: 22 80 00 17 be,a 4001aac8 <rtems_rfs_dir_del_entry+0x318>
<== ALWAYS TAKEN
4001aa70: 03 3f ff c0 sethi %hi(0xffff0000), %g1
rtems_rfs_block_map_last (&map) ? "yes" : "no");
4001aa74: c4 07 bf c0 ld [ %fp + -64 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001aa78: d6 07 bf a0 ld [ %fp + -96 ], %o3
<== NOT EXECUTED
4001aa7c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001aa80: 12 80 00 05 bne 4001aa94 <rtems_rfs_dir_del_entry+0x2e4>
<== NOT EXECUTED
4001aa84: c2 07 bf b8 ld [ %fp + -72 ], %g1
<== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
4001aa88: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001aa8c: 02 80 00 3d be 4001ab80 <rtems_rfs_dir_del_entry+0x3d0>
<== NOT EXECUTED
4001aa90: 1b 10 00 8b sethi %hi(0x40022c00), %o5
<== NOT EXECUTED
4001aa94: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001aa98: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001aa9c: 02 80 00 39 be 4001ab80 <rtems_rfs_dir_del_entry+0x3d0>
<== NOT EXECUTED
4001aaa0: 1b 10 00 8b sethi %hi(0x40022c00), %o5
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001aaa4: 1b 10 00 8b sethi %hi(0x40022c00), %o5
<== NOT EXECUTED
4001aaa8: 9a 13 60 a0 or %o5, 0xa0, %o5 ! 40022ca0 <ramdisk_ops+0xf88>
<== NOT EXECUTED
4001aaac: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001aab0: 98 10 00 11 mov %l1, %o4
<== NOT EXECUTED
4001aab4: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001aab8: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001aabc: 7f ff e2 33 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001aac0: 90 12 20 18 or %o0, 0x18, %o0
<== NOT EXECUTED
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
4001aac4: 03 3f ff c0 sethi %hi(0xffff0000), %g1
<== NOT EXECUTED
4001aac8: ba 38 40 1d xnor %g1, %i5, %i5
4001aacc: 80 a7 60 00 cmp %i5, 0
4001aad0: 12 80 00 1f bne 4001ab4c <rtems_rfs_dir_del_entry+0x39c>
4001aad4: 80 a4 60 00 cmp %l1, 0
4001aad8: 12 80 00 1d bne 4001ab4c <rtems_rfs_dir_del_entry+0x39c>
<== ALWAYS TAKEN
4001aadc: c4 07 bf c0 ld [ %fp + -64 ], %g2
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001aae0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001aae4: 12 80 00 29 bne 4001ab88 <rtems_rfs_dir_del_entry+0x3d8>
<== NOT EXECUTED
4001aae8: c2 07 bf b8 ld [ %fp + -72 ], %g1
<== NOT EXECUTED
4001aaec: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001aaf0: 12 80 00 27 bne 4001ab8c <rtems_rfs_dir_del_entry+0x3dc>
<== NOT EXECUTED
4001aaf4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001aaf8: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4001aafc: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001ab00: 7f ff fb d3 call 40019a4c <rtems_rfs_block_map_shrink>
<== NOT EXECUTED
4001ab04: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001ab08: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001ab0c: 04 80 00 10 ble 4001ab4c <rtems_rfs_dir_del_entry+0x39c>
<== NOT EXECUTED
4001ab10: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001ab14: 7f ff e1 8f call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001ab18: 13 10 00 00 sethi %hi(0x40000000), %o1
<== NOT EXECUTED
4001ab1c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ab20: 02 80 00 0c be 4001ab50 <rtems_rfs_dir_del_entry+0x3a0>
<== NOT EXECUTED
4001ab24: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001ab28: f8 06 60 08 ld [ %i1 + 8 ], %i4
<== NOT EXECUTED
4001ab2c: 40 00 12 5d call 4001f4a0 <strerror>
<== NOT EXECUTED
4001ab30: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001ab34: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001ab38: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001ab3c: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001ab40: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001ab44: 7f ff e2 11 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001ab48: 90 12 20 78 or %o0, 0x78, %o0 ! 40023c78 <status_code_to_errno+0x75c>
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
4001ab4c: 82 10 20 01 mov 1, %g1
4001ab50: 92 07 bf a4 add %fp, -92, %o1
4001ab54: 90 10 00 18 mov %i0, %o0
4001ab58: 7f ff d4 23 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001ab5c: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_block_map_close (fs, &map);
4001ab60: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001ab64: c0 2f bf a4 clrb [ %fp + -92 ]
4001ab68: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001ab6c: c0 27 bf a8 clr [ %fp + -88 ]
return 0;
4001ab70: a4 10 20 00 clr %l2
rtems_rfs_block_map_close (fs, &map);
4001ab74: 7f ff f9 c2 call 4001927c <rtems_rfs_block_map_close>
4001ab78: c0 27 bf ac clr [ %fp + -84 ]
return 0;
4001ab7c: 30 bf ff 1a b,a 4001a7e4 <rtems_rfs_dir_del_entry+0x34>
printf ("rtems-rfs: dir-del-entry: "
4001ab80: 10 bf ff cb b 4001aaac <rtems_rfs_dir_del_entry+0x2fc>
<== NOT EXECUTED
4001ab84: 9a 13 60 98 or %o5, 0x98, %o5
<== NOT EXECUTED
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001ab88: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001ab8c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001ab90: 12 bf ff f0 bne 4001ab50 <rtems_rfs_dir_del_entry+0x3a0>
<== NOT EXECUTED
4001ab94: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001ab98: 10 bf ff d9 b 4001aafc <rtems_rfs_dir_del_entry+0x34c>
<== NOT EXECUTED
4001ab9c: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001aba0: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001aba4: 7f ff e1 6b call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001aba8: 13 10 00 00 sethi %hi(0x40000000), %o1
<== NOT EXECUTED
4001abac: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001abb0: 22 bf ff 76 be,a 4001a988 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001abb4: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001abb8: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001abbc: 40 00 12 39 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001abc0: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
4001abc4: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001abc8: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001abcc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001abd0: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001abd4: 7f ff e1 ed call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001abd8: 90 12 23 80 or %o0, 0x380, %o0 ! 40023b80 <status_code_to_errno+0x664>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001abdc: 10 bf ff 6b b 4001a988 <rtems_rfs_dir_del_entry+0x1d8>
<== NOT EXECUTED
4001abe0: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = ENOENT;
4001abe4: 10 bf ff 68 b 4001a984 <rtems_rfs_dir_del_entry+0x1d4>
<== NOT EXECUTED
4001abe8: a4 10 20 02 mov 2, %l2
<== NOT EXECUTED
4001afac <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
4001afac: 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))
4001afb0: 90 10 20 00 clr %o0
4001afb4: 7f ff e0 67 call 40013150 <rtems_rfs_trace>
4001afb8: 13 20 00 00 sethi %hi(0x80000000), %o1
4001afbc: 80 a2 20 00 cmp %o0, 0
4001afc0: 12 80 00 0a bne 4001afe8 <rtems_rfs_dir_empty+0x3c>
<== NEVER TAKEN
4001afc4: 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);
4001afc8: 94 07 bf b0 add %fp, -80, %o2
4001afcc: 7f ff f8 4d call 40019100 <rtems_rfs_block_map_open>
4001afd0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001afd4: a4 92 20 00 orcc %o0, 0, %l2
4001afd8: 04 80 00 0f ble 4001b014 <rtems_rfs_dir_empty+0x68>
<== ALWAYS TAKEN
4001afdc: 94 10 20 00 clr %o2
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001afe0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001afe4: 91 e8 00 12 restore %g0, %l2, %o0
<== NOT EXECUTED
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
4001afe8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001afec: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001aff0: 7f ff e0 e6 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001aff4: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 40023da8 <status_code_to_errno+0x88c>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001aff8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001affc: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001b000: 7f ff f8 40 call 40019100 <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001b004: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001b008: a4 92 20 00 orcc %o0, 0, %l2
<== NOT EXECUTED
4001b00c: 14 bf ff f5 bg 4001afe0 <rtems_rfs_dir_empty+0x34>
<== NOT EXECUTED
4001b010: 94 10 20 00 clr %o2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001b014: 96 10 20 00 clr %o3
4001b018: 98 07 bf a0 add %fp, -96, %o4
4001b01c: 92 07 bf b0 add %fp, -80, %o1
4001b020: 7f ff f9 63 call 400195ac <rtems_rfs_block_map_seek>
4001b024: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b028: a4 92 20 00 orcc %o0, 0, %l2
4001b02c: 14 80 00 67 bg 4001b1c8 <rtems_rfs_dir_empty+0x21c>
<== NEVER TAKEN
4001b030: 23 00 00 3f sethi %hi(0xfc00), %l1
handle->dirty = false;
4001b034: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001b038: c0 27 bf a8 clr [ %fp + -88 ]
printf ("rtems-rfs: dir-empty: "
4001b03c: 21 10 00 8f sethi %hi(0x40023c00), %l0
handle->buffer = NULL;
4001b040: c0 27 bf ac clr [ %fp + -84 ]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b044: a2 14 63 ff or %l1, 0x3ff, %l1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001b048: b4 10 20 01 mov 1, %i2
4001b04c: b6 10 20 00 clr %i3
printf ("rtems-rfs: dir-empty: "
4001b050: a0 14 21 c8 or %l0, 0x1c8, %l0
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001b054: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001b058: 96 10 20 01 mov 1, %o3
4001b05c: 92 07 bf a4 add %fp, -92, %o1
4001b060: 7f ff d2 1a call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001b064: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b068: a4 92 20 00 orcc %o0, 0, %l2
4001b06c: 14 80 00 4b bg 4001b198 <rtems_rfs_dir_empty+0x1ec>
<== NEVER TAKEN
4001b070: c2 07 bf ac ld [ %fp + -84 ], %g1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001b074: c8 06 20 08 ld [ %i0 + 8 ], %g4
4001b078: 88 81 3f f6 addcc %g4, -10, %g4
4001b07c: 02 80 00 63 be 4001b208 <rtems_rfs_dir_empty+0x25c>
<== NEVER TAKEN
4001b080: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
elength = rtems_rfs_dir_entry_length (entry);
4001b084: d4 08 60 08 ldub [ %g1 + 8 ], %o2
4001b088: fa 08 60 09 ldub [ %g1 + 9 ], %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001b08c: c6 08 40 00 ldub [ %g1 ], %g3
4001b090: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001b094: f8 08 60 02 ldub [ %g1 + 2 ], %i4
4001b098: d6 08 60 03 ldub [ %g1 + 3 ], %o3
elength = rtems_rfs_dir_entry_length (entry);
4001b09c: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001b0a0: 87 28 e0 18 sll %g3, 0x18, %g3
elength = rtems_rfs_dir_entry_length (entry);
4001b0a4: ba 17 40 0a or %i5, %o2, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001b0a8: 85 28 a0 10 sll %g2, 0x10, %g2
4001b0ac: b9 2f 20 08 sll %i4, 8, %i4
4001b0b0: 84 10 80 03 or %g2, %g3, %g2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b0b4: 80 a7 40 11 cmp %i5, %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001b0b8: b8 17 00 02 or %i4, %g2, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b0bc: 02 80 00 53 be 4001b208 <rtems_rfs_dir_empty+0x25c>
<== NEVER TAKEN
4001b0c0: b8 12 c0 1c or %o3, %i4, %i4
offset = 0;
4001b0c4: 10 80 00 20 b 4001b144 <rtems_rfs_dir_empty+0x198>
4001b0c8: a6 10 20 00 clr %l3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
4001b0cc: 12 80 00 31 bne 4001b190 <rtems_rfs_dir_empty+0x1e4>
4001b0d0: 80 a4 a0 00 cmp %l2, 0
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
4001b0d4: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001b0d8: 80 a0 a0 2e cmp %g2, 0x2e
4001b0dc: 12 80 00 2d bne 4001b190 <rtems_rfs_dir_empty+0x1e4>
<== NEVER TAKEN
4001b0e0: 80 a4 a0 00 cmp %l2, 0
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001b0e4: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
4001b0e8: 80 a0 a0 2e cmp %g2, 0x2e
4001b0ec: 12 80 00 29 bne 4001b190 <rtems_rfs_dir_empty+0x1e4>
<== NEVER TAKEN
4001b0f0: 80 a4 a0 00 cmp %l2, 0
offset += elength;
4001b0f4: a6 04 c0 1d add %l3, %i5, %l3
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001b0f8: 80 a4 c0 04 cmp %l3, %g4
4001b0fc: 1a 80 00 43 bcc 4001b208 <rtems_rfs_dir_empty+0x25c>
<== NEVER TAKEN
4001b100: 82 00 40 1d add %g1, %i5, %g1
elength = rtems_rfs_dir_entry_length (entry);
4001b104: d4 08 60 08 ldub [ %g1 + 8 ], %o2
4001b108: fa 08 60 09 ldub [ %g1 + 9 ], %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001b10c: c6 08 40 00 ldub [ %g1 ], %g3
4001b110: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001b114: d6 08 60 02 ldub [ %g1 + 2 ], %o3
4001b118: f8 08 60 03 ldub [ %g1 + 3 ], %i4
elength = rtems_rfs_dir_entry_length (entry);
4001b11c: 95 2a a0 08 sll %o2, 8, %o2
eino = rtems_rfs_dir_entry_ino (entry);
4001b120: 87 28 e0 18 sll %g3, 0x18, %g3
elength = rtems_rfs_dir_entry_length (entry);
4001b124: ba 17 40 0a or %i5, %o2, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001b128: 85 28 a0 10 sll %g2, 0x10, %g2
4001b12c: 97 2a e0 08 sll %o3, 8, %o3
4001b130: 84 10 80 03 or %g2, %g3, %g2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b134: 80 a7 40 11 cmp %i5, %l1
eino = rtems_rfs_dir_entry_ino (entry);
4001b138: 96 12 c0 02 or %o3, %g2, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001b13c: 02 80 00 33 be 4001b208 <rtems_rfs_dir_empty+0x25c>
4001b140: b8 17 00 0b or %i4, %o3, %i4
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001b144: 80 a7 60 0a cmp %i5, 0xa
4001b148: 04 80 00 26 ble 4001b1e0 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001b14c: 90 10 00 1a mov %i2, %o0
4001b150: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4001b154: 80 a0 80 1d cmp %g2, %i5
4001b158: 08 80 00 22 bleu 4001b1e0 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001b15c: 80 a7 20 00 cmp %i4, 0
4001b160: 02 80 00 20 be 4001b1e0 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001b164: 01 00 00 00 nop
4001b168: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4001b16c: 80 a0 80 1c cmp %g2, %i4
4001b170: 0a 80 00 1c bcs 4001b1e0 <rtems_rfs_dir_empty+0x234>
<== NEVER TAKEN
4001b174: 80 a7 60 0b cmp %i5, 0xb
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
4001b178: 12 bf ff d5 bne 4001b0cc <rtems_rfs_dir_empty+0x120>
4001b17c: 80 a7 60 0c cmp %i5, 0xc
4001b180: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001b184: 80 a0 a0 2e cmp %g2, 0x2e
4001b188: 02 bf ff db be 4001b0f4 <rtems_rfs_dir_empty+0x148>
<== ALWAYS TAKEN
4001b18c: 80 a4 a0 00 cmp %l2, 0
if ((rc == 0) && !empty)
4001b190: 22 80 00 02 be,a 4001b198 <rtems_rfs_dir_empty+0x1ec>
<== ALWAYS TAKEN
4001b194: a4 10 20 5a mov 0x5a, %l2
rtems_rfs_buffer_handle_release (fs, handle);
4001b198: 92 07 bf a4 add %fp, -92, %o1
4001b19c: 7f ff d2 92 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001b1a0: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001b1a4: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001b1a8: c0 2f bf a4 clrb [ %fp + -92 ]
4001b1ac: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001b1b0: c0 27 bf a8 clr [ %fp + -88 ]
}
4001b1b4: b0 10 00 12 mov %l2, %i0
rtems_rfs_block_map_close (fs, &map);
4001b1b8: 7f ff f8 31 call 4001927c <rtems_rfs_block_map_close>
4001b1bc: c0 27 bf ac clr [ %fp + -84 ]
}
4001b1c0: 81 c7 e0 08 ret
4001b1c4: 81 e8 00 00 restore
rtems_rfs_block_map_close (fs, &map);
4001b1c8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001b1cc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001b1d0: 7f ff f8 2b call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001b1d4: b0 10 00 12 mov %l2, %i0
<== NOT EXECUTED
}
4001b1d8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b1dc: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001b1e0: 7f ff df dc call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b1e4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001b1e8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b1ec: 02 80 00 07 be 4001b208 <rtems_rfs_dir_empty+0x25c>
<== NOT EXECUTED
4001b1f0: 98 10 00 13 mov %l3, %o4
<== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
4001b1f4: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001b1f8: 96 10 00 1c mov %i4, %o3
<== NOT EXECUTED
4001b1fc: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4001b200: 7f ff e0 62 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b204: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001b208: 94 07 bf a0 add %fp, -96, %o2
4001b20c: 92 07 bf b0 add %fp, -80, %o1
4001b210: 7f ff f9 05 call 40019624 <rtems_rfs_block_map_next_block>
4001b214: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b218: a4 92 20 00 orcc %o0, 0, %l2
4001b21c: 04 bf ff 8f ble 4001b058 <rtems_rfs_dir_empty+0xac>
<== NEVER TAKEN
4001b220: d4 07 bf a0 ld [ %fp + -96 ], %o2
rc = 0;
4001b224: 82 1c a0 06 xor %l2, 6, %g1
4001b228: 80 a0 00 01 cmp %g0, %g1
4001b22c: 82 60 20 00 subx %g0, 0, %g1
4001b230: 10 bf ff da b 4001b198 <rtems_rfs_dir_empty+0x1ec>
4001b234: a4 0c 80 01 and %l2, %g1, %l2
4001e2b8 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
4001e2b8: 9d e3 bf a0 save %sp, -96, %sp
4001e2bc: 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;
4001e2c0: 31 37 f7 c5 sethi %hi(0xdfdf1400), %i0
4001e2c4: 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)
4001e2c8: 80 a6 60 0c cmp %i1, 0xc
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
4001e2cc: b6 06 40 18 add %i1, %i0, %i3
4001e2d0: b0 10 00 1b mov %i3, %i0
while (length > 12)
4001e2d4: 08 80 00 4b bleu 4001e400 <rtems_rfs_dir_hash+0x148>
4001e2d8: 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;
4001e2dc: fa 08 60 05 ldub [ %g1 + 5 ], %i5
b += ((uint32_t)k[6])<<16;
4001e2e0: c4 08 60 06 ldub [ %g1 + 6 ], %g2
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
4001e2e4: d6 08 60 0a ldub [ %g1 + 0xa ], %o3
b += ((uint32_t)k[5])<<8;
4001e2e8: bb 2f 60 08 sll %i5, 8, %i5
c += ((uint32_t)k[9])<<8;
4001e2ec: c6 08 60 09 ldub [ %g1 + 9 ], %g3
c += ((uint32_t)k[11])<<24;
4001e2f0: d8 08 60 0b ldub [ %g1 + 0xb ], %o4
b += ((uint32_t)k[6])<<16;
4001e2f4: 85 28 a0 10 sll %g2, 0x10, %g2
b += ((uint32_t)k[7])<<24;
4001e2f8: 84 07 40 02 add %i5, %g2, %g2
c += ((uint32_t)k[10])<<16;
4001e2fc: bb 2a e0 10 sll %o3, 0x10, %i5
c += k[8];
4001e300: d2 08 60 08 ldub [ %g1 + 8 ], %o1
a += ((uint32_t)k[2])<<16;
4001e304: de 08 60 02 ldub [ %g1 + 2 ], %o7
c += ((uint32_t)k[9])<<8;
4001e308: 87 28 e0 08 sll %g3, 8, %g3
c += ((uint32_t)k[11])<<24;
4001e30c: 86 00 c0 1d add %g3, %i5, %g3
4001e310: bb 2b 20 18 sll %o4, 0x18, %i5
a += ((uint32_t)k[1])<<8;
4001e314: c8 08 60 01 ldub [ %g1 + 1 ], %g4
a += ((uint32_t)k[3])<<24;
4001e318: f4 08 60 03 ldub [ %g1 + 3 ], %i2
c += ((uint32_t)k[11])<<24;
4001e31c: 86 00 c0 09 add %g3, %o1, %g3
4001e320: 86 00 c0 1d add %g3, %i5, %g3
a += ((uint32_t)k[2])<<16;
4001e324: bb 2b e0 10 sll %o7, 0x10, %i5
c += ((uint32_t)k[11])<<24;
4001e328: b0 00 c0 18 add %g3, %i0, %i0
a += k[0];
4001e32c: da 08 40 00 ldub [ %g1 ], %o5
a += ((uint32_t)k[1])<<8;
4001e330: 89 29 20 08 sll %g4, 8, %g4
mix(a,b,c);
4001e334: 86 01 00 1d add %g4, %i5, %g3
a += ((uint32_t)k[3])<<24;
4001e338: bb 2e a0 18 sll %i2, 0x18, %i5
b += k[4];
4001e33c: d0 08 60 04 ldub [ %g1 + 4 ], %o0
b += ((uint32_t)k[7])<<24;
4001e340: d4 08 60 07 ldub [ %g1 + 7 ], %o2
mix(a,b,c);
4001e344: 89 2e 20 04 sll %i0, 4, %g4
4001e348: 86 00 c0 0d add %g3, %o5, %g3
4001e34c: 86 00 c0 1d add %g3, %i5, %g3
4001e350: bb 36 20 1c srl %i0, 0x1c, %i5
4001e354: 88 11 00 1d or %g4, %i5, %g4
b += ((uint32_t)k[7])<<24;
4001e358: 95 2a a0 18 sll %o2, 0x18, %o2
4001e35c: 84 00 80 08 add %g2, %o0, %g2
4001e360: 84 00 80 0a add %g2, %o2, %g2
4001e364: 84 00 80 1c add %g2, %i4, %g2
mix(a,b,c);
4001e368: b8 06 00 02 add %i0, %g2, %i4
4001e36c: b0 20 c0 18 sub %g3, %i0, %i0
4001e370: b0 06 00 1b add %i0, %i3, %i0
4001e374: b0 19 00 18 xor %g4, %i0, %i0
4001e378: b6 06 00 1c add %i0, %i4, %i3
4001e37c: 89 2e 20 06 sll %i0, 6, %g4
4001e380: 84 20 80 18 sub %g2, %i0, %g2
4001e384: b1 36 20 1a srl %i0, 0x1a, %i0
4001e388: b0 11 00 18 or %g4, %i0, %i0
4001e38c: 84 1e 00 02 xor %i0, %g2, %g2
4001e390: ba 00 80 1b add %g2, %i3, %i5
4001e394: b8 27 00 02 sub %i4, %g2, %i4
4001e398: 87 28 a0 08 sll %g2, 8, %g3
4001e39c: 85 30 a0 18 srl %g2, 0x18, %g2
4001e3a0: 86 10 c0 02 or %g3, %g2, %g3
4001e3a4: 86 18 c0 1c xor %g3, %i4, %g3
4001e3a8: 88 00 c0 1d add %g3, %i5, %g4
4001e3ac: b6 26 c0 03 sub %i3, %g3, %i3
4001e3b0: b1 28 e0 10 sll %g3, 0x10, %i0
4001e3b4: 87 30 e0 10 srl %g3, 0x10, %g3
4001e3b8: 86 16 00 03 or %i0, %g3, %g3
4001e3bc: b0 18 c0 1b xor %g3, %i3, %i0
4001e3c0: 87 2e 20 13 sll %i0, 0x13, %g3
4001e3c4: b6 06 00 04 add %i0, %g4, %i3
4001e3c8: ba 27 40 18 sub %i5, %i0, %i5
4001e3cc: 85 36 20 0d srl %i0, 0xd, %g2
length -= 12;
4001e3d0: b2 06 7f f4 add %i1, -12, %i1
mix(a,b,c);
4001e3d4: 84 10 80 03 or %g2, %g3, %g2
k += 12;
4001e3d8: 82 00 60 0c add %g1, 0xc, %g1
mix(a,b,c);
4001e3dc: 84 18 80 1d xor %g2, %i5, %g2
while (length > 12)
4001e3e0: 80 a6 60 0c cmp %i1, 0xc
mix(a,b,c);
4001e3e4: 88 21 00 02 sub %g4, %g2, %g4
4001e3e8: b1 28 a0 04 sll %g2, 4, %i0
4001e3ec: 87 30 a0 1c srl %g2, 0x1c, %g3
4001e3f0: b8 00 80 1b add %g2, %i3, %i4
4001e3f4: b0 16 00 03 or %i0, %g3, %i0
while (length > 12)
4001e3f8: 18 bf ff b9 bgu 4001e2dc <rtems_rfs_dir_hash+0x24>
<== NEVER TAKEN
4001e3fc: b0 1e 00 04 xor %i0, %g4, %i0
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
4001e400: b3 2e 60 02 sll %i1, 2, %i1
4001e404: 05 10 00 78 sethi %hi(0x4001e000), %g2
4001e408: 84 10 a2 84 or %g2, 0x284, %g2 ! 4001e284 <_Objects_API_maximum_class+0x28>
4001e40c: c4 00 80 19 ld [ %g2 + %i1 ], %g2
4001e410: 81 c0 80 00 jmp %g2
4001e414: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
4001e418: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
4001e41c: 85 28 a0 18 sll %g2, 0x18, %g2
4001e420: b0 06 00 02 add %i0, %g2, %i0
case 11: c+=((uint32_t)k[10])<<16;
4001e424: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001e428: 85 28 a0 10 sll %g2, 0x10, %g2
4001e42c: b0 06 00 02 add %i0, %g2, %i0
case 10: c+=((uint32_t)k[9])<<8;
4001e430: c4 08 60 09 ldub [ %g1 + 9 ], %g2
4001e434: 85 28 a0 08 sll %g2, 8, %g2
4001e438: b0 06 00 02 add %i0, %g2, %i0
case 9 : c+=k[8];
4001e43c: c4 08 60 08 ldub [ %g1 + 8 ], %g2
4001e440: b0 06 00 02 add %i0, %g2, %i0
case 8 : b+=((uint32_t)k[7])<<24;
4001e444: c4 08 60 07 ldub [ %g1 + 7 ], %g2
4001e448: 85 28 a0 18 sll %g2, 0x18, %g2
4001e44c: b8 07 00 02 add %i4, %g2, %i4
case 7 : b+=((uint32_t)k[6])<<16;
4001e450: c4 08 60 06 ldub [ %g1 + 6 ], %g2
4001e454: 85 28 a0 10 sll %g2, 0x10, %g2
4001e458: b8 07 00 02 add %i4, %g2, %i4
case 6 : b+=((uint32_t)k[5])<<8;
4001e45c: c4 08 60 05 ldub [ %g1 + 5 ], %g2
4001e460: 85 28 a0 08 sll %g2, 8, %g2
4001e464: b8 07 00 02 add %i4, %g2, %i4
case 5 : b+=k[4];
4001e468: c4 08 60 04 ldub [ %g1 + 4 ], %g2
4001e46c: b8 07 00 02 add %i4, %g2, %i4
case 4 : a+=((uint32_t)k[3])<<24;
4001e470: c4 08 60 03 ldub [ %g1 + 3 ], %g2
4001e474: 85 28 a0 18 sll %g2, 0x18, %g2
4001e478: b6 06 c0 02 add %i3, %g2, %i3
case 3 : a+=((uint32_t)k[2])<<16;
4001e47c: c4 08 60 02 ldub [ %g1 + 2 ], %g2
4001e480: 85 28 a0 10 sll %g2, 0x10, %g2
4001e484: b6 06 c0 02 add %i3, %g2, %i3
case 2 : a+=((uint32_t)k[1])<<8;
4001e488: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001e48c: 85 28 a0 08 sll %g2, 8, %g2
4001e490: b6 06 c0 02 add %i3, %g2, %i3
case 1 : a+=k[0];
4001e494: c2 08 40 00 ldub [ %g1 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
4001e498: 85 37 20 12 srl %i4, 0x12, %g2
case 1 : a+=k[0];
4001e49c: b6 00 40 1b add %g1, %i3, %i3
final(a,b,c);
4001e4a0: 83 2f 20 0e sll %i4, 0xe, %g1
4001e4a4: 82 10 40 02 or %g1, %g2, %g1
4001e4a8: b0 1f 00 18 xor %i4, %i0, %i0
4001e4ac: b0 26 00 01 sub %i0, %g1, %i0
4001e4b0: 85 36 20 15 srl %i0, 0x15, %g2
4001e4b4: 83 2e 20 0b sll %i0, 0xb, %g1
4001e4b8: 82 10 40 02 or %g1, %g2, %g1
4001e4bc: b6 1e c0 18 xor %i3, %i0, %i3
4001e4c0: b6 26 c0 01 sub %i3, %g1, %i3
4001e4c4: 83 2e e0 19 sll %i3, 0x19, %g1
4001e4c8: 84 1f 00 1b xor %i4, %i3, %g2
4001e4cc: b9 36 e0 07 srl %i3, 7, %i4
4001e4d0: b8 17 00 01 or %i4, %g1, %i4
4001e4d4: 84 20 80 1c sub %g2, %i4, %g2
4001e4d8: 87 30 a0 10 srl %g2, 0x10, %g3
4001e4dc: 83 28 a0 10 sll %g2, 0x10, %g1
4001e4e0: 82 10 40 03 or %g1, %g3, %g1
4001e4e4: b0 1e 00 02 xor %i0, %g2, %i0
4001e4e8: b0 26 00 01 sub %i0, %g1, %i0
4001e4ec: 83 2e 20 04 sll %i0, 4, %g1
4001e4f0: 87 36 20 1c srl %i0, 0x1c, %g3
4001e4f4: 82 10 40 03 or %g1, %g3, %g1
4001e4f8: b6 1e 00 1b xor %i0, %i3, %i3
4001e4fc: b6 26 c0 01 sub %i3, %g1, %i3
4001e500: 83 2e e0 0e sll %i3, 0xe, %g1
4001e504: 84 1e c0 02 xor %i3, %g2, %g2
4001e508: b7 36 e0 12 srl %i3, 0x12, %i3
4001e50c: b6 10 40 1b or %g1, %i3, %i3
4001e510: 84 20 80 1b sub %g2, %i3, %g2
4001e514: b0 18 80 18 xor %g2, %i0, %i0
4001e518: 83 30 a0 08 srl %g2, 8, %g1
4001e51c: 85 28 a0 18 sll %g2, 0x18, %g2
4001e520: 84 10 40 02 or %g1, %g2, %g2
4001e524: b0 26 00 02 sub %i0, %g2, %i0
return c;
}
4001e528: 81 c7 e0 08 ret
4001e52c: 81 e8 00 00 restore
40019e4c <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
40019e4c: 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))
40019e50: 90 10 20 00 clr %o0
40019e54: 7f ff e4 bf call 40013150 <rtems_rfs_trace>
40019e58: 13 01 00 00 sethi %hi(0x4000000), %o1
40019e5c: 80 a2 20 00 cmp %o0, 0
40019e60: 32 80 00 ad bne,a 4001a114 <rtems_rfs_dir_lookup_ino+0x2c8>
<== NEVER TAKEN
40019e64: 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;
40019e68: c0 27 00 00 clr [ %i4 ]
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
40019e6c: 94 07 bf b0 add %fp, -80, %o2
*offset = 0;
40019e70: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
40019e74: 92 10 00 19 mov %i1, %o1
40019e78: 7f ff fc a2 call 40019100 <rtems_rfs_block_map_open>
40019e7c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40019e80: a6 92 20 00 orcc %o0, 0, %l3
40019e84: 24 80 00 15 ble,a 40019ed8 <rtems_rfs_dir_lookup_ino+0x8c>
<== ALWAYS TAKEN
40019e88: 92 10 00 1b mov %i3, %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40019e8c: 90 10 20 00 clr %o0
<== NOT EXECUTED
40019e90: 7f ff e4 b0 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
40019e94: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
40019e98: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019e9c: 32 80 00 04 bne,a 40019eac <rtems_rfs_dir_lookup_ino+0x60>
<== NOT EXECUTED
40019ea0: 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;
}
40019ea4: 81 c7 e0 08 ret
40019ea8: 91 e8 00 13 restore %g0, %l3, %o0
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
40019eac: 40 00 15 7d call 4001f4a0 <strerror>
<== NOT EXECUTED
40019eb0: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
40019eb4: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
40019eb8: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40019ebc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40019ec0: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
}
40019ec4: b0 10 00 13 mov %l3, %i0
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
40019ec8: 7f ff e5 30 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40019ecc: 90 12 23 58 or %o0, 0x358, %o0
<== NOT EXECUTED
}
40019ed0: 81 c7 e0 08 ret
<== NOT EXECUTED
40019ed4: 81 e8 00 00 restore
<== NOT EXECUTED
handle->dirty = false;
40019ed8: c0 2f bf a4 clrb [ %fp + -92 ]
hash = rtems_rfs_dir_hash (name, length);
40019edc: 90 10 00 1a mov %i2, %o0
handle->bnum = 0;
40019ee0: c0 27 bf a8 clr [ %fp + -88 ]
40019ee4: 40 00 10 f5 call 4001e2b8 <rtems_rfs_dir_hash>
40019ee8: c0 27 bf ac clr [ %fp + -84 ]
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40019eec: 98 07 bf a0 add %fp, -96, %o4
hash = rtems_rfs_dir_hash (name, length);
40019ef0: a4 10 00 08 mov %o0, %l2
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40019ef4: 94 10 20 00 clr %o2
40019ef8: 96 10 20 00 clr %o3
40019efc: 92 07 bf b0 add %fp, -80, %o1
40019f00: 7f ff fd ab call 400195ac <rtems_rfs_block_map_seek>
40019f04: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40019f08: a6 92 20 00 orcc %o0, 0, %l3
40019f0c: 14 80 00 95 bg 4001a160 <rtems_rfs_dir_lookup_ino+0x314>
<== NEVER TAKEN
40019f10: 2f 10 00 8d sethi %hi(0x40023400), %l7
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
40019f14: 82 15 e3 d8 or %l7, 0x3d8, %g1 ! 400237d8 <status_code_to_errno+0x2bc>
40019f18: c2 27 bf 9c st %g1, [ %fp + -100 ]
printf ("rtems-rfs: dir-lookup-ino: "
40019f1c: 03 10 00 8e sethi %hi(0x40023800), %g1
40019f20: 82 10 61 50 or %g1, 0x150, %g1 ! 40023950 <status_code_to_errno+0x434>
40019f24: c2 27 bf 98 st %g1, [ %fp + -104 ]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40019f28: 23 00 00 3f sethi %hi(0xfc00), %l1
printf ("rtems-rfs: dir-lookup-ino: "
40019f2c: 2d 10 00 8e sethi %hi(0x40023800), %l6
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40019f30: a2 14 63 ff or %l1, 0x3ff, %l1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
40019f34: a8 10 20 00 clr %l4
40019f38: 2b 02 00 00 sethi %hi(0x8000000), %l5
printf ("rtems-rfs: dir-lookup-ino: "
40019f3c: ac 15 a0 a8 or %l6, 0xa8, %l6
while ((rc == 0) && block)
40019f40: 80 a4 e0 00 cmp %l3, 0
40019f44: 12 80 00 90 bne 4001a184 <rtems_rfs_dir_lookup_ino+0x338>
<== NEVER TAKEN
40019f48: c2 07 bf a0 ld [ %fp + -96 ], %g1
40019f4c: 80 a0 60 00 cmp %g1, 0
40019f50: 02 80 00 fe be 4001a348 <rtems_rfs_dir_lookup_ino+0x4fc>
<== NEVER TAKEN
40019f54: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40019f58: 7f ff e4 7e call 40013150 <rtems_rfs_trace>
40019f5c: 13 01 00 00 sethi %hi(0x4000000), %o1
40019f60: 80 a2 20 00 cmp %o0, 0
40019f64: 12 80 00 b5 bne 4001a238 <rtems_rfs_dir_lookup_ino+0x3ec>
<== NEVER TAKEN
40019f68: d4 07 bf c0 ld [ %fp + -64 ], %o2
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
40019f6c: d4 07 bf a0 ld [ %fp + -96 ], %o2
40019f70: 96 10 20 01 mov 1, %o3
40019f74: 92 07 bf a4 add %fp, -92, %o1
40019f78: 7f ff d6 54 call 4000f8c8 <rtems_rfs_buffer_handle_request>
40019f7c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
40019f80: a6 92 20 00 orcc %o0, 0, %l3
40019f84: 14 80 00 c4 bg 4001a294 <rtems_rfs_dir_lookup_ino+0x448>
<== NEVER TAKEN
40019f88: 90 10 20 00 clr %o0
map.bpos.boff = 0;
40019f8c: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40019f90: d0 06 20 08 ld [ %i0 + 8 ], %o0
entry = rtems_rfs_buffer_data (&entries);
40019f94: c2 07 bf ac ld [ %fp + -84 ], %g1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40019f98: 80 a2 20 0a cmp %o0, 0xa
40019f9c: 12 80 00 0a bne 40019fc4 <rtems_rfs_dir_lookup_ino+0x178>
<== ALWAYS TAKEN
40019fa0: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
if (rc == 0)
40019fa4: 10 80 00 47 b 4001a0c0 <rtems_rfs_dir_lookup_ino+0x274>
<== NOT EXECUTED
40019fa8: 80 a4 e0 00 cmp %l3, 0
<== NOT EXECUTED
map.bpos.boff += elength;
40019fac: 82 05 c0 01 add %l7, %g1, %g1
40019fb0: c2 27 bf c4 st %g1, [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40019fb4: 86 02 3f f6 add %o0, -10, %g3
40019fb8: 80 a0 40 03 cmp %g1, %g3
40019fbc: 1a 80 00 40 bcc 4001a0bc <rtems_rfs_dir_lookup_ino+0x270>
<== NEVER TAKEN
40019fc0: a0 04 00 17 add %l0, %l7, %l0
*ino = rtems_rfs_dir_entry_ino (entry);
40019fc4: d8 0c 00 00 ldub [ %l0 ], %o4
40019fc8: de 0c 20 01 ldub [ %l0 + 1 ], %o7
40019fcc: c2 0c 20 02 ldub [ %l0 + 2 ], %g1
40019fd0: d2 0c 20 03 ldub [ %l0 + 3 ], %o1
ehash = rtems_rfs_dir_entry_hash (entry);
40019fd4: da 0c 20 04 ldub [ %l0 + 4 ], %o5
40019fd8: c8 0c 20 05 ldub [ %l0 + 5 ], %g4
40019fdc: c6 0c 20 06 ldub [ %l0 + 6 ], %g3
40019fe0: d6 0c 20 07 ldub [ %l0 + 7 ], %o3
40019fe4: c4 0c 20 08 ldub [ %l0 + 8 ], %g2
40019fe8: d4 0c 20 09 ldub [ %l0 + 9 ], %o2
*ino = rtems_rfs_dir_entry_ino (entry);
40019fec: 99 2b 20 18 sll %o4, 0x18, %o4
40019ff0: 9f 2b e0 10 sll %o7, 0x10, %o7
40019ff4: 83 28 60 08 sll %g1, 8, %g1
40019ff8: 9e 13 c0 0c or %o7, %o4, %o7
40019ffc: 82 10 40 0f or %g1, %o7, %g1
4001a000: 92 12 40 01 or %o1, %g1, %o1
4001a004: d2 27 00 00 st %o1, [ %i4 ]
ehash = rtems_rfs_dir_entry_hash (entry);
4001a008: 9b 2b 60 18 sll %o5, 0x18, %o5
4001a00c: 89 29 20 10 sll %g4, 0x10, %g4
4001a010: 87 28 e0 08 sll %g3, 8, %g3
4001a014: 88 11 00 0d or %g4, %o5, %g4
4001a018: 85 28 a0 08 sll %g2, 8, %g2
4001a01c: 86 10 c0 04 or %g3, %g4, %g3
elength = rtems_rfs_dir_entry_length (entry);
4001a020: ae 12 80 02 or %o2, %g2, %l7
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001a024: 80 a5 c0 11 cmp %l7, %l1
4001a028: 02 80 00 25 be 4001a0bc <rtems_rfs_dir_lookup_ino+0x270>
4001a02c: 86 12 c0 03 or %o3, %g3, %g3
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
4001a030: 80 a5 e0 0a cmp %l7, 0xa
4001a034: 24 80 00 61 ble,a 4001a1b8 <rtems_rfs_dir_lookup_ino+0x36c>
<== NEVER TAKEN
4001a038: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a03c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001a040: 80 a5 c0 01 cmp %l7, %g1
4001a044: 1a 80 00 5c bcc 4001a1b4 <rtems_rfs_dir_lookup_ino+0x368>
<== NEVER TAKEN
4001a048: 80 a2 60 00 cmp %o1, 0
4001a04c: 22 80 00 5b be,a 4001a1b8 <rtems_rfs_dir_lookup_ino+0x36c>
<== NEVER TAKEN
4001a050: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a054: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001a058: 80 a2 40 01 cmp %o1, %g1
4001a05c: 18 80 00 56 bgu 4001a1b4 <rtems_rfs_dir_lookup_ino+0x368>
<== NEVER TAKEN
4001a060: 80 a4 80 03 cmp %l2, %g3
if (ehash == hash)
4001a064: 12 bf ff d2 bne 40019fac <rtems_rfs_dir_lookup_ino+0x160>
4001a068: c2 07 bf c4 ld [ %fp + -60 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001a06c: 90 10 00 14 mov %l4, %o0
4001a070: 7f ff e4 38 call 40013150 <rtems_rfs_trace>
4001a074: 92 10 00 15 mov %l5, %o1
4001a078: 80 a2 20 00 cmp %o0, 0
4001a07c: 32 80 00 5f bne,a 4001a1f8 <rtems_rfs_dir_lookup_ino+0x3ac>
<== NEVER TAKEN
4001a080: c8 0c 00 00 ldub [ %l0 ], %g4
<== NOT EXECUTED
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001a084: 94 10 00 1b mov %i3, %o2
4001a088: 92 10 00 1a mov %i2, %o1
4001a08c: 40 00 11 35 call 4001e560 <memcmp>
4001a090: 90 04 20 0a add %l0, 0xa, %o0
4001a094: 80 a2 20 00 cmp %o0, 0
4001a098: 02 80 00 91 be 4001a2dc <rtems_rfs_dir_lookup_ino+0x490>
<== ALWAYS TAKEN
4001a09c: c2 07 bf c4 ld [ %fp + -60 ], %g1
map.bpos.boff += elength;
4001a0a0: 82 05 c0 01 add %l7, %g1, %g1
<== NOT EXECUTED
4001a0a4: c2 27 bf c4 st %g1, [ %fp + -60 ]
<== NOT EXECUTED
4001a0a8: 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))
4001a0ac: 86 02 3f f6 add %o0, -10, %g3
<== NOT EXECUTED
4001a0b0: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
4001a0b4: 0a bf ff c4 bcs 40019fc4 <rtems_rfs_dir_lookup_ino+0x178>
<== NOT EXECUTED
4001a0b8: a0 04 00 17 add %l0, %l7, %l0
<== NOT EXECUTED
if (rc == 0)
4001a0bc: 80 a4 e0 00 cmp %l3, 0
4001a0c0: 12 80 00 32 bne 4001a188 <rtems_rfs_dir_lookup_ino+0x33c>
<== NEVER TAKEN
4001a0c4: 92 07 bf a4 add %fp, -92, %o1
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001a0c8: 94 07 bf a0 add %fp, -96, %o2
4001a0cc: 92 07 bf b0 add %fp, -80, %o1
4001a0d0: 7f ff fd 55 call 40019624 <rtems_rfs_block_map_next_block>
4001a0d4: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && (rc != ENXIO))
4001a0d8: a6 92 20 00 orcc %o0, 0, %l3
4001a0dc: 04 80 00 09 ble 4001a100 <rtems_rfs_dir_lookup_ino+0x2b4>
<== NEVER TAKEN
4001a0e0: 80 a4 e0 06 cmp %l3, 6
4001a0e4: 02 80 00 08 be 4001a104 <rtems_rfs_dir_lookup_ino+0x2b8>
<== ALWAYS TAKEN
4001a0e8: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001a0ec: 7f ff e4 19 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a0f0: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001a0f4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a0f8: 32 80 00 5e bne,a 4001a270 <rtems_rfs_dir_lookup_ino+0x424>
<== NOT EXECUTED
4001a0fc: e0 06 60 08 ld [ %i1 + 8 ], %l0
<== NOT EXECUTED
if (rc == ENXIO)
4001a100: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
4001a104: 12 bf ff 90 bne 40019f44 <rtems_rfs_dir_lookup_ino+0xf8>
<== NEVER TAKEN
4001a108: 80 a4 e0 00 cmp %l3, 0
rc = ENOENT;
4001a10c: 10 80 00 1e b 4001a184 <rtems_rfs_dir_lookup_ino+0x338>
4001a110: a6 10 20 02 mov 2, %l3
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001a114: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
4001a118: 7f ff e4 9c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a11c: 90 12 23 10 or %o0, 0x310, %o0 ! 40023710 <status_code_to_errno+0x1f4>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001a120: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4001a124: 04 80 00 0a ble 4001a14c <rtems_rfs_dir_lookup_ino+0x300>
<== NOT EXECUTED
4001a128: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001a12c: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4001a130: a2 06 c0 1a add %i3, %i2, %l1
<== NOT EXECUTED
printf ("%c", name[c]);
4001a134: 7f ff e4 aa call 400133dc <__wrap_putchar>
<== NOT EXECUTED
4001a138: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
4001a13c: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001a140: 80 a4 40 10 cmp %l1, %l0
<== NOT EXECUTED
4001a144: 12 bf ff fc bne 4001a134 <rtems_rfs_dir_lookup_ino+0x2e8>
<== NOT EXECUTED
4001a148: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
printf (", len=%d\n", length);
4001a14c: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
4001a150: 7f ff e4 8e call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a154: 90 12 23 48 or %o0, 0x348, %o0 ! 40023748 <status_code_to_errno+0x22c>
<== NOT EXECUTED
*ino = RTEMS_RFS_EMPTY_INO;
4001a158: 10 bf ff 45 b 40019e6c <rtems_rfs_dir_lookup_ino+0x20>
<== NOT EXECUTED
4001a15c: c0 27 00 00 clr [ %i4 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001a160: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a164: 7f ff e3 fb call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a168: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001a16c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a170: 12 80 00 37 bne 4001a24c <rtems_rfs_dir_lookup_ino+0x400>
<== NOT EXECUTED
4001a174: 01 00 00 00 nop
<== NOT EXECUTED
if (rc == ENXIO)
4001a178: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
4001a17c: 22 80 00 02 be,a 4001a184 <rtems_rfs_dir_lookup_ino+0x338>
<== NOT EXECUTED
4001a180: a6 10 20 02 mov 2, %l3
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a184: 92 07 bf a4 add %fp, -92, %o1
4001a188: 7f ff d6 97 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001a18c: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001a190: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001a194: c0 2f bf a4 clrb [ %fp + -92 ]
4001a198: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001a19c: c0 27 bf a8 clr [ %fp + -88 ]
}
4001a1a0: b0 10 00 13 mov %l3, %i0
rtems_rfs_block_map_close (fs, &map);
4001a1a4: 7f ff fc 36 call 4001927c <rtems_rfs_block_map_close>
4001a1a8: c0 27 bf ac clr [ %fp + -84 ]
}
4001a1ac: 81 c7 e0 08 ret
4001a1b0: 81 e8 00 00 restore
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001a1b4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001a1b8: 7f ff e3 e6 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a1bc: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001a1c0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a1c4: 12 80 00 04 bne 4001a1d4 <rtems_rfs_dir_lookup_ino+0x388>
<== NOT EXECUTED
4001a1c8: d8 07 bf c4 ld [ %fp + -60 ], %o4
<== NOT EXECUTED
rc = EIO;
4001a1cc: 10 bf ff ee b 4001a184 <rtems_rfs_dir_lookup_ino+0x338>
<== NOT EXECUTED
4001a1d0: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001a1d4: d6 07 00 00 ld [ %i4 ], %o3
<== NOT EXECUTED
4001a1d8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a1dc: 94 10 00 17 mov %l7, %o2
<== NOT EXECUTED
rc = EIO;
4001a1e0: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001a1e4: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a1e8: 7f ff e4 68 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a1ec: 90 12 20 58 or %o0, 0x58, %o0 ! 40023858 <status_code_to_errno+0x33c>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a1f0: 10 bf ff e6 b 4001a188 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001a1f4: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001a1f8: c6 0c 20 01 ldub [ %l0 + 1 ], %g3
<== NOT EXECUTED
4001a1fc: c2 0c 20 02 ldub [ %l0 + 2 ], %g1
<== NOT EXECUTED
4001a200: da 0c 20 03 ldub [ %l0 + 3 ], %o5
<== NOT EXECUTED
4001a204: 89 29 20 18 sll %g4, 0x18, %g4
<== NOT EXECUTED
4001a208: d4 1f bf c0 ldd [ %fp + -64 ], %o2
<== NOT EXECUTED
4001a20c: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a210: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
4001a214: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001a218: 86 10 c0 04 or %g3, %g4, %g3
<== NOT EXECUTED
4001a21c: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
4001a220: 98 10 00 17 mov %l7, %o4
<== NOT EXECUTED
4001a224: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
4001a228: 7f ff e4 58 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a22c: 9a 13 40 01 or %o5, %g1, %o5
<== NOT EXECUTED
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001a230: 10 bf ff 96 b 4001a088 <rtems_rfs_dir_lookup_ino+0x23c>
<== NOT EXECUTED
4001a234: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001a238: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a23c: 7f ff e4 53 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a240: d0 07 bf 9c ld [ %fp + -100 ], %o0
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001a244: 10 bf ff 4b b 40019f70 <rtems_rfs_dir_lookup_ino+0x124>
<== NOT EXECUTED
4001a248: d4 07 bf a0 ld [ %fp + -96 ], %o2
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
4001a24c: 40 00 14 95 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a250: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001a254: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
4001a258: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001a25c: 11 10 00 8d sethi %hi(0x40023400), %o0
<== NOT EXECUTED
4001a260: 7f ff e4 4a call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a264: 90 12 23 98 or %o0, 0x398, %o0 ! 40023798 <status_code_to_errno+0x27c>
<== NOT EXECUTED
if (rc == ENXIO)
4001a268: 10 bf ff c5 b 4001a17c <rtems_rfs_dir_lookup_ino+0x330>
<== NOT EXECUTED
4001a26c: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001a270: 40 00 14 8c call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a274: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001a278: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001a27c: d0 07 bf 98 ld [ %fp + -104 ], %o0
<== NOT EXECUTED
4001a280: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4001a284: 7f ff e4 41 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a288: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
if (rc == ENXIO)
4001a28c: 10 bf ff 9e b 4001a104 <rtems_rfs_dir_lookup_ino+0x2b8>
<== NOT EXECUTED
4001a290: 80 a4 e0 06 cmp %l3, 6
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001a294: 7f ff e3 af call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a298: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001a29c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a2a0: 22 bf ff ba be,a 4001a188 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001a2a4: 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",
4001a2a8: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001a2ac: f8 07 bf a0 ld [ %fp + -96 ], %i4
<== NOT EXECUTED
4001a2b0: 40 00 14 7c call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a2b4: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
4001a2b8: 96 10 00 13 mov %l3, %o3
<== NOT EXECUTED
4001a2bc: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001a2c0: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001a2c4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001a2c8: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a2cc: 7f ff e4 2f call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a2d0: 90 12 20 10 or %o0, 0x10, %o0 ! 40023810 <status_code_to_errno+0x2f4>
<== NOT EXECUTED
4001a2d4: 10 bf ff ad b 4001a188 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001a2d8: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
*offset = rtems_rfs_block_map_pos (fs, &map);
4001a2dc: 92 07 bf c0 add %fp, -64, %o1
4001a2e0: 7f ff fb 6e call 40019098 <rtems_rfs_block_get_pos>
4001a2e4: 90 10 00 18 mov %i0, %o0
4001a2e8: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001a2ec: 90 10 20 00 clr %o0
4001a2f0: 7f ff e3 98 call 40013150 <rtems_rfs_trace>
4001a2f4: 13 04 00 00 sethi %hi(0x10000000), %o1
4001a2f8: 80 a2 20 00 cmp %o0, 0
4001a2fc: 02 80 00 09 be 4001a320 <rtems_rfs_dir_lookup_ino+0x4d4>
<== ALWAYS TAKEN
4001a300: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
4001a304: d6 07 40 00 ld [ %i5 ], %o3
<== NOT EXECUTED
4001a308: d4 07 00 00 ld [ %i4 ], %o2
<== NOT EXECUTED
4001a30c: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001a310: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a314: 7f ff e4 1d call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a318: 90 12 21 08 or %o0, 0x108, %o0 ! 40023908 <status_code_to_errno+0x3ec>
<== NOT EXECUTED
4001a31c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001a320: 7f ff d6 31 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001a324: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001a328: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001a32c: c0 2f bf a4 clrb [ %fp + -92 ]
4001a330: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001a334: c0 27 bf a8 clr [ %fp + -88 ]
return 0;
4001a338: a6 10 20 00 clr %l3
rtems_rfs_block_map_close (fs, &map);
4001a33c: 7f ff fb d0 call 4001927c <rtems_rfs_block_map_close>
4001a340: c0 27 bf ac clr [ %fp + -84 ]
return 0;
4001a344: 30 bf fe d8 b,a 40019ea4 <rtems_rfs_dir_lookup_ino+0x58>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001a348: 7f ff e3 82 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001a34c: 13 01 00 00 sethi %hi(0x4000000), %o1
<== NOT EXECUTED
4001a350: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a354: 22 bf ff 8c be,a 4001a184 <rtems_rfs_dir_lookup_ino+0x338>
<== NOT EXECUTED
4001a358: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001a35c: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
4001a360: 40 00 14 50 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001a364: 90 10 20 05 mov 5, %o0
<== NOT EXECUTED
4001a368: 94 10 20 05 mov 5, %o2
<== NOT EXECUTED
4001a36c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001a370: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
rc = EIO;
4001a374: a6 10 20 05 mov 5, %l3
<== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001a378: 11 10 00 8e sethi %hi(0x40023800), %o0
<== NOT EXECUTED
4001a37c: 7f ff e4 03 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001a380: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400239a0 <status_code_to_errno+0x484>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001a384: 10 bf ff 81 b 4001a188 <rtems_rfs_dir_lookup_ino+0x33c>
<== NOT EXECUTED
4001a388: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
4001abec <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)
{
4001abec: 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))
4001abf0: 90 10 20 00 clr %o0
4001abf4: 13 20 00 00 sethi %hi(0x80000000), %o1
4001abf8: 7f ff e1 56 call 40013150 <rtems_rfs_trace>
4001abfc: a4 10 00 1a mov %i2, %l2
4001ac00: 80 a2 20 00 cmp %o0, 0
4001ac04: 12 80 00 29 bne 4001aca8 <rtems_rfs_dir_read+0xbc>
<== NEVER TAKEN
4001ac08: 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;
4001ac0c: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001ac10: 92 10 00 19 mov %i1, %o1
4001ac14: 94 07 bf b0 add %fp, -80, %o2
4001ac18: 7f ff f9 3a call 40019100 <rtems_rfs_block_map_open>
4001ac1c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001ac20: b6 92 20 00 orcc %o0, 0, %i3
4001ac24: 24 80 00 04 ble,a 4001ac34 <rtems_rfs_dir_read+0x48>
<== ALWAYS TAKEN
4001ac28: e0 06 20 08 ld [ %i0 + 8 ], %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001ac2c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001ac30: 91 e8 00 1b restore %g0, %i3, %o0
<== NOT EXECUTED
if (((rtems_rfs_fs_block_size (fs) -
4001ac34: b4 10 20 00 clr %i2
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
4001ac38: 90 10 00 12 mov %l2, %o0
4001ac3c: 92 10 00 13 mov %l3, %o1
4001ac40: 94 10 00 1a mov %i2, %o2
4001ac44: 40 00 14 cf call 4001ff80 <__moddi3>
4001ac48: 96 10 00 10 mov %l0, %o3
if (((rtems_rfs_fs_block_size (fs) -
4001ac4c: 86 a4 00 09 subcc %l0, %o1, %g3
4001ac50: 84 66 80 08 subx %i2, %o0, %g2
4001ac54: 80 a0 a0 00 cmp %g2, 0
4001ac58: 04 80 00 1c ble 4001acc8 <rtems_rfs_dir_read+0xdc>
<== ALWAYS TAKEN
4001ac5c: b6 10 00 10 mov %l0, %i3
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001ac60: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001ac64: 96 10 00 13 mov %l3, %o3
4001ac68: 98 07 bf a0 add %fp, -96, %o4
4001ac6c: 92 07 bf b0 add %fp, -80, %o1
4001ac70: 7f ff fa 4f call 400195ac <rtems_rfs_block_map_seek>
4001ac74: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001ac78: b6 92 20 00 orcc %o0, 0, %i3
4001ac7c: 24 80 00 2d ble,a 4001ad30 <rtems_rfs_dir_read+0x144>
<== ALWAYS TAKEN
4001ac80: 35 00 00 3f sethi %hi(0xfc00), %i2
if (rc == ENXIO)
4001ac84: 80 a6 e0 06 cmp %i3, 6
<== NOT EXECUTED
4001ac88: 22 80 00 02 be,a 4001ac90 <rtems_rfs_dir_read+0xa4>
<== NOT EXECUTED
4001ac8c: b6 10 20 02 mov 2, %i3
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001ac90: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001ac94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001ac98: 7f ff f9 79 call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001ac9c: b0 10 00 1b mov %i3, %i0
<== NOT EXECUTED
}
4001aca0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001aca4: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
4001aca8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001acac: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001acb0: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4001acb4: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001acb8: 7f ff e1 b4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001acbc: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40023cc0 <status_code_to_errno+0x7a4>
<== NOT EXECUTED
*length = 0;
4001acc0: 10 bf ff d4 b 4001ac10 <rtems_rfs_dir_read+0x24>
<== NOT EXECUTED
4001acc4: c0 27 40 00 clr [ %i5 ]
<== NOT EXECUTED
if (((rtems_rfs_fs_block_size (fs) -
4001acc8: 12 80 00 06 bne 4001ace0 <rtems_rfs_dir_read+0xf4>
<== NEVER TAKEN
4001accc: 96 10 00 1b mov %i3, %o3
4001acd0: 80 a0 e0 0a cmp %g3, 0xa
4001acd4: 38 bf ff e4 bgu,a 4001ac64 <rtems_rfs_dir_read+0x78>
<== ALWAYS TAKEN
4001acd8: 94 10 00 12 mov %l2, %o2
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
4001acdc: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4001ace0: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
4001ace4: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
4001ace8: 40 00 14 1b call 4001fd54 <__divdi3>
<== NOT EXECUTED
4001acec: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001acf0: 86 82 60 01 addcc %o1, 1, %g3
<== NOT EXECUTED
4001acf4: 84 42 20 00 addx %o0, 0, %g2
<== NOT EXECUTED
4001acf8: 82 58 80 10 smul %g2, %l0, %g1
<== NOT EXECUTED
4001acfc: a6 54 00 03 umul %l0, %g3, %l3
<== NOT EXECUTED
4001ad00: a5 40 00 00 rd %y, %l2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001ad04: 98 07 bf a0 add %fp, -96, %o4
<== NOT EXECUTED
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
4001ad08: a4 00 40 12 add %g1, %l2, %l2
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001ad0c: 96 10 00 13 mov %l3, %o3
<== NOT EXECUTED
4001ad10: 94 10 00 12 mov %l2, %o2
<== NOT EXECUTED
4001ad14: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001ad18: 7f ff fa 25 call 400195ac <rtems_rfs_block_map_seek>
<== NOT EXECUTED
4001ad1c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001ad20: b6 92 20 00 orcc %o0, 0, %i3
<== NOT EXECUTED
4001ad24: 14 bf ff d9 bg 4001ac88 <rtems_rfs_dir_read+0x9c>
<== NOT EXECUTED
4001ad28: 80 a6 e0 06 cmp %i3, 6
<== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001ad2c: 35 00 00 3f sethi %hi(0xfc00), %i2
<== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001ad30: 2d 10 00 8f sethi %hi(0x40023c00), %l6
handle->dirty = false;
4001ad34: c0 2f bf a4 clrb [ %fp + -92 ]
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001ad38: b4 16 a3 ff or %i2, 0x3ff, %i2
handle->bnum = 0;
4001ad3c: c0 27 bf a8 clr [ %fp + -88 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001ad40: a8 10 20 00 clr %l4
handle->buffer = NULL;
4001ad44: c0 27 bf ac clr [ %fp + -84 ]
4001ad48: 2b 20 00 00 sethi %hi(0x80000000), %l5
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001ad4c: 10 80 00 0b b 4001ad78 <rtems_rfs_dir_read+0x18c>
4001ad50: ac 15 a1 70 or %l6, 0x170, %l6
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001ad54: 92 07 bf b0 add %fp, -80, %o1
4001ad58: 7f ff fa 33 call 40019624 <rtems_rfs_block_map_next_block>
4001ad5c: 90 10 00 18 mov %i0, %o0
if (rc == ENXIO)
4001ad60: 80 a2 20 06 cmp %o0, 6
4001ad64: 02 80 00 90 be 4001afa4 <rtems_rfs_dir_read+0x3b8>
<== ALWAYS TAKEN
4001ad68: b6 10 00 08 mov %o0, %i3
while (rc == 0)
4001ad6c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ad70: 12 80 00 60 bne 4001aef0 <rtems_rfs_dir_read+0x304>
<== NOT EXECUTED
4001ad74: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001ad78: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001ad7c: 96 10 20 01 mov 1, %o3
4001ad80: 92 07 bf a4 add %fp, -92, %o1
4001ad84: 7f ff d2 d1 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001ad88: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001ad8c: b6 92 20 00 orcc %o0, 0, %i3
4001ad90: 14 80 00 57 bg 4001aeec <rtems_rfs_dir_read+0x300>
<== NEVER TAKEN
4001ad94: c2 07 bf ac ld [ %fp + -84 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
4001ad98: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
entry += map.bpos.boff;
4001ad9c: c6 07 bf c4 ld [ %fp + -60 ], %g3
4001ada0: a0 04 00 03 add %l0, %g3, %l0
4001ada4: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
4001ada8: e2 0c 20 09 ldub [ %l0 + 9 ], %l1
4001adac: 83 28 60 08 sll %g1, 8, %g1
elength = rtems_rfs_dir_entry_length (entry);
4001adb0: a2 14 40 01 or %l1, %g1, %l1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001adb4: 80 a4 40 1a cmp %l1, %i2
4001adb8: 12 80 00 59 bne 4001af1c <rtems_rfs_dir_read+0x330>
4001adbc: 90 10 00 14 mov %l4, %o0
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
4001adc0: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001adc4: c2 07 40 00 ld [ %i5 ], %g1
4001adc8: 84 20 80 03 sub %g2, %g3, %g2
4001adcc: 82 00 40 02 add %g1, %g2, %g1
4001add0: c2 27 40 00 st %g1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001add4: 7f ff e0 df call 40013150 <rtems_rfs_trace>
4001add8: 92 10 00 15 mov %l5, %o1
4001addc: 80 a2 20 00 cmp %o0, 0
4001ade0: 22 bf ff dd be,a 4001ad54 <rtems_rfs_dir_read+0x168>
<== ALWAYS TAKEN
4001ade4: 94 07 bf a0 add %fp, -96, %o2
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001ade8: d6 07 40 00 ld [ %i5 ], %o3
<== NOT EXECUTED
4001adec: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001adf0: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4001adf4: 7f ff e1 65 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001adf8: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001adfc: 10 bf ff d6 b 4001ad54 <rtems_rfs_dir_read+0x168>
<== NOT EXECUTED
4001ae00: 94 07 bf a0 add %fp, -96, %o2
<== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001ae04: 80 a0 40 1a cmp %g1, %i2
4001ae08: 0a 80 00 58 bcs 4001af68 <rtems_rfs_dir_read+0x37c>
<== NEVER TAKEN
4001ae0c: 90 10 20 00 clr %o0
memset (dirent, 0, sizeof (struct dirent));
4001ae10: 94 10 21 18 mov 0x118, %o2
4001ae14: 92 10 20 00 clr %o1
4001ae18: 40 00 0e 85 call 4001e82c <memset>
4001ae1c: 90 10 00 1c mov %i4, %o0
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
4001ae20: 92 07 bf c0 add %fp, -64, %o1
4001ae24: 7f ff f8 9d call 40019098 <rtems_rfs_block_get_pos>
4001ae28: 90 10 00 18 mov %i0, %o0
*length += elength;
4001ae2c: c2 07 40 00 ld [ %i5 ], %g1
dirent->d_reclen = sizeof (struct dirent);
4001ae30: 84 10 21 18 mov 0x118, %g2
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
4001ae34: d0 3f 20 08 std %o0, [ %i4 + 8 ]
*length += elength;
4001ae38: 82 04 40 01 add %l1, %g1, %g1
dirent->d_reclen = sizeof (struct dirent);
4001ae3c: c4 37 20 10 sth %g2, [ %i4 + 0x10 ]
*length += elength;
4001ae40: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001ae44: c6 07 bf c4 ld [ %fp + -60 ], %g3
4001ae48: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001ae4c: 84 20 80 03 sub %g2, %g3, %g2
4001ae50: 84 20 80 11 sub %g2, %l1, %g2
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
4001ae54: 80 a0 a0 0a cmp %g2, 0xa
4001ae58: 14 80 00 04 bg 4001ae68 <rtems_rfs_dir_read+0x27c>
<== ALWAYS TAKEN
4001ae5c: a2 04 7f f6 add %l1, -10, %l1
*length += remaining;
4001ae60: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4001ae64: c2 27 40 00 st %g1, [ %i5 ]
<== NOT EXECUTED
4001ae68: 80 a4 60 ff cmp %l1, 0xff
4001ae6c: 34 80 00 02 bg,a 4001ae74 <rtems_rfs_dir_read+0x288>
<== NEVER TAKEN
4001ae70: a2 10 20 ff mov 0xff, %l1
<== NOT EXECUTED
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
4001ae74: 94 10 00 11 mov %l1, %o2
4001ae78: 92 04 20 0a add %l0, 0xa, %o1
4001ae7c: ba 07 20 14 add %i4, 0x14, %i5
4001ae80: 40 00 0d e1 call 4001e604 <memcpy>
4001ae84: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001ae88: c8 0c 00 00 ldub [ %l0 ], %g4
4001ae8c: c4 0c 20 01 ldub [ %l0 + 1 ], %g2
4001ae90: c2 0c 20 02 ldub [ %l0 + 2 ], %g1
4001ae94: c6 0c 20 03 ldub [ %l0 + 3 ], %g3
4001ae98: 89 29 20 18 sll %g4, 0x18, %g4
4001ae9c: 85 28 a0 10 sll %g2, 0x10, %g2
4001aea0: 83 28 60 08 sll %g1, 8, %g1
4001aea4: 84 10 80 04 or %g2, %g4, %g2
dirent->d_namlen = elength;
4001aea8: e2 37 20 12 sth %l1, [ %i4 + 0x12 ]
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001aeac: 82 10 40 02 or %g1, %g2, %g1
4001aeb0: 82 10 c0 01 or %g3, %g1, %g1
4001aeb4: c2 27 00 00 st %g1, [ %i4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001aeb8: 90 10 20 00 clr %o0
4001aebc: 7f ff e0 a5 call 40013150 <rtems_rfs_trace>
4001aec0: 13 20 00 00 sethi %hi(0x80000000), %o1
4001aec4: 80 a2 20 00 cmp %o0, 0
4001aec8: 02 80 00 0a be 4001aef0 <rtems_rfs_dir_read+0x304>
<== ALWAYS TAKEN
4001aecc: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001aed0: d6 07 00 00 ld [ %i4 ], %o3
<== NOT EXECUTED
4001aed4: d2 07 20 08 ld [ %i4 + 8 ], %o1
<== NOT EXECUTED
4001aed8: d4 07 20 0c ld [ %i4 + 0xc ], %o2
<== NOT EXECUTED
4001aedc: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001aee0: 98 10 00 1d mov %i5, %o4
<== NOT EXECUTED
4001aee4: 7f ff e1 29 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001aee8: 90 12 21 38 or %o0, 0x138, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001aeec: 92 07 bf a4 add %fp, -92, %o1
4001aef0: 7f ff d3 3d call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001aef4: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
4001aef8: 92 07 bf b0 add %fp, -80, %o1
handle->dirty = false;
4001aefc: c0 2f bf a4 clrb [ %fp + -92 ]
4001af00: 90 10 00 18 mov %i0, %o0
handle->bnum = 0;
4001af04: c0 27 bf a8 clr [ %fp + -88 ]
}
4001af08: b0 10 00 1b mov %i3, %i0
rtems_rfs_block_map_close (fs, &map);
4001af0c: 7f ff f8 dc call 4001927c <rtems_rfs_block_map_close>
4001af10: c0 27 bf ac clr [ %fp + -84 ]
}
4001af14: 81 c7 e0 08 ret
4001af18: 81 e8 00 00 restore
eino = rtems_rfs_dir_entry_ino (entry);
4001af1c: c4 0c 00 00 ldub [ %l0 ], %g2
4001af20: c2 0c 20 01 ldub [ %l0 + 1 ], %g1
4001af24: d6 0c 20 02 ldub [ %l0 + 2 ], %o3
4001af28: c6 0c 20 03 ldub [ %l0 + 3 ], %g3
4001af2c: 85 28 a0 18 sll %g2, 0x18, %g2
4001af30: 83 28 60 10 sll %g1, 0x10, %g1
4001af34: 97 2a e0 08 sll %o3, 8, %o3
4001af38: 82 10 40 02 or %g1, %g2, %g1
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001af3c: 80 a4 60 0a cmp %l1, 0xa
eino = rtems_rfs_dir_entry_ino (entry);
4001af40: 96 12 c0 01 or %o3, %g1, %o3
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001af44: 04 80 00 08 ble 4001af64 <rtems_rfs_dir_read+0x378>
<== NEVER TAKEN
4001af48: b4 10 c0 0b or %g3, %o3, %i2
4001af4c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001af50: 80 a4 40 01 cmp %l1, %g1
4001af54: 1a 80 00 04 bcc 4001af64 <rtems_rfs_dir_read+0x378>
<== NEVER TAKEN
4001af58: 80 a6 a0 00 cmp %i2, 0
4001af5c: 32 bf ff aa bne,a 4001ae04 <rtems_rfs_dir_read+0x218>
<== ALWAYS TAKEN
4001af60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001af64: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001af68: 13 20 00 00 sethi %hi(0x80000000), %o1
<== NOT EXECUTED
4001af6c: 7f ff e0 79 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001af70: b6 10 20 05 mov 5, %i3
<== NOT EXECUTED
4001af74: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001af78: 22 bf ff de be,a 4001aef0 <rtems_rfs_dir_read+0x304>
<== NOT EXECUTED
4001af7c: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
4001af80: d8 07 bf c4 ld [ %fp + -60 ], %o4
<== NOT EXECUTED
4001af84: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
4001af88: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4001af8c: 94 10 00 11 mov %l1, %o2
<== NOT EXECUTED
4001af90: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001af94: 7f ff e0 fd call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001af98: 90 12 20 f0 or %o0, 0xf0, %o0 ! 40023cf0 <status_code_to_errno+0x7d4>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001af9c: 10 bf ff d5 b 4001aef0 <rtems_rfs_dir_read+0x304>
<== NOT EXECUTED
4001afa0: 92 07 bf a4 add %fp, -92, %o1
<== NOT EXECUTED
rc = ENOENT;
4001afa4: 10 bf ff d2 b 4001aeec <rtems_rfs_dir_read+0x300>
4001afa8: b6 10 20 02 mov 2, %i3
4001b560 <rtems_rfs_file_close>:
{
4001b560: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001b564: 90 10 20 10 mov 0x10, %o0
4001b568: 7f ff de fa call 40013150 <rtems_rfs_trace>
4001b56c: 92 10 20 00 clr %o1
4001b570: 80 a2 20 00 cmp %o0, 0
4001b574: 32 80 00 79 bne,a 4001b758 <rtems_rfs_file_close+0x1f8>
<== NEVER TAKEN
4001b578: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
if (handle->shared->references > 0)
4001b57c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001b580: fa 02 60 08 ld [ %o1 + 8 ], %i5
4001b584: 80 a7 60 00 cmp %i5, 0
4001b588: 04 80 00 05 ble 4001b59c <rtems_rfs_file_close+0x3c>
<== NEVER TAKEN
4001b58c: 01 00 00 00 nop
handle->shared->references--;
4001b590: ba 07 7f ff add %i5, -1, %i5
4001b594: fa 22 60 08 st %i5, [ %o1 + 8 ]
if (handle->shared->references == 0)
4001b598: 80 a7 60 00 cmp %i5, 0
4001b59c: 02 80 00 0b be 4001b5c8 <rtems_rfs_file_close+0x68>
<== ALWAYS TAKEN
4001b5a0: b8 06 60 04 add %i1, 4, %i4
4001b5a4: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001b5a8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001b5ac: 7f ff d1 8e call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001b5b0: ba 10 20 00 clr %i5
<== NOT EXECUTED
free (handle);
4001b5b4: 90 10 00 19 mov %i1, %o0
4001b5b8: 7f ff ac 08 call 400065d8 <free>
4001b5bc: b0 10 00 1d mov %i5, %i0
}
4001b5c0: 81 c7 e0 08 ret
4001b5c4: 81 e8 00 00 restore
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
4001b5c8: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001b5cc: 80 a0 a0 00 cmp %g2, 0
4001b5d0: 22 80 00 87 be,a 4001b7ec <rtems_rfs_file_close+0x28c>
<== ALWAYS TAKEN
4001b5d4: 92 02 60 0c add %o1, 0xc, %o1
rtems_rfs_inode_set_atime (&handle->shared->inode,
4001b5d8: c2 02 60 8c ld [ %o1 + 0x8c ], %g1
rtems_rfs_write_u32 (&handle->node->atime, atime);
4001b5dc: 87 30 60 18 srl %g1, 0x18, %g3
4001b5e0: c6 28 a0 10 stb %g3, [ %g2 + 0x10 ]
4001b5e4: 87 30 60 10 srl %g1, 0x10, %g3
4001b5e8: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001b5ec: c6 28 a0 11 stb %g3, [ %g2 + 0x11 ]
4001b5f0: 87 30 60 08 srl %g1, 8, %g3
4001b5f4: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001b5f8: c6 28 a0 12 stb %g3, [ %g2 + 0x12 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b5fc: 88 10 20 01 mov 1, %g4
rtems_rfs_write_u32 (&handle->node->atime, atime);
4001b600: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
4001b604: c2 28 a0 13 stb %g1, [ %g2 + 0x13 ]
rtems_rfs_inode_set_mtime (&handle->shared->inode,
4001b608: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
4001b60c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001b610: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b614: c8 2a 60 1c stb %g4, [ %o1 + 0x1c ]
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001b618: b7 30 60 18 srl %g1, 0x18, %i3
4001b61c: f6 28 e0 14 stb %i3, [ %g3 + 0x14 ]
4001b620: b7 30 60 10 srl %g1, 0x10, %i3
4001b624: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4001b628: f6 28 e0 15 stb %i3, [ %g3 + 0x15 ]
4001b62c: b7 30 60 08 srl %g1, 8, %i3
4001b630: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4001b634: f6 28 e0 16 stb %i3, [ %g3 + 0x16 ]
4001b638: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4001b63c: c2 28 e0 17 stb %g1, [ %g3 + 0x17 ]
rtems_rfs_inode_set_ctime (&handle->shared->inode,
4001b640: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001b644: c6 00 60 94 ld [ %g1 + 0x94 ], %g3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b648: c8 28 a0 1c stb %g4, [ %g2 + 0x1c ]
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4001b64c: b7 30 e0 18 srl %g3, 0x18, %i3
4001b650: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001b654: f6 28 a0 18 stb %i3, [ %g2 + 0x18 ]
4001b658: b7 30 e0 10 srl %g3, 0x10, %i3
4001b65c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001b660: f6 28 a0 19 stb %i3, [ %g2 + 0x19 ]
4001b664: b7 30 e0 08 srl %g3, 8, %i3
4001b668: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001b66c: f6 28 a0 1a stb %i3, [ %g2 + 0x1a ]
4001b670: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4001b674: c6 28 a0 1b stb %g3, [ %g2 + 0x1b ]
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001b678: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b67c: c8 28 60 1c stb %g4, [ %g1 + 0x1c ]
4001b680: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
4001b684: c4 02 60 3c ld [ %o1 + 0x3c ], %g2
4001b688: 80 a0 40 02 cmp %g1, %g2
4001b68c: 02 80 00 75 be 4001b860 <rtems_rfs_file_close+0x300>
<== ALWAYS TAKEN
4001b690: 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);
4001b694: c2 22 60 3c st %g1, [ %o1 + 0x3c ]
<== NOT EXECUTED
map->dirty = true;
4001b698: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
rtems_rfs_block_copy_size (&map->size, size);
4001b69c: c4 22 60 40 st %g2, [ %o1 + 0x40 ]
<== NOT EXECUTED
map->dirty = true;
4001b6a0: c2 2a 60 34 stb %g1, [ %o1 + 0x34 ]
<== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
4001b6a4: 92 02 60 34 add %o1, 0x34, %o1
<== NOT EXECUTED
4001b6a8: 7f ff f6 f5 call 4001927c <rtems_rfs_block_map_close>
4001b6ac: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b6b0: b6 92 20 00 orcc %o0, 0, %i3
4001b6b4: 14 80 00 44 bg 4001b7c4 <rtems_rfs_file_close+0x264>
<== NEVER TAKEN
4001b6b8: 90 10 20 10 mov 0x10, %o0
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001b6bc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001b6c0: 92 02 60 0c add %o1, 0xc, %o1
4001b6c4: 7f ff d8 e5 call 40011a58 <rtems_rfs_inode_close>
4001b6c8: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001b6cc: b6 92 20 00 orcc %o0, 0, %i3
4001b6d0: 34 80 00 28 bg,a 4001b770 <rtems_rfs_file_close+0x210>
<== NEVER TAKEN
4001b6d4: 90 10 20 10 mov 0x10, %o0
<== NOT EXECUTED
4001b6d8: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
4001b6dc: c4 02 00 00 ld [ %o0 ], %g2
4001b6e0: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
4001b6e4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
free (handle->shared);
4001b6e8: 7f ff ab bc call 400065d8 <free>
4001b6ec: c4 20 40 00 st %g2, [ %g1 ]
4001b6f0: 92 10 00 1c mov %i4, %o1
4001b6f4: 7f ff d1 3c call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001b6f8: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001b6fc: c0 2e 60 04 clrb [ %i1 + 4 ]
if (rrc > 0)
4001b700: 80 a7 60 00 cmp %i5, 0
handle->bnum = 0;
4001b704: c0 26 60 08 clr [ %i1 + 8 ]
4001b708: 04 bf ff ab ble 4001b5b4 <rtems_rfs_file_close+0x54>
<== ALWAYS TAKEN
4001b70c: c0 26 60 0c clr [ %i1 + 0xc ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001b710: 90 10 20 10 mov 0x10, %o0
<== NOT EXECUTED
4001b714: 7f ff de 8f call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b718: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b71c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b720: 22 bf ff a6 be,a 4001b5b8 <rtems_rfs_file_close+0x58>
<== NOT EXECUTED
4001b724: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001b728: 40 00 0f 5e call 4001f4a0 <strerror>
<== NOT EXECUTED
4001b72c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001b730: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001b734: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001b738: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b73c: 7f ff df 13 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b740: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 40023fa0 <status_code_to_errno+0xa84>
<== NOT EXECUTED
free (handle);
4001b744: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4001b748: 7f ff ab a4 call 400065d8 <free>
<== NOT EXECUTED
4001b74c: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4001b750: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b754: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
4001b758: d2 00 60 14 ld [ %g1 + 0x14 ], %o1
<== NOT EXECUTED
4001b75c: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b760: 7f ff df 0a call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b764: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 40023ef8 <status_code_to_errno+0x9dc>
<== NOT EXECUTED
if (handle->shared->references > 0)
4001b768: 10 bf ff 86 b 4001b580 <rtems_rfs_file_close+0x20>
<== NOT EXECUTED
4001b76c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001b770: 7f ff de 78 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b774: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b778: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b77c: 32 80 00 23 bne,a 4001b808 <rtems_rfs_file_close+0x2a8>
<== NOT EXECUTED
4001b780: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
4001b784: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
<== NOT EXECUTED
4001b788: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
if (rrc == 0)
4001b78c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001b790: 12 bf ff d5 bne 4001b6e4 <rtems_rfs_file_close+0x184>
<== NOT EXECUTED
4001b794: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
4001b798: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
handle->buffer = NULL;
4001b79c: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
free (handle->shared);
4001b7a0: 7f ff ab 8e call 400065d8 <free>
<== NOT EXECUTED
4001b7a4: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001b7a8: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001b7ac: 7f ff d1 0e call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001b7b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->dirty = false;
4001b7b4: c0 2e 60 04 clrb [ %i1 + 4 ]
<== NOT EXECUTED
handle->bnum = 0;
4001b7b8: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
handle->buffer = NULL;
4001b7bc: 10 bf ff d5 b 4001b710 <rtems_rfs_file_close+0x1b0>
<== NOT EXECUTED
4001b7c0: c0 26 60 0c clr [ %i1 + 0xc ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001b7c4: 7f ff de 63 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b7c8: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b7cc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b7d0: 32 80 00 19 bne,a 4001b834 <rtems_rfs_file_close+0x2d4>
<== NOT EXECUTED
4001b7d4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
if (rrc == 0)
4001b7d8: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001b7dc: 22 bf ff b8 be,a 4001b6bc <rtems_rfs_file_close+0x15c>
<== NOT EXECUTED
4001b7e0: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001b7e4: 10 bf ff b7 b 4001b6c0 <rtems_rfs_file_close+0x160>
<== NOT EXECUTED
4001b7e8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
<== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
4001b7ec: 7f ff d7 f7 call 400117c8 <rtems_rfs_inode_load>
4001b7f0: 90 10 00 18 mov %i0, %o0
if (rrc == 0)
4001b7f4: 80 a2 20 00 cmp %o0, 0
4001b7f8: 12 80 00 20 bne 4001b878 <rtems_rfs_file_close+0x318>
<== NEVER TAKEN
4001b7fc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001b800: 10 bf ff 76 b 4001b5d8 <rtems_rfs_file_close+0x78>
4001b804: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
4001b808: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
<== NOT EXECUTED
4001b80c: 40 00 0f 25 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001b810: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4001b814: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4001b818: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001b81c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001b820: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b824: 7f ff de d9 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b828: 90 12 23 60 or %o0, 0x360, %o0 ! 40023f60 <status_code_to_errno+0xa44>
<== NOT EXECUTED
4001b82c: 10 bf ff d7 b 4001b788 <rtems_rfs_file_close+0x228>
<== NOT EXECUTED
4001b830: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
<== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
4001b834: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
<== NOT EXECUTED
4001b838: 40 00 0f 1a call 4001f4a0 <strerror>
<== NOT EXECUTED
4001b83c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4001b840: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4001b844: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001b848: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001b84c: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b850: 7f ff de ce call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b854: 90 12 23 20 or %o0, 0x320, %o0 ! 40023f20 <status_code_to_errno+0xa04>
<== NOT EXECUTED
if (rrc == 0)
4001b858: 10 bf ff e1 b 4001b7dc <rtems_rfs_file_close+0x27c>
<== NOT EXECUTED
4001b85c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001b860: c6 02 60 40 ld [ %o1 + 0x40 ], %g3
4001b864: 80 a0 80 03 cmp %g2, %g3
4001b868: 32 bf ff 8c bne,a 4001b698 <rtems_rfs_file_close+0x138>
<== NEVER TAKEN
4001b86c: c2 22 60 3c st %g1, [ %o1 + 0x3c ]
<== NOT EXECUTED
4001b870: 10 bf ff 8e b 4001b6a8 <rtems_rfs_file_close+0x148>
4001b874: 92 02 60 34 add %o1, 0x34, %o1
if (rrc == 0)
4001b878: 10 bf ff 8b b 4001b6a4 <rtems_rfs_file_close+0x144>
<== NOT EXECUTED
4001b87c: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
4001c230 <rtems_rfs_file_get_shared>:
return _Chain_Immutable_head( the_chain )->next;
4001c230: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
return &the_chain->Tail.Node;
4001c234: 90 02 20 78 add %o0, 0x78, %o0
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001c238: 80 a0 40 08 cmp %g1, %o0
4001c23c: 22 80 00 10 be,a 4001c27c <rtems_rfs_file_get_shared+0x4c>
4001c240: 82 10 20 00 clr %g1
if (shared->inode.ino == ino)
4001c244: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4001c248: 80 a2 40 02 cmp %o1, %g2
4001c24c: 32 80 00 08 bne,a 4001c26c <rtems_rfs_file_get_shared+0x3c>
<== NEVER TAKEN
4001c250: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
4001c254: 81 c3 e0 08 retl
4001c258: 90 10 00 01 mov %g1, %o0
if (shared->inode.ino == ino)
4001c25c: 80 a0 80 09 cmp %g2, %o1
<== NOT EXECUTED
4001c260: 22 80 00 08 be,a 4001c280 <rtems_rfs_file_get_shared+0x50>
<== NOT EXECUTED
4001c264: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4001c268: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001c26c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4001c270: 32 bf ff fb bne,a 4001c25c <rtems_rfs_file_get_shared+0x2c>
<== NOT EXECUTED
4001c274: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
<== NOT EXECUTED
return NULL;
4001c278: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4001c27c: 90 10 00 01 mov %g1, %o0
4001c280: 81 c3 e0 08 retl
4001c284: 01 00 00 00 nop
4001bb0c <rtems_rfs_file_io_end>:
{
4001bb0c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001bb10: 90 10 20 20 mov 0x20, %o0
4001bb14: 92 10 20 00 clr %o1
4001bb18: 7f ff dd 8e call 40013150 <rtems_rfs_trace>
4001bb1c: ba 10 00 18 mov %i0, %i5
4001bb20: 80 a2 20 00 cmp %o0, 0
4001bb24: 22 80 00 0c be,a 4001bb54 <rtems_rfs_file_io_end+0x48>
<== ALWAYS TAKEN
4001bb28: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001bb2c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001bb30: 12 80 00 35 bne 4001bc04 <rtems_rfs_file_io_end+0xf8>
<== NOT EXECUTED
4001bb34: 13 10 00 87 sethi %hi(0x40021c00), %o1
<== NOT EXECUTED
4001bb38: 13 10 00 8f sethi %hi(0x40023c00), %o1
<== NOT EXECUTED
4001bb3c: 92 12 63 c8 or %o1, 0x3c8, %o1 ! 40023fc8 <status_code_to_errno+0xaac>
<== NOT EXECUTED
4001bb40: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001bb44: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001bb48: 7f ff de 10 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001bb4c: 90 12 20 88 or %o0, 0x88, %o0
<== NOT EXECUTED
4001bb50: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001bb54: c4 07 60 0c ld [ %i5 + 0xc ], %g2
4001bb58: 80 a0 a0 00 cmp %g2, 0
4001bb5c: 02 80 00 2c be 4001bc0c <rtems_rfs_file_io_end+0x100>
<== NEVER TAKEN
4001bb60: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (!read)
4001bb64: 80 a6 a0 00 cmp %i2, 0
4001bb68: 02 80 00 14 be 4001bbb8 <rtems_rfs_file_io_end+0xac>
4001bb6c: 92 07 60 04 add %i5, 4, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001bb70: 7f ff d0 1d call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001bb74: 01 00 00 00 nop
if (rc > 0)
4001bb78: b0 92 20 00 orcc %o0, 0, %i0
4001bb7c: 24 80 00 9b ble,a 4001bde8 <rtems_rfs_file_io_end+0x2dc>
<== ALWAYS TAKEN
4001bb80: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
printf (
4001bb84: 40 00 0e 47 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001bb88: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001bb8c: 3b 10 00 87 sethi %hi(0x40021c00), %i5
<== NOT EXECUTED
4001bb90: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001bb94: ba 17 62 40 or %i5, 0x240, %i5
<== NOT EXECUTED
4001bb98: 96 10 00 18 mov %i0, %o3
<== NOT EXECUTED
4001bb9c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001bba0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001bba4: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001bba8: 7f ff dd f8 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001bbac: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400240b0 <status_code_to_errno+0xb94>
<== NOT EXECUTED
return rc;
4001bbb0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001bbb4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001bbb8: 82 10 20 01 mov 1, %g1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001bbbc: 7f ff d0 0a call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001bbc0: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
if (rc > 0)
4001bbc4: b0 92 20 00 orcc %o0, 0, %i0
4001bbc8: 24 80 00 49 ble,a 4001bcec <rtems_rfs_file_io_end+0x1e0>
<== ALWAYS TAKEN
4001bbcc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
printf (
4001bbd0: 40 00 0e 34 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001bbd4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001bbd8: 3b 10 00 8f sethi %hi(0x40023c00), %i5
<== NOT EXECUTED
4001bbdc: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
4001bbe0: ba 17 63 c8 or %i5, 0x3c8, %i5
<== NOT EXECUTED
4001bbe4: 96 10 00 18 mov %i0, %o3
<== NOT EXECUTED
4001bbe8: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001bbec: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001bbf0: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001bbf4: 7f ff dd e5 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001bbf8: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400240b0 <status_code_to_errno+0xb94>
<== NOT EXECUTED
return rc;
4001bbfc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001bc00: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001bc04: 10 bf ff cf b 4001bb40 <rtems_rfs_file_io_end+0x34>
<== NOT EXECUTED
4001bc08: 92 12 62 40 or %o1, 0x240, %o1
<== NOT EXECUTED
handle->bpos.boff += size;
4001bc0c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
4001bc10: b2 06 40 02 add %i1, %g2, %i1
<== NOT EXECUTED
4001bc14: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
<== NOT EXECUTED
4001bc18: 86 1e a0 01 xor %i2, 1, %g3
<== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bc1c: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
if (handle->bpos.boff >=
4001bc20: 80 a6 40 02 cmp %i1, %g2
<== NOT EXECUTED
4001bc24: 1a 80 00 3a bcc 4001bd0c <rtems_rfs_file_io_end+0x200>
<== NOT EXECUTED
4001bc28: b0 10 20 00 clr %i0
<== NOT EXECUTED
if (!read &&
4001bc2c: 80 a6 a0 00 cmp %i2, 0
4001bc30: 12 80 00 0e bne 4001bc68 <rtems_rfs_file_io_end+0x15c>
4001bc34: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001bc38: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if (!read &&
4001bc3c: 80 a7 20 00 cmp %i4, 0
4001bc40: 02 80 00 39 be 4001bd24 <rtems_rfs_file_io_end+0x218>
4001bc44: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001bc48: 80 a0 a0 00 cmp %g2, 0
4001bc4c: 12 80 00 37 bne 4001bd28 <rtems_rfs_file_io_end+0x21c>
<== ALWAYS TAKEN
4001bc50: 80 a7 00 02 cmp %i4, %g2
4001bc54: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
<== NOT EXECUTED
map->size.offset = offset;
4001bc58: c8 20 60 40 st %g4, [ %g1 + 0x40 ]
map->dirty = true;
4001bc5c: 88 10 20 01 mov 1, %g4
4001bc60: c8 28 60 34 stb %g4, [ %g1 + 0x34 ]
length = true;
4001bc64: 84 10 20 01 mov 1, %g2
atime = rtems_rfs_file_update_atime (handle);
4001bc68: e0 07 40 00 ld [ %i5 ], %l0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001bc6c: 90 10 20 20 mov 0x20, %o0
4001bc70: 92 10 20 00 clr %o1
atime = rtems_rfs_file_update_atime (handle);
4001bc74: b2 38 00 10 xnor %g0, %l0, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001bc78: b9 34 20 01 srl %l0, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001bc7c: b7 34 20 02 srl %l0, 2, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001bc80: b8 1f 20 01 xor %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001bc84: b6 1e e0 01 xor %i3, 1, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001bc88: b8 0f 20 01 and %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001bc8c: b6 0e e0 01 and %i3, 1, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001bc90: b8 0f 00 03 and %i4, %g3, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001bc94: b6 0e c0 02 and %i3, %g2, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001bc98: 7f ff dd 2e call 40013150 <rtems_rfs_trace>
4001bc9c: b2 0e 60 01 and %i1, 1, %i1
4001bca0: 80 a2 20 00 cmp %o0, 0
4001bca4: 32 80 00 30 bne,a 4001bd64 <rtems_rfs_file_io_end+0x258>
<== NEVER TAKEN
4001bca8: d4 07 60 14 ld [ %i5 + 0x14 ], %o2
<== NOT EXECUTED
4001bcac: b8 0f 20 ff and %i4, 0xff, %i4
4001bcb0: b6 0e e0 ff and %i3, 0xff, %i3
if (atime || mtime)
4001bcb4: b2 8e 60 ff andcc %i1, 0xff, %i1
4001bcb8: 12 80 00 3d bne 4001bdac <rtems_rfs_file_io_end+0x2a0>
<== ALWAYS TAKEN
4001bcbc: 80 a7 20 00 cmp %i4, 0
4001bcc0: 12 80 00 3b bne 4001bdac <rtems_rfs_file_io_end+0x2a0>
<== NOT EXECUTED
4001bcc4: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
if (length)
4001bcc8: 02 80 00 25 be 4001bd5c <rtems_rfs_file_io_end+0x250>
4001bccc: 01 00 00 00 nop
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
4001bcd0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->shared->size.count =
4001bcd4: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
handle->shared->size.offset =
4001bcd8: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
handle->shared->size.count =
4001bcdc: c6 20 60 84 st %g3, [ %g1 + 0x84 ]
handle->shared->size.offset =
4001bce0: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
4001bce4: 81 c7 e0 08 ret
4001bce8: 81 e8 00 00 restore
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bcec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->bpos.boff += size;
4001bcf0: b2 06 40 02 add %i1, %g2, %i1
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bcf4: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
handle->bpos.boff += size;
4001bcf8: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bcfc: c4 00 a0 08 ld [ %g2 + 8 ], %g2
if (handle->bpos.boff >=
4001bd00: 80 a0 80 19 cmp %g2, %i1
4001bd04: 18 bf ff cd bgu 4001bc38 <rtems_rfs_file_io_end+0x12c>
4001bd08: 86 10 20 01 mov 1, %g3
handle->bpos.bno++;
4001bd0c: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
4001bd10: 88 01 20 01 inc %g4
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001bd14: b2 26 40 02 sub %i1, %g2, %i1
handle->bpos.bno++;
4001bd18: c8 27 60 10 st %g4, [ %i5 + 0x10 ]
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001bd1c: 10 bf ff c4 b 4001bc2c <rtems_rfs_file_io_end+0x120>
4001bd20: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001bd24: 80 a7 00 02 cmp %i4, %g2
4001bd28: 3a bf ff cc bcc,a 4001bc58 <rtems_rfs_file_io_end+0x14c>
4001bd2c: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
4001bd30: 88 00 bf ff add %g2, -1, %g4
4001bd34: 80 a7 00 04 cmp %i4, %g4
4001bd38: 12 bf ff cc bne 4001bc68 <rtems_rfs_file_io_end+0x15c>
4001bd3c: 84 10 20 00 clr %g2
4001bd40: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
4001bd44: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
4001bd48: 80 a1 00 1c cmp %g4, %i4
4001bd4c: 28 bf ff c8 bleu,a 4001bc6c <rtems_rfs_file_io_end+0x160>
4001bd50: e0 07 40 00 ld [ %i5 ], %l0
4001bd54: 10 bf ff c2 b 4001bc5c <rtems_rfs_file_io_end+0x150>
4001bd58: c8 20 60 40 st %g4, [ %g1 + 0x40 ]
}
4001bd5c: 81 c7 e0 08 ret
4001bd60: 81 e8 00 00 restore
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
4001bd64: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
<== NOT EXECUTED
4001bd68: 96 0c 20 01 and %l0, 1, %o3
<== NOT EXECUTED
4001bd6c: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
4001bd70: b6 0e e0 ff and %i3, 0xff, %i3
<== NOT EXECUTED
4001bd74: 98 07 3f ff add %i4, -1, %o4
<== NOT EXECUTED
4001bd78: 9a 06 ff ff add %i3, -1, %o5
<== NOT EXECUTED
4001bd7c: 96 20 00 0b neg %o3
<== NOT EXECUTED
4001bd80: 98 0b 3f e0 and %o4, -32, %o4
<== NOT EXECUTED
4001bd84: 96 0a ff ec and %o3, -20, %o3
<== NOT EXECUTED
4001bd88: 98 03 20 4d add %o4, 0x4d, %o4
<== NOT EXECUTED
4001bd8c: 9a 0b 7f e1 and %o5, -31, %o5
<== NOT EXECUTED
4001bd90: 96 02 e0 41 add %o3, 0x41, %o3
<== NOT EXECUTED
4001bd94: 9a 03 60 4c add %o5, 0x4c, %o5
<== NOT EXECUTED
4001bd98: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001bd9c: 7f ff dd 7b call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001bda0: 90 12 20 f8 or %o0, 0xf8, %o0 ! 400240f8 <status_code_to_errno+0xbdc>
<== NOT EXECUTED
if (atime || mtime)
4001bda4: 10 bf ff c5 b 4001bcb8 <rtems_rfs_file_io_end+0x1ac>
<== NOT EXECUTED
4001bda8: b2 8e 60 ff andcc %i1, 0xff, %i1
<== NOT EXECUTED
time_t now = time (NULL);
4001bdac: 40 00 0e ed call 4001f960 <time>
4001bdb0: 90 10 20 00 clr %o0
if (read && atime)
4001bdb4: 80 a6 a0 00 cmp %i2, 0
4001bdb8: 02 80 00 06 be 4001bdd0 <rtems_rfs_file_io_end+0x2c4>
4001bdbc: 80 a6 60 00 cmp %i1, 0
4001bdc0: 02 80 00 05 be 4001bdd4 <rtems_rfs_file_io_end+0x2c8>
<== NEVER TAKEN
4001bdc4: 80 a7 20 00 cmp %i4, 0
handle->shared->atime = now;
4001bdc8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001bdcc: d2 20 60 8c st %o1, [ %g1 + 0x8c ]
if (!read && mtime)
4001bdd0: 80 a7 20 00 cmp %i4, 0
4001bdd4: 02 bf ff bd be 4001bcc8 <rtems_rfs_file_io_end+0x1bc>
4001bdd8: 80 a6 e0 00 cmp %i3, 0
handle->shared->mtime = now;
4001bddc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001bde0: 10 bf ff ba b 4001bcc8 <rtems_rfs_file_io_end+0x1bc>
4001bde4: d2 20 60 90 st %o1, [ %g1 + 0x90 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bde8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->bpos.boff += size;
4001bdec: b2 06 40 02 add %i1, %g2, %i1
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bdf0: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
handle->bpos.boff += size;
4001bdf4: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001bdf8: c4 00 a0 08 ld [ %g2 + 8 ], %g2
if (handle->bpos.boff >=
4001bdfc: 80 a6 40 02 cmp %i1, %g2
4001be00: 1a bf ff c3 bcc 4001bd0c <rtems_rfs_file_io_end+0x200>
4001be04: 86 10 20 00 clr %g3
length = false;
4001be08: 10 bf ff 98 b 4001bc68 <rtems_rfs_file_io_end+0x15c>
4001be0c: 84 10 20 00 clr %g2
4001b880 <rtems_rfs_file_io_start>:
{
4001b880: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001b884: 90 10 20 20 mov 0x20, %o0
4001b888: 92 10 20 00 clr %o1
4001b88c: 7f ff de 31 call 40013150 <rtems_rfs_trace>
4001b890: ba 10 00 18 mov %i0, %i5
4001b894: 80 a2 20 00 cmp %o0, 0
4001b898: 22 80 00 0d be,a 4001b8cc <rtems_rfs_file_io_start+0x4c>
<== ALWAYS TAKEN
4001b89c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001b8a0: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001b8a4: 22 80 00 2f be,a 4001b960 <rtems_rfs_file_io_start+0xe0>
<== NOT EXECUTED
4001b8a8: 13 10 00 8f sethi %hi(0x40023c00), %o1
<== NOT EXECUTED
4001b8ac: 13 10 00 87 sethi %hi(0x40021c00), %o1
<== NOT EXECUTED
4001b8b0: 92 12 62 40 or %o1, 0x240, %o1 ! 40021e40 <ramdisk_ops+0x128>
<== NOT EXECUTED
4001b8b4: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
<== NOT EXECUTED
4001b8b8: d4 07 60 10 ld [ %i5 + 0x10 ], %o2
<== NOT EXECUTED
4001b8bc: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b8c0: 7f ff de b2 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b8c4: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 40023fd0 <status_code_to_errno+0xab4>
<== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001b8c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4001b8cc: 80 a0 60 00 cmp %g1, 0
4001b8d0: 02 80 00 30 be 4001b990 <rtems_rfs_file_io_start+0x110>
4001b8d4: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
if (read
4001b8d8: 80 a6 a0 00 cmp %i2, 0
4001b8dc: 22 80 00 0e be,a 4001b914 <rtems_rfs_file_io_start+0x94>
4001b8e0: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001b8e4: c4 02 60 44 ld [ %o1 + 0x44 ], %g2
4001b8e8: 80 a0 a0 00 cmp %g2, 0
4001b8ec: 12 80 00 1f bne 4001b968 <rtems_rfs_file_io_start+0xe8>
4001b8f0: c2 02 60 3c ld [ %o1 + 0x3c ], %g1
4001b8f4: 80 a0 60 00 cmp %g1, 0
4001b8f8: 12 80 00 1d bne 4001b96c <rtems_rfs_file_io_start+0xec>
<== ALWAYS TAKEN
4001b8fc: 82 00 7f ff add %g1, -1, %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001b900: f8 02 60 40 ld [ %o1 + 0x40 ], %i4
<== NOT EXECUTED
4001b904: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4001b908: 32 80 00 05 bne,a 4001b91c <rtems_rfs_file_io_start+0x9c>
<== NOT EXECUTED
4001b90c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001b910: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
<== NOT EXECUTED
4001b914: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
4001b918: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001b91c: 82 27 00 01 sub %i4, %g1, %g1
4001b920: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001b924: 90 10 20 20 mov 0x20, %o0
4001b928: 92 10 20 00 clr %o1
4001b92c: 7f ff de 09 call 40013150 <rtems_rfs_trace>
4001b930: b0 10 20 00 clr %i0
4001b934: 80 a2 20 00 cmp %o0, 0
4001b938: 32 80 00 04 bne,a 4001b948 <rtems_rfs_file_io_start+0xc8>
<== NEVER TAKEN
4001b93c: d2 06 40 00 ld [ %i1 ], %o1
<== NOT EXECUTED
}
4001b940: 81 c7 e0 08 ret
4001b944: 81 e8 00 00 restore
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
4001b948: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001b94c: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001b950: 7f ff de 8e call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b954: 90 12 20 58 or %o0, 0x58, %o0 ! 40024058 <status_code_to_errno+0xb3c>
<== NOT EXECUTED
}
4001b958: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b95c: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001b960: 10 bf ff d5 b 4001b8b4 <rtems_rfs_file_io_start+0x34>
<== NOT EXECUTED
4001b964: 92 12 63 c8 or %o1, 0x3c8, %o1
<== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001b968: 82 00 7f ff add %g1, -1, %g1
4001b96c: 80 a0 80 01 cmp %g2, %g1
4001b970: 32 bf ff e9 bne,a 4001b914 <rtems_rfs_file_io_start+0x94>
4001b974: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001b978: f8 02 60 40 ld [ %o1 + 0x40 ], %i4
4001b97c: 80 a7 20 00 cmp %i4, 0
4001b980: 32 bf ff e7 bne,a 4001b91c <rtems_rfs_file_io_start+0x9c>
4001b984: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001b988: 10 bf ff e3 b 4001b914 <rtems_rfs_file_io_start+0x94>
4001b98c: c2 02 60 98 ld [ %o1 + 0x98 ], %g1
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001b990: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001b994: 94 07 60 10 add %i5, 0x10, %o2
4001b998: 96 07 bf fc add %fp, -4, %o3
4001b99c: 7f ff f6 ab call 40019448 <rtems_rfs_block_map_find>
4001b9a0: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001b9a4: b0 92 20 00 orcc %o0, 0, %i0
4001b9a8: 04 80 00 0b ble 4001b9d4 <rtems_rfs_file_io_start+0x154>
4001b9ac: 82 1e 20 06 xor %i0, 6, %g1
if (read && (rc == ENXIO))
4001b9b0: 80 a0 00 01 cmp %g0, %g1
4001b9b4: 82 60 3f ff subx %g0, -1, %g1
4001b9b8: 82 0e 80 01 and %i2, %g1, %g1
4001b9bc: 80 a0 60 00 cmp %g1, 0
4001b9c0: 02 80 00 29 be 4001ba64 <rtems_rfs_file_io_start+0x1e4>
<== ALWAYS TAKEN
4001b9c4: b8 10 00 01 mov %g1, %i4
*available = 0;
4001b9c8: c0 26 40 00 clr [ %i1 ]
<== NOT EXECUTED
return 0;
4001b9cc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b9d0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
if (!read &&
4001b9d4: 80 a6 a0 00 cmp %i2, 0
4001b9d8: 12 80 00 3d bne 4001bacc <rtems_rfs_file_io_start+0x24c>
4001b9dc: 90 10 20 20 mov 0x20, %o0
4001b9e0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001b9e4: 80 a0 60 00 cmp %g1, 0
4001b9e8: 12 80 00 3a bne 4001bad0 <rtems_rfs_file_io_start+0x250>
4001b9ec: 92 10 20 00 clr %o1
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001b9f0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001b9f4: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
(rtems_rfs_file_block_offset (handle) ||
4001b9f8: c4 06 40 00 ld [ %i1 ], %g2
4001b9fc: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001ba00: 80 a0 80 01 cmp %g2, %g1
4001ba04: 0a 80 00 33 bcs 4001bad0 <rtems_rfs_file_io_start+0x250>
<== ALWAYS TAKEN
4001ba08: 01 00 00 00 nop
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ba0c: 7f ff dd d1 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001ba10: 01 00 00 00 nop
<== NOT EXECUTED
4001ba14: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ba18: 02 80 00 08 be 4001ba38 <rtems_rfs_file_io_start+0x1b8>
<== NOT EXECUTED
4001ba1c: b8 10 20 00 clr %i4
<== NOT EXECUTED
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001ba20: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4001ba24: 15 10 00 8b sethi %hi(0x40022c00), %o2
<== NOT EXECUTED
4001ba28: 94 12 a0 a0 or %o2, 0xa0, %o2 ! 40022ca0 <ramdisk_ops+0xf88>
<== NOT EXECUTED
4001ba2c: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001ba30: 7f ff de 56 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001ba34: 90 12 20 20 or %o0, 0x20, %o0 ! 40024020 <status_code_to_errno+0xb04>
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001ba38: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001ba3c: d4 07 bf fc ld [ %fp + -4 ], %o2
4001ba40: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ba44: 96 0f 20 ff and %i4, 0xff, %o3
4001ba48: 7f ff cf a0 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001ba4c: 92 07 60 04 add %i5, 4, %o1
if (rc > 0)
4001ba50: b0 92 20 00 orcc %o0, 0, %i0
4001ba54: 14 bf ff c1 bg 4001b958 <rtems_rfs_file_io_start+0xd8>
<== NEVER TAKEN
4001ba58: 01 00 00 00 nop
4001ba5c: 10 bf ff 9f b 4001b8d8 <rtems_rfs_file_io_start+0x58>
4001ba60: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
if (rc != ENXIO)
4001ba64: 80 a6 20 06 cmp %i0, 6
4001ba68: 12 bf ff b6 bne 4001b940 <rtems_rfs_file_io_start+0xc0>
<== NEVER TAKEN
4001ba6c: 90 10 20 20 mov 0x20, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ba70: 7f ff dd b8 call 40013150 <rtems_rfs_trace>
4001ba74: 92 10 20 00 clr %o1
4001ba78: 80 a2 20 00 cmp %o0, 0
4001ba7c: 12 80 00 20 bne 4001bafc <rtems_rfs_file_io_start+0x27c>
<== NEVER TAKEN
4001ba80: 11 10 00 90 sethi %hi(0x40024000), %o0
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001ba84: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001ba88: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ba8c: 96 07 bf fc add %fp, -4, %o3
4001ba90: 94 10 20 01 mov 1, %o2
4001ba94: 7f ff f6 f1 call 40019658 <rtems_rfs_block_map_grow>
4001ba98: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001ba9c: b0 92 20 00 orcc %o0, 0, %i0
4001baa0: 14 bf ff a8 bg 4001b940 <rtems_rfs_file_io_start+0xc0>
4001baa4: 90 10 20 20 mov 0x20, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001baa8: 7f ff dd aa call 40013150 <rtems_rfs_trace>
4001baac: 92 10 20 00 clr %o1
4001bab0: 80 a2 20 00 cmp %o0, 0
4001bab4: 22 bf ff e1 be,a 4001ba38 <rtems_rfs_file_io_start+0x1b8>
<== ALWAYS TAKEN
4001bab8: b8 10 20 00 clr %i4
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001babc: 15 10 00 8b sethi %hi(0x40022c00), %o2
<== NOT EXECUTED
4001bac0: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4001bac4: 10 bf ff da b 4001ba2c <rtems_rfs_file_io_start+0x1ac>
<== NOT EXECUTED
4001bac8: 94 12 a0 a0 or %o2, 0xa0, %o2
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001bacc: 92 10 20 00 clr %o1
4001bad0: 7f ff dd a0 call 40013150 <rtems_rfs_trace>
4001bad4: 01 00 00 00 nop
4001bad8: 80 a2 20 00 cmp %o0, 0
4001badc: 02 80 00 06 be 4001baf4 <rtems_rfs_file_io_start+0x274>
<== ALWAYS TAKEN
4001bae0: b8 10 00 08 mov %o0, %i4
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001bae4: 15 10 00 8b sethi %hi(0x40022c00), %o2
<== NOT EXECUTED
4001bae8: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4001baec: 10 bf ff d0 b 4001ba2c <rtems_rfs_file_io_start+0x1ac>
<== NOT EXECUTED
4001baf0: 94 12 a0 98 or %o2, 0x98, %o2
<== NOT EXECUTED
4001baf4: 10 bf ff d1 b 4001ba38 <rtems_rfs_file_io_start+0x1b8>
4001baf8: b8 10 20 01 mov 1, %i4
printf ("rtems-rfs: file-io: start: grow\n");
4001bafc: 7f ff de 32 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001bb00: 90 12 20 00 mov %o0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001bb04: 10 bf ff e1 b 4001ba88 <rtems_rfs_file_io_start+0x208>
<== NOT EXECUTED
4001bb08: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
<== NOT EXECUTED
4001b238 <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)
{
4001b238: 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))
4001b23c: 90 10 20 08 mov 8, %o0
4001b240: 92 10 20 00 clr %o1
4001b244: 7f ff df c3 call 40013150 <rtems_rfs_trace>
4001b248: a2 10 00 18 mov %i0, %l1
4001b24c: 80 a2 20 00 cmp %o0, 0
4001b250: 12 80 00 4d bne 4001b384 <rtems_rfs_file_open+0x14c>
<== NEVER TAKEN
4001b254: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
4001b258: 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));
4001b25c: 92 10 20 01 mov 1, %o1
4001b260: 90 10 20 20 mov 0x20, %o0
4001b264: 7f ff ac 3d call 40006358 <calloc>
4001b268: b0 10 20 0c mov 0xc, %i0
if (!handle)
4001b26c: 80 a2 20 00 cmp %o0, 0
4001b270: 02 80 00 43 be 4001b37c <rtems_rfs_file_open+0x144>
<== NEVER TAKEN
4001b274: b8 10 00 08 mov %o0, %i4
handle->dirty = false;
4001b278: c0 2a 20 04 clrb [ %o0 + 4 ]
return &the_chain->Tail.Node;
4001b27c: a0 04 60 78 add %l1, 0x78, %l0
handle->bnum = 0;
4001b280: c0 22 20 08 clr [ %o0 + 8 ]
handle->buffer = NULL;
4001b284: c0 22 20 0c clr [ %o0 + 0xc ]
return _Chain_Immutable_head( the_chain )->next;
4001b288: 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))
4001b28c: 80 a7 40 10 cmp %i5, %l0
4001b290: 32 80 00 08 bne,a 4001b2b0 <rtems_rfs_file_open+0x78>
<== NEVER TAKEN
4001b294: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
4001b298: 10 80 00 17 b 4001b2f4 <rtems_rfs_file_open+0xbc>
4001b29c: 92 10 20 01 mov 1, %o1
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001b2a0: 80 a7 40 10 cmp %i5, %l0
<== NOT EXECUTED
4001b2a4: 02 80 00 14 be 4001b2f4 <rtems_rfs_file_open+0xbc>
<== NOT EXECUTED
4001b2a8: 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)
4001b2ac: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4001b2b0: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
4001b2b4: 32 bf ff fb bne,a 4001b2a0 <rtems_rfs_file_open+0x68>
<== NOT EXECUTED
4001b2b8: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
shared->references++;
4001b2bc: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4001b2c0: 82 00 60 01 inc %g1
<== NOT EXECUTED
4001b2c4: c2 27 60 08 st %g1, [ %i5 + 8 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001b2c8: 90 10 20 08 mov 8, %o0
<== NOT EXECUTED
4001b2cc: 7f ff df a1 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b2d0: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b2d4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b2d8: 32 80 00 30 bne,a 4001b398 <rtems_rfs_file_open+0x160>
<== NOT EXECUTED
4001b2dc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
handle->flags = oflag;
4001b2e0: f4 27 00 00 st %i2, [ %i4 ]
<== NOT EXECUTED
handle->shared = shared;
4001b2e4: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
*file = handle;
4001b2e8: f8 26 c0 00 st %i4, [ %i3 ]
return 0;
4001b2ec: 81 c7 e0 08 ret
4001b2f0: 91 e8 20 00 restore %g0, 0, %o0
shared = malloc (sizeof (rtems_rfs_file_shared));
4001b2f4: 90 10 20 9c mov 0x9c, %o0
4001b2f8: 7f ff ac 18 call 40006358 <calloc>
4001b2fc: a4 07 20 04 add %i4, 4, %l2
if (!shared)
4001b300: 80 a2 20 00 cmp %o0, 0
4001b304: 02 80 00 8f be 4001b540 <rtems_rfs_file_open+0x308>
<== NEVER TAKEN
4001b308: ba 10 00 08 mov %o0, %i5
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4001b30c: a6 07 60 0c add %i5, 0xc, %l3
4001b310: 96 10 20 01 mov 1, %o3
4001b314: 94 10 00 13 mov %l3, %o2
4001b318: 92 10 00 19 mov %i1, %o1
4001b31c: 7f ff d9 58 call 4001187c <rtems_rfs_inode_open>
4001b320: 90 10 00 11 mov %l1, %o0
if (rc > 0)
4001b324: b0 92 20 00 orcc %o0, 0, %i0
4001b328: 04 80 00 25 ble 4001b3bc <rtems_rfs_file_open+0x184>
<== ALWAYS TAKEN
4001b32c: 90 10 20 08 mov 8, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001b330: 7f ff df 88 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b334: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b338: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b33c: 02 80 00 09 be 4001b360 <rtems_rfs_file_open+0x128>
<== NOT EXECUTED
4001b340: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
4001b344: 40 00 10 57 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001b348: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001b34c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001b350: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001b354: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b358: 7f ff e0 0c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b35c: 90 12 22 58 or %o0, 0x258, %o0 ! 40023e58 <status_code_to_errno+0x93c>
<== NOT EXECUTED
free (shared);
4001b360: 7f ff ac 9e call 400065d8 <free>
<== NOT EXECUTED
4001b364: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001b368: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001b36c: 7f ff d2 1e call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001b370: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
free (handle);
4001b374: 7f ff ac 99 call 400065d8 <free>
<== NOT EXECUTED
4001b378: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rc;
4001b37c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b380: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
4001b384: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b388: 7f ff e0 00 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b38c: 90 12 22 10 or %o0, 0x210, %o0 ! 40023e10 <status_code_to_errno+0x8f4>
<== NOT EXECUTED
*file = NULL;
4001b390: 10 bf ff b3 b 4001b25c <rtems_rfs_file_open+0x24>
<== NOT EXECUTED
4001b394: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001b398: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
return 0;
4001b39c: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001b3a0: 7f ff df fa call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b3a4: 90 12 22 30 or %o0, 0x230, %o0
<== NOT EXECUTED
handle->flags = oflag;
4001b3a8: f4 27 00 00 st %i2, [ %i4 ]
<== NOT EXECUTED
handle->shared = shared;
4001b3ac: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
<== NOT EXECUTED
*file = handle;
4001b3b0: f8 26 c0 00 st %i4, [ %i3 ]
<== NOT EXECUTED
return 0;
4001b3b4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b3b8: 81 e8 00 00 restore
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
4001b3bc: 94 07 60 34 add %i5, 0x34, %o2
4001b3c0: 92 10 00 13 mov %l3, %o1
4001b3c4: 7f ff f7 4f call 40019100 <rtems_rfs_block_map_open>
4001b3c8: 90 10 00 11 mov %l1, %o0
if (rc > 0)
4001b3cc: b0 92 20 00 orcc %o0, 0, %i0
4001b3d0: 04 80 00 12 ble 4001b418 <rtems_rfs_file_open+0x1e0>
<== ALWAYS TAKEN
4001b3d4: 90 10 20 08 mov 8, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001b3d8: 7f ff df 5e call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001b3dc: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001b3e0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001b3e4: 02 80 00 0a be 4001b40c <rtems_rfs_file_open+0x1d4>
<== NOT EXECUTED
4001b3e8: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001b3ec: 40 00 10 2d call 4001f4a0 <strerror>
<== NOT EXECUTED
4001b3f0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001b3f4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001b3f8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001b3fc: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b400: 7f ff df e2 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b404: 90 12 22 90 or %o0, 0x290, %o0 ! 40023e90 <status_code_to_errno+0x974>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
4001b408: 92 10 00 13 mov %l3, %o1
<== NOT EXECUTED
4001b40c: 7f ff d9 93 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001b410: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4001b414: 30 bf ff d3 b,a 4001b360 <rtems_rfs_file_open+0x128>
<== NOT EXECUTED
shared->references = 1;
4001b418: 82 10 20 01 mov 1, %g1
4001b41c: c2 27 60 08 st %g1, [ %i5 + 8 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001b420: 94 10 20 00 clr %o2
4001b424: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
return rtems_rfs_read_u32 (&handle->node->block_count);
4001b428: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
4001b42c: f0 08 60 0c ldub [ %g1 + 0xc ], %i0
4001b430: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4001b434: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
4001b438: b1 2e 20 18 sll %i0, 0x18, %i0
4001b43c: 87 28 e0 10 sll %g3, 0x10, %g3
4001b440: 85 28 a0 08 sll %g2, 8, %g2
4001b444: 86 10 c0 18 or %g3, %i0, %g3
4001b448: 84 10 80 03 or %g2, %g3, %g2
4001b44c: 84 11 00 02 or %g4, %g2, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001b450: c4 27 60 84 st %g2, [ %i5 + 0x84 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001b454: 92 10 00 13 mov %l3, %o1
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001b458: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
4001b45c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001b460: 85 28 a0 08 sll %g2, 8, %g2
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001b464: 84 10 80 03 or %g2, %g3, %g2
4001b468: c4 27 60 88 st %g2, [ %i5 + 0x88 ]
return rtems_rfs_read_u32 (&handle->node->atime);
4001b46c: c8 08 60 13 ldub [ %g1 + 0x13 ], %g4
4001b470: f0 08 60 10 ldub [ %g1 + 0x10 ], %i0
4001b474: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
4001b478: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
4001b47c: b1 2e 20 18 sll %i0, 0x18, %i0
4001b480: 87 28 e0 10 sll %g3, 0x10, %g3
4001b484: 85 28 a0 08 sll %g2, 8, %g2
4001b488: 86 10 c0 18 or %g3, %i0, %g3
4001b48c: 84 10 80 03 or %g2, %g3, %g2
4001b490: 84 11 00 02 or %g4, %g2, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001b494: c4 27 60 8c st %g2, [ %i5 + 0x8c ]
return rtems_rfs_read_u32 (&handle->node->mtime);
4001b498: c8 08 60 17 ldub [ %g1 + 0x17 ], %g4
4001b49c: f0 08 60 14 ldub [ %g1 + 0x14 ], %i0
4001b4a0: c6 08 60 15 ldub [ %g1 + 0x15 ], %g3
4001b4a4: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
4001b4a8: b1 2e 20 18 sll %i0, 0x18, %i0
4001b4ac: 87 28 e0 10 sll %g3, 0x10, %g3
4001b4b0: 85 28 a0 08 sll %g2, 8, %g2
4001b4b4: 86 10 c0 18 or %g3, %i0, %g3
4001b4b8: 84 10 80 03 or %g2, %g3, %g2
4001b4bc: 84 11 00 02 or %g4, %g2, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
4001b4c0: c4 27 60 90 st %g2, [ %i5 + 0x90 ]
return rtems_rfs_read_u32 (&handle->node->ctime);
4001b4c4: c8 08 60 1b ldub [ %g1 + 0x1b ], %g4
4001b4c8: f0 08 60 18 ldub [ %g1 + 0x18 ], %i0
4001b4cc: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
4001b4d0: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
old_last = tail->previous;
4001b4d4: de 04 60 7c ld [ %l1 + 0x7c ], %o7
4001b4d8: 87 28 e0 10 sll %g3, 0x10, %g3
4001b4dc: 83 28 a0 08 sll %g2, 8, %g1
shared->fs = fs;
4001b4e0: e2 27 60 98 st %l1, [ %i5 + 0x98 ]
4001b4e4: b1 2e 20 18 sll %i0, 0x18, %i0
the_node->next = tail;
4001b4e8: e0 27 40 00 st %l0, [ %i5 ]
4001b4ec: 84 10 c0 18 or %g3, %i0, %g2
tail->previous = the_node;
4001b4f0: fa 24 60 7c st %i5, [ %l1 + 0x7c ]
4001b4f4: 82 10 40 02 or %g1, %g2, %g1
4001b4f8: 82 11 00 01 or %g4, %g1, %g1
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
4001b4fc: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
old_last->next = the_node;
4001b500: fa 23 c0 00 st %i5, [ %o7 ]
the_node->previous = old_last;
4001b504: de 27 60 04 st %o7, [ %i5 + 4 ]
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001b508: 7f ff d9 16 call 40011960 <rtems_rfs_inode_unload>
4001b50c: 90 10 00 11 mov %l1, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001b510: 90 10 20 08 mov 8, %o0
4001b514: 7f ff df 0f call 40013150 <rtems_rfs_trace>
4001b518: 92 10 20 00 clr %o1
4001b51c: 80 a2 20 00 cmp %o0, 0
4001b520: 22 bf ff 71 be,a 4001b2e4 <rtems_rfs_file_open+0xac>
<== ALWAYS TAKEN
4001b524: f4 27 00 00 st %i2, [ %i4 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001b528: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001b52c: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
4001b530: 7f ff df 96 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001b534: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 40023ec8 <status_code_to_errno+0x9ac>
<== NOT EXECUTED
handle->flags = oflag;
4001b538: 10 bf ff 6b b 4001b2e4 <rtems_rfs_file_open+0xac>
<== NOT EXECUTED
4001b53c: f4 27 00 00 st %i2, [ %i4 ]
<== NOT EXECUTED
4001b540: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4001b544: 7f ff d1 a8 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001b548: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
return ENOMEM;
4001b54c: b0 10 20 0c mov 0xc, %i0
<== NOT EXECUTED
free (handle);
4001b550: 7f ff ac 22 call 400065d8 <free>
<== NOT EXECUTED
4001b554: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return ENOMEM;
4001b558: 81 c7 e0 08 ret
<== NOT EXECUTED
4001b55c: 81 e8 00 00 restore
<== NOT EXECUTED
4001be10 <rtems_rfs_file_seek>:
{
4001be10: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001be14: 90 10 20 20 mov 0x20, %o0
4001be18: 92 10 20 00 clr %o1
4001be1c: 7f ff dc cd call 40013150 <rtems_rfs_trace>
4001be20: ba 10 00 18 mov %i0, %i5
4001be24: 80 a2 20 00 cmp %o0, 0
4001be28: 32 80 00 35 bne,a 4001befc <rtems_rfs_file_seek+0xec>
<== NEVER TAKEN
4001be2c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001be30: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001be34: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001be38: 7f ff f4 9f call 400190b4 <rtems_rfs_block_get_size>
4001be3c: 92 02 60 84 add %o1, 0x84, %o1
4001be40: 80 a6 40 08 cmp %i1, %o0
4001be44: 08 80 00 0f bleu 4001be80 <rtems_rfs_file_seek+0x70>
<== ALWAYS TAKEN
4001be48: 01 00 00 00 nop
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001be4c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4001be50: 80 a0 60 00 cmp %g1, 0
4001be54: 22 80 00 27 be,a 4001bef0 <rtems_rfs_file_seek+0xe0>
<== ALWAYS TAKEN
4001be58: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001be5c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4001be60: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
<== NOT EXECUTED
4001be64: 7f ff cf 60 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001be68: 92 07 60 04 add %i5, 4, %o1
<== NOT EXECUTED
if (rc > 0)
4001be6c: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4001be70: 24 80 00 20 ble,a 4001bef0 <rtems_rfs_file_seek+0xe0>
<== NOT EXECUTED
4001be74: f2 26 c0 00 st %i1, [ %i3 ]
<== NOT EXECUTED
}
4001be78: 81 c7 e0 08 ret
<== NOT EXECUTED
4001be7c: 81 e8 00 00 restore
<== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001be80: 12 80 00 04 bne 4001be90 <rtems_rfs_file_seek+0x80>
<== NEVER TAKEN
4001be84: 80 a6 80 09 cmp %i2, %o1
4001be88: 38 bf ff f2 bgu,a 4001be50 <rtems_rfs_file_seek+0x40>
4001be8c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
rtems_rfs_file_set_bpos (handle, pos);
4001be90: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001be94: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001be98: b8 07 60 10 add %i5, 0x10, %i4
4001be9c: 92 10 00 19 mov %i1, %o1
4001bea0: 96 10 00 1c mov %i4, %o3
4001bea4: 7f ff f4 6d call 40019058 <rtems_rfs_block_get_bpos>
4001bea8: 94 10 00 1a mov %i2, %o2
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001beac: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001beb0: 80 a0 60 00 cmp %g1, 0
4001beb4: 02 80 00 0e be 4001beec <rtems_rfs_file_seek+0xdc>
4001beb8: 96 07 bf fc add %fp, -4, %o3
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001bebc: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001bec0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001bec4: 94 10 00 1c mov %i4, %o2
4001bec8: 7f ff f5 60 call 40019448 <rtems_rfs_block_map_find>
4001becc: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001bed0: b0 92 20 00 orcc %o0, 0, %i0
4001bed4: 14 bf ff e9 bg 4001be78 <rtems_rfs_file_seek+0x68>
<== NEVER TAKEN
4001bed8: c2 07 bf fc ld [ %fp + -4 ], %g1
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
4001bedc: c4 07 60 08 ld [ %i5 + 8 ], %g2
4001bee0: 80 a0 80 01 cmp %g2, %g1
4001bee4: 32 bf ff df bne,a 4001be60 <rtems_rfs_file_seek+0x50>
<== NEVER TAKEN
4001bee8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
*new_pos = pos;
4001beec: f2 26 c0 00 st %i1, [ %i3 ]
4001bef0: f4 26 e0 04 st %i2, [ %i3 + 4 ]
}
4001bef4: 81 c7 e0 08 ret
4001bef8: 91 e8 20 00 restore %g0, 0, %o0
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
4001befc: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001bf00: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001bf04: 7f ff dd 21 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001bf08: 90 12 21 30 or %o0, 0x130, %o0 ! 40024130 <status_code_to_errno+0xc14>
<== NOT EXECUTED
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001bf0c: 10 bf ff ca b 4001be34 <rtems_rfs_file_seek+0x24>
<== NOT EXECUTED
4001bf10: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
<== NOT EXECUTED
4001bf14 <rtems_rfs_file_set_size>:
{
4001bf14: 9d e3 bf 90 save %sp, -112, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001bf18: 90 10 20 20 mov 0x20, %o0
4001bf1c: 92 10 20 00 clr %o1
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001bf20: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001bf24: 7f ff dc 8b call 40013150 <rtems_rfs_trace>
4001bf28: a4 10 00 19 mov %i1, %l2
4001bf2c: 80 a2 20 00 cmp %o0, 0
4001bf30: 12 80 00 54 bne 4001c080 <rtems_rfs_file_set_size+0x16c>
<== NEVER TAKEN
4001bf34: a6 10 00 1a mov %i2, %l3
size = rtems_rfs_file_size (handle);
4001bf38: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
4001bf3c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001bf40: 7f ff f4 5d call 400190b4 <rtems_rfs_block_get_size>
4001bf44: 92 02 60 84 add %o1, 0x84, %o1
if (size != new_size)
4001bf48: 80 a4 80 08 cmp %l2, %o0
4001bf4c: 02 80 00 41 be 4001c050 <rtems_rfs_file_set_size+0x13c>
<== ALWAYS TAKEN
4001bf50: 80 a4 c0 09 cmp %l3, %o1
4001bf54: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
<== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001bf58: a2 07 20 34 add %i4, 0x34, %l1
if (new_size == 0)
4001bf5c: 80 94 80 13 orcc %l2, %l3, %g0
4001bf60: 02 80 00 33 be 4001c02c <rtems_rfs_file_set_size+0x118>
4001bf64: e8 06 e0 98 ld [ %i3 + 0x98 ], %l4
4001bf68: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
if (size < new_size)
4001bf6c: 80 a4 80 08 cmp %l2, %o0
4001bf70: 18 80 00 4d bgu 4001c0a4 <rtems_rfs_file_set_size+0x190>
<== NEVER TAKEN
4001bf74: e0 05 20 08 ld [ %l4 + 8 ], %l0
4001bf78: 02 80 00 49 be 4001c09c <rtems_rfs_file_set_size+0x188>
<== ALWAYS TAKEN
4001bf7c: 80 a4 c0 09 cmp %l3, %o1
(((new_size - 1) /
4001bf80: 92 84 ff ff addcc %l3, -1, %o1
<== NOT EXECUTED
4001bf84: 94 10 20 00 clr %o2
4001bf88: 90 44 bf ff addx %l2, -1, %o0
4001bf8c: 40 00 10 95 call 400201e0 <__udivdi3>
4001bf90: 96 10 00 10 mov %l0, %o3
blocks =
4001bf94: b4 07 7f ff add %i5, -1, %i2
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001bf98: 94 10 20 00 clr %o2
blocks =
4001bf9c: b4 26 80 09 sub %i2, %o1, %i2
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001bfa0: 96 10 00 10 mov %l0, %o3
4001bfa4: 90 10 00 12 mov %l2, %o0
4001bfa8: 40 00 11 07 call 400203c4 <__umoddi3>
4001bfac: 92 10 00 13 mov %l3, %o1
if (blocks)
4001bfb0: 80 a6 a0 00 cmp %i2, 0
4001bfb4: 12 80 00 89 bne 4001c1d8 <rtems_rfs_file_set_size+0x2c4>
4001bfb8: b2 10 00 09 mov %o1, %i1
map->size.offset = offset;
4001bfbc: f2 27 20 40 st %i1, [ %i4 + 0x40 ]
map->dirty = true;
4001bfc0: 82 10 20 01 mov 1, %g1
4001bfc4: c2 2f 20 34 stb %g1, [ %i4 + 0x34 ]
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001bfc8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001bfcc: 80 a0 60 00 cmp %g1, 0
4001bfd0: 02 80 00 8c be 4001c200 <rtems_rfs_file_set_size+0x2ec>
4001bfd4: 80 a0 40 1d cmp %g1, %i5
4001bfd8: 80 a7 60 00 cmp %i5, 0
4001bfdc: 12 80 00 89 bne 4001c200 <rtems_rfs_file_set_size+0x2ec>
<== ALWAYS TAKEN
4001bfe0: 80 a0 40 1d cmp %g1, %i5
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
4001bfe4: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
<== NOT EXECUTED
4001bfe8: 80 a6 60 00 cmp %i1, 0
4001bfec: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
4001bff0: 02 80 00 04 be 4001c000 <rtems_rfs_file_set_size+0xec>
<== NEVER TAKEN
4001bff4: c0 26 20 18 clr [ %i0 + 0x18 ]
4001bff8: 82 07 7f ff add %i5, -1, %g1
4001bffc: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
4001c000: 84 10 00 1b mov %i3, %g2
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
4001c004: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
4001c008: c2 20 a0 88 st %g1, [ %g2 + 0x88 ]
handle->shared->size.count = rtems_rfs_block_map_count (map);
4001c00c: fa 20 a0 84 st %i5, [ %g2 + 0x84 ]
if (rtems_rfs_file_update_mtime (handle))
4001c010: fa 06 00 00 ld [ %i0 ], %i5
4001c014: ba 8f 60 02 andcc %i5, 2, %i5
4001c018: 02 80 00 14 be 4001c068 <rtems_rfs_file_set_size+0x154>
<== ALWAYS TAKEN
4001c01c: 01 00 00 00 nop
return 0;
4001c020: ba 10 20 00 clr %i5 ! 0 <PROM_START>
<== NOT EXECUTED
}
4001c024: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c028: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001c02c: 92 10 00 11 mov %l1, %o1
4001c030: 7f ff f7 4c call 40019d60 <rtems_rfs_block_map_free_all>
4001c034: 90 10 00 14 mov %l4, %o0
if (rc > 0)
4001c038: ba 92 20 00 orcc %o0, 0, %i5
4001c03c: 14 bf ff fa bg 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c040: 01 00 00 00 nop
4001c044: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
4001c048: 10 bf ff ef b 4001c004 <rtems_rfs_file_set_size+0xf0>
4001c04c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
if (size != new_size)
4001c050: 32 bf ff c2 bne,a 4001bf58 <rtems_rfs_file_set_size+0x44>
4001c054: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
if (rtems_rfs_file_update_mtime (handle))
4001c058: fa 06 00 00 ld [ %i0 ], %i5
4001c05c: ba 8f 60 02 andcc %i5, 2, %i5
4001c060: 32 bf ff f1 bne,a 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c064: ba 10 20 00 clr %i5
<== NOT EXECUTED
handle->shared->mtime = time (NULL);
4001c068: 40 00 0e 3e call 4001f960 <time>
4001c06c: 90 10 20 00 clr %o0
4001c070: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001c074: d2 20 60 90 st %o1, [ %g1 + 0x90 ]
}
4001c078: 81 c7 e0 08 ret
4001c07c: 91 e8 00 1d restore %g0, %i5, %o0
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
4001c080: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001c084: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001c088: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c08c: 7f ff dc bf call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c090: 90 12 21 50 or %o0, 0x150, %o0 ! 40024150 <status_code_to_errno+0xc34>
<== NOT EXECUTED
size = rtems_rfs_file_size (handle);
4001c094: 10 bf ff aa b 4001bf3c <rtems_rfs_file_set_size+0x28>
<== NOT EXECUTED
4001c098: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
<== NOT EXECUTED
if (size < new_size)
4001c09c: 28 bf ff ba bleu,a 4001bf84 <rtems_rfs_file_set_size+0x70>
4001c0a0: 92 84 ff ff addcc %l3, -1, %o1
count = new_size - size;
4001c0a4: b6 a4 c0 09 subcc %l3, %o1, %i3
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001c0a8: b2 06 20 04 add %i0, 4, %i1
count = new_size - size;
4001c0ac: b4 64 80 08 subx %l2, %o0, %i2
read_block = false;
4001c0b0: a6 10 20 00 clr %l3
4001c0b4: 10 80 00 28 b 4001c154 <rtems_rfs_file_set_size+0x240>
4001c0b8: a4 10 20 01 mov 1, %l2
if (count < (length - bpos.boff))
4001c0bc: 80 a0 80 1b cmp %g2, %i3
4001c0c0: 28 80 00 44 bleu,a 4001c1d0 <rtems_rfs_file_set_size+0x2bc>
4001c0c4: c0 27 20 40 clr [ %i4 + 0x40 ]
length = count + bpos.boff;
4001c0c8: a0 00 40 1b add %g1, %i3, %l0
4001c0cc: e4 2f 20 34 stb %l2, [ %i4 + 0x34 ]
read_block = true;
4001c0d0: a6 10 20 01 mov 1, %l3
map->size.offset = offset;
4001c0d4: e0 27 20 40 st %l0, [ %i4 + 0x40 ]
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001c0d8: 96 0c e0 01 and %l3, 1, %o3
4001c0dc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001c0e0: d4 07 bf f0 ld [ %fp + -16 ], %o2
4001c0e4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001c0e8: 7f ff cd f8 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001c0ec: 92 10 00 19 mov %i1, %o1
if (rc > 0)
4001c0f0: ba 92 20 00 orcc %o0, 0, %i5
4001c0f4: 14 bf ff cc bg 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c0f8: c2 07 bf f8 ld [ %fp + -8 ], %g1
dst = rtems_rfs_buffer_data (&handle->buffer);
4001c0fc: c4 06 20 0c ld [ %i0 + 0xc ], %g2
memset (dst + bpos.boff, 0, length - bpos.boff);
4001c100: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
4001c104: 94 24 00 01 sub %l0, %g1, %o2
4001c108: 92 10 20 00 clr %o1
4001c10c: 40 00 09 c8 call 4001e82c <memset>
4001c110: 90 02 00 01 add %o0, %g1, %o0
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001c114: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001c118: e4 2e 20 04 stb %l2, [ %i0 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001c11c: 92 10 00 19 mov %i1, %o1
4001c120: 7f ff ce b1 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001c124: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (rc > 0)
4001c128: ba 92 20 00 orcc %o0, 0, %i5
4001c12c: 14 bf ff be bg 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c130: c2 07 bf f8 ld [ %fp + -8 ], %g1
count -= length - bpos.boff;
4001c134: 82 24 00 01 sub %l0, %g1, %g1
4001c138: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4001c13c: b6 a6 c0 01 subcc %i3, %g1, %i3
4001c140: b4 66 a0 00 subx %i2, 0, %i2
while (count)
4001c144: 80 96 80 1b orcc %i2, %i3, %g0
4001c148: 02 bf ff af be 4001c004 <rtems_rfs_file_set_size+0xf0>
4001c14c: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
4001c150: e8 00 a0 98 ld [ %g2 + 0x98 ], %l4
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
4001c154: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
4001c158: fa 27 bf f4 st %i5, [ %fp + -12 ]
4001c15c: 80 a0 60 00 cmp %g1, 0
4001c160: c2 27 bf f8 st %g1, [ %fp + -8 ]
4001c164: 02 80 00 04 be 4001c174 <rtems_rfs_file_set_size+0x260>
4001c168: c0 27 bf fc clr [ %fp + -4 ]
4001c16c: ba 07 7f ff add %i5, -1, %i5
4001c170: fa 27 bf f4 st %i5, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001c174: 96 07 bf f0 add %fp, -16, %o3
4001c178: 94 07 bf f4 add %fp, -12, %o2
4001c17c: 92 10 00 11 mov %l1, %o1
4001c180: 7f ff f4 b2 call 40019448 <rtems_rfs_block_map_find>
4001c184: 90 10 00 14 mov %l4, %o0
if (rc > 0)
4001c188: ba 92 20 00 orcc %o0, 0, %i5
4001c18c: 04 80 00 0c ble 4001c1bc <rtems_rfs_file_set_size+0x2a8>
4001c190: 80 a7 60 06 cmp %i5, 6
if (rc != ENXIO)
4001c194: 12 bf ff a4 bne 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c198: 96 07 bf f0 add %fp, -16, %o3
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001c19c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001c1a0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001c1a4: 94 10 20 01 mov 1, %o2
4001c1a8: 7f ff f5 2c call 40019658 <rtems_rfs_block_map_grow>
4001c1ac: 92 10 00 11 mov %l1, %o1
if (rc > 0)
4001c1b0: ba 92 20 00 orcc %o0, 0, %i5
4001c1b4: 14 bf ff 9c bg 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c1b8: 01 00 00 00 nop
if (count < (length - bpos.boff))
4001c1bc: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001c1c0: 80 a6 a0 00 cmp %i2, 0
4001c1c4: 02 bf ff be be 4001c0bc <rtems_rfs_file_set_size+0x1a8>
<== ALWAYS TAKEN
4001c1c8: 84 24 00 01 sub %l0, %g1, %g2
4001c1cc: c0 27 20 40 clr [ %i4 + 0x40 ]
<== NOT EXECUTED
map->dirty = true;
4001c1d0: 10 bf ff c2 b 4001c0d8 <rtems_rfs_file_set_size+0x1c4>
4001c1d4: e4 2f 20 34 stb %l2, [ %i4 + 0x34 ]
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
4001c1d8: 94 10 00 1a mov %i2, %o2
4001c1dc: 92 06 e0 34 add %i3, 0x34, %o1
4001c1e0: 7f ff f6 1b call 40019a4c <rtems_rfs_block_map_shrink>
4001c1e4: 90 10 00 14 mov %l4, %o0
if (rc > 0)
4001c1e8: ba 92 20 00 orcc %o0, 0, %i5
4001c1ec: 14 bf ff 8e bg 4001c024 <rtems_rfs_file_set_size+0x110>
<== NEVER TAKEN
4001c1f0: 01 00 00 00 nop
4001c1f4: fa 07 20 3c ld [ %i4 + 0x3c ], %i5
4001c1f8: 10 bf ff 71 b 4001bfbc <rtems_rfs_file_set_size+0xa8>
4001c1fc: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001c200: 3a bf ff 7a bcc,a 4001bfe8 <rtems_rfs_file_set_size+0xd4>
<== NEVER TAKEN
4001c204: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
<== NOT EXECUTED
4001c208: 84 07 7f ff add %i5, -1, %g2
4001c20c: 80 a0 40 02 cmp %g1, %g2
4001c210: 32 bf ff 7d bne,a 4001c004 <rtems_rfs_file_set_size+0xf0>
<== NEVER TAKEN
4001c214: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
4001c218: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001c21c: 80 a0 40 19 cmp %g1, %i1
4001c220: 38 bf ff 72 bgu,a 4001bfe8 <rtems_rfs_file_set_size+0xd4>
4001c224: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
4001c228: 10 bf ff 77 b 4001c004 <rtems_rfs_file_set_size+0xf0>
4001c22c: 84 10 00 1b mov %i3, %g2
400100b8 <rtems_rfs_format>:
return 0;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
400100b8: 9d e3 be d8 save %sp, -296, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
400100bc: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
400100c0: 80 a0 60 00 cmp %g1, 0
400100c4: 12 80 00 94 bne 40010314 <rtems_rfs_format+0x25c>
<== NEVER TAKEN
400100c8: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
400100cc: 94 10 20 80 mov 0x80, %o2
400100d0: 92 10 20 00 clr %o1
400100d4: 40 00 39 d6 call 4001e82c <memset>
400100d8: 90 07 bf 80 add %fp, -128, %o0
head->next = tail;
400100dc: 82 07 bf c4 add %fp, -60, %g1
400100e0: c2 27 bf c0 st %g1, [ %fp + -64 ]
tail->previous = head;
400100e4: 82 07 bf c0 add %fp, -64, %g1
400100e8: c2 27 bf c8 st %g1, [ %fp + -56 ]
head->next = tail;
400100ec: 82 07 bf d4 add %fp, -44, %g1
400100f0: c2 27 bf d0 st %g1, [ %fp + -48 ]
tail->previous = head;
400100f4: 82 07 bf d0 add %fp, -48, %g1
400100f8: c2 27 bf d8 st %g1, [ %fp + -40 ]
head->next = tail;
400100fc: 82 07 bf e4 add %fp, -28, %g1
40010100: c2 27 bf e0 st %g1, [ %fp + -32 ]
tail->previous = head;
40010104: 82 07 bf e0 add %fp, -32, %g1
40010108: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->next = tail;
4001010c: 82 07 bf f4 add %fp, -12, %g1
40010110: c2 27 bf f0 st %g1, [ %fp + -16 ]
tail->previous = head;
40010114: 82 07 bf f0 add %fp, -16, %g1
40010118: 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;
4001011c: 82 10 20 05 mov 5, %g1
40010120: 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;
40010124: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40010128: 92 07 bf 7c add %fp, -132, %o1
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
4001012c: c2 27 bf 7c st %g1, [ %fp + -132 ]
rc = rtems_rfs_buffer_open (name, &fs);
40010130: 7f ff fe b6 call 4000fc08 <rtems_rfs_buffer_open>
40010134: 90 10 00 18 mov %i0, %o0
if (rc != 0)
40010138: ba 92 20 00 orcc %o0, 0, %i5
4001013c: 12 80 03 ac bne 40010fec <rtems_rfs_format+0xf34>
<== NEVER TAKEN
40010140: c2 07 bf 8c ld [ %fp + -116 ], %g1
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40010144: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
40010148: 80 a2 a0 00 cmp %o2, 0
4001014c: 02 80 03 93 be 40010f98 <rtems_rfs_format+0xee0>
<== NEVER TAKEN
40010150: 92 10 20 00 clr %o1
fs->block_size = config->block_size;
40010154: d2 06 40 00 ld [ %i1 ], %o1
if (!fs->block_size)
40010158: 80 a2 60 00 cmp %o1, 0
4001015c: 02 80 00 73 be 40010328 <rtems_rfs_format+0x270>
40010160: d2 27 bf 84 st %o1, [ %fp + -124 ]
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40010164: 81 80 20 00 wr %g0, %y
40010168: 01 00 00 00 nop
4001016c: 01 00 00 00 nop
40010170: 01 00 00 00 nop
40010174: 82 72 40 0a udiv %o1, %o2, %g1
40010178: 82 58 40 0a smul %g1, %o2, %g1
4001017c: 80 a2 40 01 cmp %o1, %g1
40010180: 32 80 00 91 bne,a 400103c4 <rtems_rfs_format+0x30c>
<== NEVER TAKEN
40010184: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
fs->group_blocks = config->group_blocks;
40010188: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001018c: c2 27 bf a4 st %g1, [ %fp + -92 ]
if (!fs->group_blocks)
40010190: 80 a0 60 00 cmp %g1, 0
40010194: 02 80 00 0d be 400101c8 <rtems_rfs_format+0x110>
<== ALWAYS TAKEN
40010198: 93 2a 60 03 sll %o1, 3, %o1
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
4001019c: 80 a0 40 09 cmp %g1, %o1
<== NOT EXECUTED
400101a0: 08 80 00 0b bleu 400101cc <rtems_rfs_format+0x114>
<== NOT EXECUTED
400101a4: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
printf ("group block count is higher than bits in block\n");
400101a8: 40 00 0c 87 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
400101ac: 90 12 23 20 or %o0, 0x320, %o0 ! 40022320 <ramdisk_ops+0x608>
<== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
{
errno = EINVAL;
400101b0: 40 00 38 e7 call 4001e54c <__errno>
<== NOT EXECUTED
400101b4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400101b8: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400101bc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
400101c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400101c4: 81 e8 00 00 restore
<== NOT EXECUTED
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
400101c8: d2 27 bf a4 st %o1, [ %fp + -92 ]
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
400101cc: 40 00 30 35 call 4001c2a0 <rtems_rfs_fs_media_size>
400101d0: 90 07 bf 7c add %fp, -132, %o0
400101d4: fa 07 bf 84 ld [ %fp + -124 ], %i5
400101d8: 94 10 20 00 clr %o2
400101dc: 40 00 40 01 call 400201e0 <__udivdi3>
400101e0: 96 10 00 1d mov %i5, %o3
400101e4: d2 27 bf 80 st %o1, [ %fp + -128 ]
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
400101e8: b9 2f 60 03 sll %i5, 3, %i4
if (dividend == 0)
400101ec: 80 a2 60 00 cmp %o1, 0
400101f0: 12 80 01 06 bne 40010608 <rtems_rfs_format+0x550>
<== ALWAYS TAKEN
400101f4: 88 10 20 01 mov 1, %g4
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
400101f8: c8 27 bf a0 st %g4, [ %fp + -96 ]
<== NOT EXECUTED
400101fc: 83 37 60 03 srl %i5, 3, %g1
<== NOT EXECUTED
fs->group_inodes = config->group_inodes;
40010200: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
40010204: 05 09 24 92 sethi %hi(0x24924800), %g2
<== NOT EXECUTED
if (!fs->group_inodes)
40010208: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4001020c: 84 10 a1 25 or %g2, 0x125, %g2
<== NOT EXECUTED
40010210: 80 50 40 02 umul %g1, %g2, %g0
<== NOT EXECUTED
40010214: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
40010218: 22 80 00 73 be,a 400103e4 <rtems_rfs_format+0x32c>
<== NOT EXECUTED
4001021c: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
40010220: c2 27 bf ac st %g1, [ %fp + -84 ]
<== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40010224: 86 00 ff ff add %g3, -1, %g3
40010228: 81 80 20 00 wr %g0, %y
4001022c: 01 00 00 00 nop
40010230: 01 00 00 00 nop
40010234: 01 00 00 00 nop
40010238: 84 70 c0 01 udiv %g3, %g1, %g2
4001023c: 84 00 a0 01 inc %g2
40010240: 82 58 40 02 smul %g1, %g2, %g1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40010244: 80 a7 00 01 cmp %i4, %g1
40010248: 2a 80 00 83 bcs,a 40010454 <rtems_rfs_format+0x39c>
<== NEVER TAKEN
4001024c: f8 27 bf a8 st %i4, [ %fp + -88 ]
<== NOT EXECUTED
fs->group_inodes =
40010250: c2 27 bf a8 st %g1, [ %fp + -88 ]
fs->max_name_length = config->max_name_length;
40010254: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
40010258: 80 a0 60 00 cmp %g1, 0
4001025c: 32 80 00 83 bne,a 40010468 <rtems_rfs_format+0x3b0>
<== NEVER TAKEN
40010260: c2 27 bf 98 st %g1, [ %fp + -104 ]
<== NOT EXECUTED
fs->max_name_length = 512;
40010264: 82 10 22 00 mov 0x200, %g1
40010268: c2 27 bf 98 st %g1, [ %fp + -104 ]
}
if (config->verbose)
4001026c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40010270: 80 a0 60 00 cmp %g1, 0
40010274: 12 80 00 81 bne 40010478 <rtems_rfs_format+0x3c0>
<== NEVER TAKEN
40010278: 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));
4001027c: 92 10 00 1d mov %i5, %o1
40010280: 7f ff ff 14 call 4000fed0 <rtems_rfs_buffer_setblksize>
40010284: 90 07 bf 7c add %fp, -132, %o0
if (rc != 0)
40010288: ba 92 20 00 orcc %o0, 0, %i5
4001028c: 12 80 03 4c bne 40010fbc <rtems_rfs_format+0xf04>
<== NEVER TAKEN
40010290: 96 10 20 00 clr %o3
handle->dirty = false;
40010294: c0 2f bf 54 clrb [ %fp + -172 ]
handle->bnum = 0;
40010298: c0 27 bf 58 clr [ %fp + -168 ]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
4001029c: 94 10 20 00 clr %o2
handle->buffer = NULL;
400102a0: c0 27 bf 5c clr [ %fp + -164 ]
400102a4: 92 07 bf 54 add %fp, -172, %o1
400102a8: 7f ff fd 88 call 4000f8c8 <rtems_rfs_buffer_handle_request>
400102ac: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
400102b0: b8 92 20 00 orcc %o0, 0, %i4
400102b4: 04 80 00 f9 ble 40010698 <rtems_rfs_format+0x5e0>
<== ALWAYS TAKEN
400102b8: 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);
400102bc: 7f ff fe 4a call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400102c0: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
400102c4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
handle->dirty = false;
400102c8: 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;
400102cc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
handle->bnum = 0;
400102d0: c0 27 bf 58 clr [ %fp + -168 ]
<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
400102d4: 40 00 3c 73 call 4001f4a0 <strerror>
<== NOT EXECUTED
400102d8: c0 27 bf 5c clr [ %fp + -164 ]
<== NOT EXECUTED
400102dc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
400102e0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
400102e4: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400102e8: 40 00 0c 28 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400102ec: 90 12 21 68 or %o0, 0x168, %o0 ! 40022568 <ramdisk_ops+0x850>
<== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
400102f0: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400102f4: 40 00 0c 34 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
400102f8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400225e0 <ramdisk_ops+0x8c8>
<== NOT EXECUTED
errno = EIO;
400102fc: 40 00 38 94 call 4001e54c <__errno>
<== NOT EXECUTED
40010300: 01 00 00 00 nop
<== NOT EXECUTED
40010304: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
40010308: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
4001030c: 81 c7 e0 08 ret
<== NOT EXECUTED
40010310: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
40010314: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
40010318: 40 00 0c 1c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001031c: 90 12 22 70 or %o0, 0x270, %o0 ! 40022270 <ramdisk_ops+0x558>
<== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40010320: 10 bf ff 6c b 400100d0 <rtems_rfs_format+0x18>
<== NOT EXECUTED
40010324: 94 10 20 80 mov 0x80, %o2
<== NOT EXECUTED
uint64_t total_size = rtems_rfs_fs_media_size (fs);
40010328: 40 00 2f de call 4001c2a0 <rtems_rfs_fs_media_size>
4001032c: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
40010330: 80 a2 20 00 cmp %o0, 0
40010334: 22 80 00 c8 be,a 40010654 <rtems_rfs_format+0x59c>
<== ALWAYS TAKEN
40010338: 03 00 03 ff sethi %hi(0xffc00), %g1
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4001033c: 84 10 20 00 clr %g2
<== NOT EXECUTED
40010340: 07 00 04 00 sethi %hi(0x100000), %g3
<== NOT EXECUTED
for (b = 31; b > 0; b--)
40010344: 82 10 20 1f mov 0x1f, %g1
<== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40010348: ba 82 40 03 addcc %o1, %g3, %i5
<== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4001034c: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40010350: b8 42 00 02 addx %o0, %g2, %i4
<== NOT EXECUTED
40010354: 89 37 60 14 srl %i5, 0x14, %g4
<== NOT EXECUTED
40010358: 85 2f 20 0c sll %i4, 0xc, %g2
<== NOT EXECUTED
4001035c: 10 80 00 04 b 4001036c <rtems_rfs_format+0x2b4>
<== NOT EXECUTED
40010360: 84 10 80 04 or %g2, %g4, %g2
<== NOT EXECUTED
for (b = 31; b > 0; b--)
40010364: 02 80 00 06 be 4001037c <rtems_rfs_format+0x2c4>
<== NOT EXECUTED
40010368: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4001036c: 93 28 c0 01 sll %g3, %g1, %o1
<== NOT EXECUTED
40010370: 80 88 80 09 btst %g2, %o1
<== NOT EXECUTED
40010374: 02 bf ff fc be 40010364 <rtems_rfs_format+0x2ac>
<== NOT EXECUTED
40010378: 82 80 7f ff addcc %g1, -1, %g1
<== NOT EXECUTED
if (fs->block_size < 512)
4001037c: 80 a2 61 ff cmp %o1, 0x1ff
<== NOT EXECUTED
40010380: 18 80 00 bd bgu 40010674 <rtems_rfs_format+0x5bc>
<== NOT EXECUTED
40010384: d2 27 bf 84 st %o1, [ %fp + -124 ]
<== NOT EXECUTED
40010388: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
4001038c: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
fs->block_size = 512;
40010390: 82 10 22 00 mov 0x200, %g1
40010394: c2 27 bf 84 st %g1, [ %fp + -124 ]
40010398: 92 10 22 00 mov 0x200, %o1
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4001039c: 81 80 20 00 wr %g0, %y
400103a0: 01 00 00 00 nop
400103a4: 01 00 00 00 nop
400103a8: 01 00 00 00 nop
400103ac: 82 72 40 0a udiv %o1, %o2, %g1
400103b0: 82 58 40 0a smul %g1, %o2, %g1
400103b4: 80 a2 40 01 cmp %o1, %g1
400103b8: 22 bf ff 75 be,a 4001018c <rtems_rfs_format+0xd4>
<== ALWAYS TAKEN
400103bc: c2 06 60 04 ld [ %i1 + 4 ], %g1
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400103c0: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
400103c4: 40 00 0b f1 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400103c8: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 400222e0 <ramdisk_ops+0x5c8>
<== NOT EXECUTED
errno = EINVAL;
400103cc: 40 00 38 60 call 4001e54c <__errno>
<== NOT EXECUTED
400103d0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400103d4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400103d8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
400103dc: 81 c7 e0 08 ret
<== NOT EXECUTED
400103e0: 81 e8 00 00 restore
<== NOT EXECUTED
if (config->inode_overhead)
400103e4: 80 a0 e0 00 cmp %g3, 0
400103e8: 22 80 00 02 be,a 400103f0 <rtems_rfs_format+0x338>
<== ALWAYS TAKEN
400103ec: 86 10 20 01 mov 1, %g3
blocks = ((rtems_rfs_fs_blocks (fs) -
400103f0: 84 02 7f ff add %o1, -1, %g2
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
400103f4: 37 14 7a e1 sethi %hi(0x51eb8400), %i3
400103f8: 84 58 80 03 smul %g2, %g3, %g2
400103fc: b6 16 e1 1f or %i3, 0x11f, %i3
40010400: 80 50 80 1b umul %g2, %i3, %g0
40010404: 85 40 00 00 rd %y, %g2
40010408: 85 30 a0 05 srl %g2, 5, %g2
if (dividend == 0)
4001040c: 80 a0 a0 00 cmp %g2, 0
40010410: 02 80 00 0a be 40010438 <rtems_rfs_format+0x380>
<== NEVER TAKEN
40010414: 86 10 00 01 mov %g1, %g3
return ((dividend - 1) / divisor) + 1;
40010418: 84 00 bf ff add %g2, -1, %g2
4001041c: 81 80 20 00 wr %g0, %y
40010420: 01 00 00 00 nop
40010424: 01 00 00 00 nop
40010428: 01 00 00 00 nop
4001042c: 86 70 80 04 udiv %g2, %g4, %g3
40010430: 86 00 e0 01 inc %g3
40010434: 86 58 c0 01 smul %g3, %g1, %g3
if (dividend == 0)
40010438: 80 a0 e0 00 cmp %g3, 0
4001043c: 12 bf ff 7a bne 40010224 <rtems_rfs_format+0x16c>
<== ALWAYS TAKEN
40010440: c2 27 bf ac st %g1, [ %fp + -84 ]
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40010444: 80 a7 00 01 cmp %i4, %g1
<== NOT EXECUTED
40010448: 3a bf ff 83 bcc,a 40010254 <rtems_rfs_format+0x19c>
<== NOT EXECUTED
4001044c: c2 27 bf a8 st %g1, [ %fp + -88 ]
<== NOT EXECUTED
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
40010450: f8 27 bf a8 st %i4, [ %fp + -88 ]
<== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40010454: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
if (!fs->max_name_length)
40010458: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001045c: 22 bf ff 83 be,a 40010268 <rtems_rfs_format+0x1b0>
<== NOT EXECUTED
40010460: 82 10 22 00 mov 0x200, %g1
<== NOT EXECUTED
fs->max_name_length = config->max_name_length;
40010464: c2 27 bf 98 st %g1, [ %fp + -104 ]
<== NOT EXECUTED
if (config->verbose)
40010468: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
<== NOT EXECUTED
4001046c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40010470: 02 bf ff 84 be 40010280 <rtems_rfs_format+0x1c8>
<== NOT EXECUTED
40010474: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
40010478: 40 00 2f 8a call 4001c2a0 <rtems_rfs_fs_media_size>
<== NOT EXECUTED
4001047c: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
40010480: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
40010484: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
40010488: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
4001048c: 40 00 0b bf call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010490: 90 12 23 50 or %o0, 0x350, %o0 ! 40022350 <ramdisk_ops+0x638>
<== NOT EXECUTED
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
40010494: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
40010498: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
<== NOT EXECUTED
4001049c: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
400104a0: 40 00 0b ba call 40013388 <__wrap_printf>
<== NOT EXECUTED
400104a4: 90 12 23 78 or %o0, 0x378, %o0 ! 40022378 <ramdisk_ops+0x660>
<== NOT EXECUTED
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
400104a8: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
400104ac: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
<== NOT EXECUTED
400104b0: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
400104b4: 40 00 0b b5 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400104b8: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 400223a0 <ramdisk_ops+0x688>
<== NOT EXECUTED
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
400104bc: 40 00 2f 73 call 4001c288 <rtems_rfs_fs_size>
<== NOT EXECUTED
400104c0: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
400104c4: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
400104c8: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
400104cc: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
400104d0: 40 00 0b ae call 40013388 <__wrap_printf>
<== NOT EXECUTED
400104d4: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 400223d0 <ramdisk_ops+0x6b8>
<== NOT EXECUTED
printf ("rtems-rfs: format: blocks = %zu\n",
400104d8: d2 07 bf 80 ld [ %fp + -128 ], %o1
<== NOT EXECUTED
400104dc: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
400104e0: 40 00 0b aa call 40013388 <__wrap_printf>
<== NOT EXECUTED
400104e4: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 400223f0 <ramdisk_ops+0x6d8>
<== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
400104e8: d2 07 bf 84 ld [ %fp + -124 ], %o1
<== NOT EXECUTED
400104ec: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400104f0: 40 00 0b a6 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400104f4: 90 12 20 18 or %o0, 0x18, %o0 ! 40022418 <ramdisk_ops+0x700>
<== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
400104f8: d2 07 bf 84 ld [ %fp + -124 ], %o1
<== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
400104fc: 93 2a 60 03 sll %o1, 3, %o1
<== NOT EXECUTED
40010500: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010504: 40 00 0b a1 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010508: 90 12 20 40 or %o0, 0x40, %o0 ! 40022440 <ramdisk_ops+0x728>
<== NOT EXECUTED
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
4001050c: 92 10 20 38 mov 0x38, %o1
<== NOT EXECUTED
40010510: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010514: 40 00 0b 9d call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010518: 90 12 20 68 or %o0, 0x68, %o0 ! 40022468 <ramdisk_ops+0x750>
<== NOT EXECUTED
fs.group_inodes * fs.group_count,
4001051c: c4 07 bf a8 ld [ %fp + -88 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40010520: d2 07 bf a0 ld [ %fp + -96 ], %o1
<== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40010524: 83 28 a0 03 sll %g2, 3, %g1
<== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40010528: 92 58 80 09 smul %g2, %o1, %o1
<== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4001052c: 82 20 40 02 sub %g1, %g2, %g1
<== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
40010530: c6 07 bf 84 ld [ %fp + -124 ], %g3
<== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40010534: 83 28 60 03 sll %g1, 3, %g1
<== NOT EXECUTED
if (dividend == 0)
40010538: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001053c: 02 80 00 0a be 40010564 <rtems_rfs_format+0x4ac>
<== NOT EXECUTED
40010540: 84 10 27 d0 mov 0x7d0, %g2
<== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40010544: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
40010548: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001054c: 01 00 00 00 nop
<== NOT EXECUTED
40010550: 01 00 00 00 nop
<== NOT EXECUTED
40010554: 01 00 00 00 nop
<== NOT EXECUTED
40010558: 84 70 40 03 udiv %g1, %g3, %g2
<== NOT EXECUTED
4001055c: 84 00 a0 02 add %g2, 2, %g2
<== NOT EXECUTED
40010560: 84 58 a3 e8 smul %g2, 0x3e8, %g2
<== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40010564: d6 07 bf 80 ld [ %fp + -128 ], %o3
<== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40010568: 83 28 e0 03 sll %g3, 3, %g1
<== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
4001056c: 96 02 ff ff add %o3, -1, %o3
<== NOT EXECUTED
40010570: 80 a2 c0 01 cmp %o3, %g1
<== NOT EXECUTED
40010574: 38 80 00 02 bgu,a 4001057c <rtems_rfs_format+0x4c4>
<== NOT EXECUTED
40010578: 96 10 00 01 mov %g1, %o3
<== NOT EXECUTED
4001057c: 83 38 a0 1f sra %g2, 0x1f, %g1
<== NOT EXECUTED
40010580: 81 80 60 00 wr %g1, %y
<== NOT EXECUTED
40010584: 01 00 00 00 nop
<== NOT EXECUTED
40010588: 01 00 00 00 nop
<== NOT EXECUTED
4001058c: 01 00 00 00 nop
<== NOT EXECUTED
40010590: 84 78 80 0b sdiv %g2, %o3, %g2
<== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40010594: 03 19 99 99 sethi %hi(0x66666400), %g1
<== NOT EXECUTED
40010598: 87 38 a0 1f sra %g2, 0x1f, %g3
<== NOT EXECUTED
4001059c: 82 10 62 67 or %g1, 0x267, %g1
<== NOT EXECUTED
400105a0: 80 58 80 01 smul %g2, %g1, %g0
<== NOT EXECUTED
400105a4: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
400105a8: 83 38 60 02 sra %g1, 2, %g1
<== NOT EXECUTED
400105ac: 82 20 40 03 sub %g1, %g3, %g1
<== NOT EXECUTED
400105b0: 94 10 00 01 mov %g1, %o2
<== NOT EXECUTED
400105b4: 97 28 60 02 sll %g1, 2, %o3
<== NOT EXECUTED
400105b8: 82 02 c0 01 add %o3, %g1, %g1
<== NOT EXECUTED
400105bc: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400105c0: 97 28 60 01 sll %g1, 1, %o3
<== NOT EXECUTED
400105c4: 90 12 20 90 or %o0, 0x90, %o0
<== NOT EXECUTED
400105c8: 40 00 0b 70 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400105cc: 96 20 80 0b sub %g2, %o3, %o3
<== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
400105d0: d2 07 bf a0 ld [ %fp + -96 ], %o1
<== NOT EXECUTED
400105d4: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400105d8: 40 00 0b 6c call 40013388 <__wrap_printf>
<== NOT EXECUTED
400105dc: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400224c0 <ramdisk_ops+0x7a8>
<== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
400105e0: d2 07 bf a4 ld [ %fp + -92 ], %o1
<== NOT EXECUTED
400105e4: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400105e8: 40 00 0b 68 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400105ec: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400224e0 <ramdisk_ops+0x7c8>
<== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
400105f0: d2 07 bf a8 ld [ %fp + -88 ], %o1
<== NOT EXECUTED
400105f4: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400105f8: 40 00 0b 64 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400105fc: 90 12 21 08 or %o0, 0x108, %o0 ! 40022508 <ramdisk_ops+0x7f0>
<== NOT EXECUTED
40010600: 10 bf ff 1f b 4001027c <rtems_rfs_format+0x1c4>
<== NOT EXECUTED
40010604: fa 07 bf 84 ld [ %fp + -124 ], %i5
<== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40010608: 82 02 7f ff add %o1, -1, %g1
4001060c: 81 80 20 00 wr %g0, %y
40010610: 01 00 00 00 nop
40010614: 01 00 00 00 nop
40010618: 01 00 00 00 nop
4001061c: 88 70 40 1c udiv %g1, %i4, %g4
40010620: 88 01 20 01 inc %g4
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
40010624: c8 27 bf a0 st %g4, [ %fp + -96 ]
40010628: 83 37 60 03 srl %i5, 3, %g1
fs->group_inodes = config->group_inodes;
4001062c: c6 06 60 08 ld [ %i1 + 8 ], %g3
40010630: 05 09 24 92 sethi %hi(0x24924800), %g2
if (!fs->group_inodes)
40010634: 80 a0 e0 00 cmp %g3, 0
40010638: 84 10 a1 25 or %g2, 0x125, %g2
4001063c: 80 50 40 02 umul %g1, %g2, %g0
40010640: 83 40 00 00 rd %y, %g1
40010644: 32 bf fe f8 bne,a 40010224 <rtems_rfs_format+0x16c>
<== NEVER TAKEN
40010648: c2 27 bf ac st %g1, [ %fp + -84 ]
<== NOT EXECUTED
if (config->inode_overhead)
4001064c: 10 bf ff 66 b 400103e4 <rtems_rfs_format+0x32c>
40010650: c6 06 60 0c ld [ %i1 + 0xc ], %g3
if (total_size >= GIGS (1))
40010654: 82 10 63 ff or %g1, 0x3ff, %g1
40010658: 80 a2 40 01 cmp %o1, %g1
4001065c: 18 bf ff 39 bgu 40010340 <rtems_rfs_format+0x288>
<== NEVER TAKEN
40010660: 84 10 20 00 clr %g2
40010664: d2 07 bf 84 ld [ %fp + -124 ], %o1
if (fs->block_size < 512)
40010668: 80 a2 61 ff cmp %o1, 0x1ff
4001066c: 08 bf ff 48 bleu 4001038c <rtems_rfs_format+0x2d4>
<== ALWAYS TAKEN
40010670: c2 07 bf 8c ld [ %fp + -116 ], %g1
if (fs->block_size > (4 * 1024))
40010674: 03 00 00 04 sethi %hi(0x1000), %g1
<== NOT EXECUTED
40010678: 80 a2 40 01 cmp %o1, %g1
<== NOT EXECUTED
4001067c: 28 80 00 05 bleu,a 40010690 <rtems_rfs_format+0x5d8>
<== NOT EXECUTED
40010680: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
fs->block_size = (4 * 1024);
40010684: c2 27 bf 84 st %g1, [ %fp + -124 ]
<== NOT EXECUTED
40010688: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
4001068c: c2 07 bf 8c ld [ %fp + -116 ], %g1
<== NOT EXECUTED
40010690: 10 bf fe b5 b 40010164 <rtems_rfs_format+0xac>
<== NOT EXECUTED
40010694: d4 00 60 20 ld [ %g1 + 0x20 ], %o2
<== NOT EXECUTED
sb = rtems_rfs_buffer_data (&handle);
40010698: c2 07 bf 5c ld [ %fp + -164 ], %g1
4001069c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
400106a0: d4 07 bf 84 ld [ %fp + -124 ], %o2
400106a4: 92 10 20 ff mov 0xff, %o1
400106a8: 40 00 38 61 call 4001e82c <memset>
400106ac: 90 10 00 01 mov %g1, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400106b0: 84 10 20 28 mov 0x28, %g2
400106b4: c4 2a 00 00 stb %g2, [ %o0 ]
400106b8: 84 10 20 09 mov 9, %g2
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400106bc: c0 2a 20 04 clrb [ %o0 + 4 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400106c0: 86 10 20 01 mov 1, %g3
400106c4: c4 2a 20 01 stb %g2, [ %o0 + 1 ]
400106c8: 84 10 20 20 mov 0x20, %g2
400106cc: c6 2a 20 03 stb %g3, [ %o0 + 3 ]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
400106d0: 82 10 00 08 mov %o0, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400106d4: c0 2a 20 05 clrb [ %o0 + 5 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400106d8: 92 07 bf 54 add %fp, -172, %o1
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400106dc: c4 2a 20 02 stb %g2, [ %o0 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400106e0: c0 2a 20 06 clrb [ %o0 + 6 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400106e4: 90 07 bf 7c add %fp, -132, %o0
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400106e8: c0 28 60 07 clrb [ %g1 + 7 ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
400106ec: c4 0f bf 84 ldub [ %fp + -124 ], %g2
400106f0: c4 28 60 08 stb %g2, [ %g1 + 8 ]
400106f4: c4 17 bf 84 lduh [ %fp + -124 ], %g2
400106f8: c4 28 60 09 stb %g2, [ %g1 + 9 ]
400106fc: c4 07 bf 84 ld [ %fp + -124 ], %g2
40010700: 85 30 a0 08 srl %g2, 8, %g2
40010704: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40010708: c4 07 bf 80 ld [ %fp + -128 ], %g2
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4001070c: c8 07 bf 84 ld [ %fp + -124 ], %g4
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40010710: c4 28 60 0f stb %g2, [ %g1 + 0xf ]
40010714: b9 30 a0 18 srl %g2, 0x18, %i4
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010718: c8 28 60 0b stb %g4, [ %g1 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4001071c: 89 30 a0 10 srl %g2, 0x10, %g4
40010720: f8 28 60 0c stb %i4, [ %g1 + 0xc ]
40010724: 85 30 a0 08 srl %g2, 8, %g2
40010728: c8 28 60 0d stb %g4, [ %g1 + 0xd ]
4001072c: c4 28 60 0e stb %g2, [ %g1 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40010730: c4 0f bf 94 ldub [ %fp + -108 ], %g2
40010734: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
40010738: c4 17 bf 94 lduh [ %fp + -108 ], %g2
4001073c: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
40010740: c4 07 bf 94 ld [ %fp + -108 ], %g2
40010744: 85 30 a0 08 srl %g2, 8, %g2
40010748: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
4001074c: c4 07 bf 94 ld [ %fp + -108 ], %g2
40010750: c4 28 60 13 stb %g2, [ %g1 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40010754: c4 0f bf 98 ldub [ %fp + -104 ], %g2
40010758: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
4001075c: c4 17 bf 98 lduh [ %fp + -104 ], %g2
40010760: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40010764: c4 07 bf 98 ld [ %fp + -104 ], %g2
40010768: 85 30 a0 08 srl %g2, 8, %g2
4001076c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40010770: c4 07 bf 98 ld [ %fp + -104 ], %g2
40010774: c4 28 60 17 stb %g2, [ %g1 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
40010778: c4 0f bf a0 ldub [ %fp + -96 ], %g2
4001077c: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
40010780: c4 17 bf a0 lduh [ %fp + -96 ], %g2
40010784: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
40010788: c4 07 bf a0 ld [ %fp + -96 ], %g2
4001078c: 85 30 a0 08 srl %g2, 8, %g2
40010790: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
40010794: c4 07 bf a0 ld [ %fp + -96 ], %g2
40010798: c4 28 60 1b stb %g2, [ %g1 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
4001079c: c4 0f bf a4 ldub [ %fp + -92 ], %g2
400107a0: c4 28 60 1c stb %g2, [ %g1 + 0x1c ]
400107a4: c4 17 bf a4 lduh [ %fp + -92 ], %g2
400107a8: c4 28 60 1d stb %g2, [ %g1 + 0x1d ]
400107ac: c4 07 bf a4 ld [ %fp + -92 ], %g2
400107b0: 85 30 a0 08 srl %g2, 8, %g2
400107b4: c4 28 60 1e stb %g2, [ %g1 + 0x1e ]
400107b8: c4 07 bf a4 ld [ %fp + -92 ], %g2
400107bc: c4 28 60 1f stb %g2, [ %g1 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
400107c0: c4 0f bf a8 ldub [ %fp + -88 ], %g2
400107c4: c4 28 60 20 stb %g2, [ %g1 + 0x20 ]
400107c8: c4 17 bf a8 lduh [ %fp + -88 ], %g2
400107cc: c4 28 60 21 stb %g2, [ %g1 + 0x21 ]
400107d0: c4 07 bf a8 ld [ %fp + -88 ], %g2
400107d4: 85 30 a0 08 srl %g2, 8, %g2
400107d8: c4 28 60 22 stb %g2, [ %g1 + 0x22 ]
400107dc: c4 07 bf a8 ld [ %fp + -88 ], %g2
400107e0: c4 28 60 23 stb %g2, [ %g1 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
400107e4: 84 10 20 38 mov 0x38, %g2
400107e8: c0 28 60 24 clrb [ %g1 + 0x24 ]
400107ec: c4 28 60 27 stb %g2, [ %g1 + 0x27 ]
400107f0: c0 28 60 25 clrb [ %g1 + 0x25 ]
400107f4: c0 28 60 26 clrb [ %g1 + 0x26 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400107f8: 7f ff fc fb call 4000fbe4 <rtems_rfs_buffer_handle_release>
400107fc: c6 2f bf 54 stb %g3, [ %fp + -172 ]
rtems_rfs_buffer_handle_release (fs, handle);
40010800: 92 07 bf 54 add %fp, -172, %o1
40010804: b8 10 00 08 mov %o0, %i4
if (rc > 0)
40010808: 80 a7 20 00 cmp %i4, 0
4001080c: 04 80 00 17 ble 40010868 <rtems_rfs_format+0x7b0>
<== ALWAYS TAKEN
40010810: 90 07 bf 7c add %fp, -132, %o0
40010814: 7f ff fc f4 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40010818: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
4001081c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
handle->dirty = false;
40010820: c0 2f bf 54 clrb [ %fp + -172 ]
<== NOT EXECUTED
handle->bnum = 0;
40010824: c0 27 bf 58 clr [ %fp + -168 ]
<== NOT EXECUTED
40010828: 40 00 3b 1e call 4001f4a0 <strerror>
<== NOT EXECUTED
4001082c: c0 27 bf 5c clr [ %fp + -164 ]
<== NOT EXECUTED
40010830: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40010834: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010838: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
4001083c: 40 00 0a d3 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010840: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400225a0 <ramdisk_ops+0x888>
<== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
40010844: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010848: 40 00 0a df call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001084c: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400225e0 <ramdisk_ops+0x8c8>
<== NOT EXECUTED
errno = EIO;
40010850: 40 00 37 3f call 4001e54c <__errno>
<== NOT EXECUTED
40010854: 01 00 00 00 nop
<== NOT EXECUTED
40010858: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
4001085c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40010860: 81 c7 e0 08 ret
<== NOT EXECUTED
40010864: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40010868: 7f ff fc df call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001086c: 01 00 00 00 nop
}
for (group = 0; group < fs.group_count; group++)
40010870: c2 07 bf a0 ld [ %fp + -96 ], %g1
40010874: 80 a0 60 00 cmp %g1, 0
40010878: 04 80 00 a1 ble 40010afc <rtems_rfs_format+0xa44>
<== NEVER TAKEN
4001087c: c2 07 bf 80 ld [ %fp + -128 ], %g1
if (group_base > rtems_rfs_fs_blocks (fs))
40010880: 80 a0 60 00 cmp %g1, 0
40010884: 02 80 00 34 be 40010954 <rtems_rfs_format+0x89c>
<== NEVER TAKEN
40010888: 29 10 00 89 sethi %hi(0x40022400), %l4
printf (", inodes");
4001088c: 86 15 23 78 or %l4, 0x378, %g3 ! 40022778 <ramdisk_ops+0xa60>
40010890: c6 27 bf 3c st %g3, [ %fp + -196 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40010894: 25 10 00 89 sethi %hi(0x40022400), %l2
if (!rtems_rfs_write_group (&fs, group,
40010898: ea 0e 60 14 ldub [ %i1 + 0x14 ], %l5
4001089c: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2
group_base = rtems_rfs_fs_block (fs, group, 0);
400108a0: f6 07 bf a4 ld [ %fp + -92 ], %i3
printf (", blocks");
400108a4: 23 10 00 89 sethi %hi(0x40022400), %l1
group_base = rtems_rfs_fs_block (fs, group, 0);
400108a8: b8 10 20 01 mov 1, %i4
400108ac: a0 10 20 00 clr %l0
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400108b0: a4 14 a2 50 or %l2, 0x250, %l2
printf (", blocks");
400108b4: a2 14 62 88 or %l1, 0x288, %l1
rtems_rfs_buffer_mark_dirty (&handle);
400108b8: a6 10 20 01 mov 1, %l3
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
400108bc: 86 06 c0 1c add %i3, %i4, %g3
400108c0: 80 a0 c0 01 cmp %g3, %g1
400108c4: 38 80 00 02 bgu,a 400108cc <rtems_rfs_format+0x814>
<== ALWAYS TAKEN
400108c8: b6 20 40 1c sub %g1, %i4, %i3
if (verbose)
400108cc: b4 88 a0 ff andcc %g2, 0xff, %i2
400108d0: 12 80 00 46 bne 400109e8 <rtems_rfs_format+0x930>
<== NEVER TAKEN
400108d4: 96 10 00 1b mov %i3, %o3
handle->dirty = false;
400108d8: c0 2f bf 48 clrb [ %fp + -184 ]
handle->bnum = 0;
400108dc: c0 27 bf 4c clr [ %fp + -180 ]
handle->buffer = NULL;
400108e0: c0 27 bf 50 clr [ %fp + -176 ]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
400108e4: 98 10 00 1c mov %i4, %o4
400108e8: 96 10 00 1b mov %i3, %o3
400108ec: 94 07 bf 48 add %fp, -184, %o2
400108f0: 92 07 bf 7c add %fp, -132, %o1
400108f4: 7f ff fa e1 call 4000f478 <rtems_rfs_bitmap_open>
400108f8: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
400108fc: ac 92 20 00 orcc %o0, 0, %l6
40010900: 04 80 00 1f ble 4001097c <rtems_rfs_format+0x8c4>
<== ALWAYS TAKEN
40010904: 92 07 bf 48 add %fp, -184, %o1
rtems_rfs_buffer_handle_release (fs, handle);
40010908: 7f ff fc b7 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001090c: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40010910: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
handle->dirty = false;
40010914: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010918: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
4001091c: 40 00 3a e1 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010920: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40010924: 94 10 00 16 mov %l6, %o2
<== NOT EXECUTED
40010928: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
4001092c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010930: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010934: 40 00 0a 95 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010938: 90 12 22 98 or %o0, 0x298, %o0 ! 40022698 <ramdisk_ops+0x980>
<== NOT EXECUTED
config->initialise_inodes, config->verbose))
{
errno = EIO;
4001093c: 40 00 37 04 call 4001e54c <__errno>
<== NOT EXECUTED
40010940: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40010944: 82 10 20 05 mov 5, %g1
<== NOT EXECUTED
40010948: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
4001094c: 81 c7 e0 08 ret
<== NOT EXECUTED
40010950: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40010954: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010958: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
4001095c: 40 00 0a 8b call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010960: 90 12 22 10 or %o0, 0x210, %o0 ! 40022610 <ramdisk_ops+0x8f8>
<== NOT EXECUTED
errno = EIO;
40010964: 40 00 36 fa call 4001e54c <__errno>
<== NOT EXECUTED
40010968: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001096c: 82 10 20 05 mov 5, %g1
<== NOT EXECUTED
40010970: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40010974: 81 c7 e0 08 ret
<== NOT EXECUTED
40010978: 81 e8 00 00 restore
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4001097c: c2 07 bf 50 ld [ %fp + -176 ], %g1
40010980: d4 07 bf 84 ld [ %fp + -124 ], %o2
40010984: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40010988: 40 00 37 a9 call 4001e82c <memset>
4001098c: 92 10 20 ff mov 0xff, %o1
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40010990: 7f ff fa 06 call 4000f1a8 <rtems_rfs_bitmap_map_clear_all>
40010994: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40010998: ac 92 20 00 orcc %o0, 0, %l6
4001099c: 04 80 00 1e ble 40010a14 <rtems_rfs_format+0x95c>
<== ALWAYS TAKEN
400109a0: 92 10 20 00 clr %o1
rtems_rfs_bitmap_close (&bitmap);
400109a4: 7f ff fa c6 call 4000f4bc <rtems_rfs_bitmap_close>
<== NOT EXECUTED
400109a8: 90 07 bf 54 add %fp, -172, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400109ac: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
400109b0: 7f ff fc 8d call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400109b4: 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",
400109b8: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
handle->dirty = false;
400109bc: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
400109c0: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
400109c4: 40 00 3a b7 call 4001f4a0 <strerror>
<== NOT EXECUTED
400109c8: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
400109cc: 94 10 00 16 mov %l6, %o2
<== NOT EXECUTED
400109d0: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
400109d4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400109d8: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
400109dc: 40 00 0a 6b call 40013388 <__wrap_printf>
<== NOT EXECUTED
400109e0: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 400226e0 <ramdisk_ops+0x9c8>
<== NOT EXECUTED
400109e4: 30 bf ff d6 b,a 4001093c <rtems_rfs_format+0x884>
<== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400109e8: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
400109ec: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400109f0: 40 00 0a 66 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400109f4: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
printf (", blocks");
400109f8: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
handle->dirty = false;
400109fc: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010a00: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40010a04: 40 00 0a 61 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010a08: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40010a0c: 10 bf ff b7 b 400108e8 <rtems_rfs_format+0x830>
<== NOT EXECUTED
40010a10: 98 10 00 1c mov %i4, %o4
<== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
40010a14: 7f ff f9 59 call 4000ef78 <rtems_rfs_bitmap_map_set>
40010a18: 90 07 bf 54 add %fp, -172, %o0
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
40010a1c: 92 10 20 01 mov 1, %o1
40010a20: 7f ff f9 56 call 4000ef78 <rtems_rfs_bitmap_map_set>
40010a24: 90 07 bf 54 add %fp, -172, %o0
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40010a28: c2 07 bf a8 ld [ %fp + -88 ], %g1
if (dividend == 0)
40010a2c: 80 a0 60 00 cmp %g1, 0
40010a30: 02 80 00 74 be 40010c00 <rtems_rfs_format+0xb48>
<== NEVER TAKEN
40010a34: 92 10 20 02 mov 2, %o1
return ((dividend - 1) / divisor) + 1;
40010a38: 82 00 7f ff add %g1, -1, %g1
40010a3c: 81 80 20 00 wr %g0, %y
40010a40: ee 07 bf ac ld [ %fp + -84 ], %l7
40010a44: 01 00 00 00 nop
40010a48: 01 00 00 00 nop
40010a4c: ae 70 40 17 udiv %g1, %l7, %l7
40010a50: ac 05 e0 01 add %l7, 1, %l6
for (b = 0; b < blocks; b++)
40010a54: 80 a5 a0 00 cmp %l6, 0
40010a58: 04 80 00 0a ble 40010a80 <rtems_rfs_format+0x9c8>
<== NEVER TAKEN
40010a5c: ae 05 e0 03 add %l7, 3, %l7
40010a60: a8 10 20 02 mov 2, %l4
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40010a64: 92 10 00 14 mov %l4, %o1
40010a68: 7f ff f9 44 call 4000ef78 <rtems_rfs_bitmap_map_set>
40010a6c: 90 07 bf 54 add %fp, -172, %o0
40010a70: a8 05 20 01 inc %l4
for (b = 0; b < blocks; b++)
40010a74: 80 a5 c0 14 cmp %l7, %l4
40010a78: 12 bf ff fc bne 40010a68 <rtems_rfs_format+0x9b0>
40010a7c: 92 10 00 14 mov %l4, %o1
rc = rtems_rfs_bitmap_close (&bitmap);
40010a80: 7f ff fa 8f call 4000f4bc <rtems_rfs_bitmap_close>
40010a84: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40010a88: ae 92 20 00 orcc %o0, 0, %l7
40010a8c: 14 80 00 66 bg 40010c24 <rtems_rfs_format+0xb6c>
<== NEVER TAKEN
40010a90: 92 07 bf 48 add %fp, -184, %o1
if (verbose)
40010a94: 80 a6 a0 00 cmp %i2, 0
40010a98: 12 80 00 9f bne 40010d14 <rtems_rfs_format+0xc5c>
<== NEVER TAKEN
40010a9c: e6 2f bf 48 stb %l3, [ %fp + -184 ]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40010aa0: 96 10 00 1b mov %i3, %o3
40010aa4: 98 04 20 02 add %l0, 2, %o4
40010aa8: 94 07 bf 48 add %fp, -184, %o2
40010aac: 92 07 bf 7c add %fp, -132, %o1
40010ab0: 7f ff fa 72 call 4000f478 <rtems_rfs_bitmap_open>
40010ab4: 90 07 bf 54 add %fp, -172, %o0
if (rc > 0)
40010ab8: b6 92 20 00 orcc %o0, 0, %i3
40010abc: 04 80 00 7a ble 40010ca4 <rtems_rfs_format+0xbec>
<== ALWAYS TAKEN
40010ac0: 92 07 bf 48 add %fp, -184, %o1
rtems_rfs_buffer_handle_release (fs, handle);
40010ac4: 7f ff fc 48 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40010ac8: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
40010acc: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40010ad0: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010ad4: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40010ad8: 40 00 3a 72 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010adc: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40010ae0: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40010ae4: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40010ae8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010aec: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010af0: 40 00 0a 26 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010af4: 90 12 23 88 or %o0, 0x388, %o0 ! 40022788 <ramdisk_ops+0xa70>
<== NOT EXECUTED
40010af8: 30 bf ff 91 b,a 4001093c <rtems_rfs_format+0x884>
<== NOT EXECUTED
}
if (config->verbose)
40010afc: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40010b00: 80 a0 60 00 cmp %g1, 0
40010b04: 12 80 00 65 bne 40010c98 <rtems_rfs_format+0xbe0>
<== NEVER TAKEN
40010b08: 01 00 00 00 nop
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
40010b0c: 7f ff fd 32 call 4000ffd4 <rtems_rfs_buffer_close>
40010b10: 90 07 bf 7c add %fp, -132, %o0
if (rc != 0)
40010b14: ba 92 20 00 orcc %o0, 0, %i5
40010b18: 12 80 01 41 bne 4001101c <rtems_rfs_format+0xf64>
<== NEVER TAKEN
40010b1c: 98 07 bf 44 add %fp, -188, %o4
rc = rtems_rfs_fs_open (name, NULL,
40010b20: 96 10 20 00 clr %o3
40010b24: 94 10 20 06 mov 6, %o2
40010b28: 92 10 20 00 clr %o1
40010b2c: 40 00 2d e4 call 4001c2bc <rtems_rfs_fs_open>
40010b30: 90 10 00 18 mov %i0, %o0
if (rc != 0)
40010b34: 80 a2 20 00 cmp %o0, 0
40010b38: 12 80 00 49 bne 40010c5c <rtems_rfs_format+0xba4>
<== NEVER TAKEN
40010b3c: 94 07 bf 48 add %fp, -184, %o2
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
40010b40: d0 07 bf 44 ld [ %fp + -188 ], %o0
40010b44: 40 00 03 17 call 400117a0 <rtems_rfs_inode_alloc>
40010b48: 92 10 20 01 mov 1, %o1
if (rc != 0)
40010b4c: b0 92 20 00 orcc %o0, 0, %i0
40010b50: 12 80 00 87 bne 40010d6c <rtems_rfs_format+0xcb4>
<== NEVER TAKEN
40010b54: d2 07 bf 48 ld [ %fp + -184 ], %o1
if (ino != RTEMS_RFS_ROOT_INO)
40010b58: 80 a2 60 01 cmp %o1, 1
40010b5c: 12 80 00 72 bne 40010d24 <rtems_rfs_format+0xc6c>
<== NEVER TAKEN
40010b60: 96 10 20 01 mov 1, %o3
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40010b64: d0 07 bf 44 ld [ %fp + -188 ], %o0
40010b68: 94 07 bf 54 add %fp, -172, %o2
40010b6c: 40 00 03 44 call 4001187c <rtems_rfs_inode_open>
40010b70: 92 10 20 01 mov 1, %o1
if (rc != 0)
40010b74: b0 92 20 00 orcc %o0, 0, %i0
40010b78: 12 80 00 fa bne 40010f60 <rtems_rfs_format+0xea8>
<== NEVER TAKEN
40010b7c: 98 10 20 00 clr %o4
rc = rtems_rfs_inode_initialise (&inode, 0,
40010b80: 96 10 20 00 clr %o3
40010b84: 92 10 20 00 clr %o1
40010b88: 15 00 00 10 sethi %hi(0x4000), %o2
40010b8c: 90 07 bf 54 add %fp, -172, %o0
40010b90: 40 00 04 4b call 40011cbc <rtems_rfs_inode_initialise>
40010b94: 94 12 a1 c9 or %o2, 0x1c9, %o2
if (rc != 0)
40010b98: ba 92 20 00 orcc %o0, 0, %i5
40010b9c: 12 80 00 d7 bne 40010ef8 <rtems_rfs_format+0xe40>
<== NEVER TAKEN
40010ba0: 01 00 00 00 nop
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40010ba4: d8 07 bf 48 ld [ %fp + -184 ], %o4
40010ba8: d0 07 bf 44 ld [ %fp + -188 ], %o0
40010bac: 96 10 20 01 mov 1, %o3
40010bb0: 92 07 bf 54 add %fp, -172, %o1
40010bb4: 15 10 00 85 sethi %hi(0x40021400), %o2
40010bb8: 40 00 25 f5 call 4001a38c <rtems_rfs_dir_add_entry>
40010bbc: 94 12 a1 d0 or %o2, 0x1d0, %o2 ! 400215d0 <rtems_test_name+0x120>
if (rc != 0)
40010bc0: ba 92 20 00 orcc %o0, 0, %i5
40010bc4: 12 80 00 c4 bne 40010ed4 <rtems_rfs_format+0xe1c>
<== NEVER TAKEN
40010bc8: 01 00 00 00 nop
rc = rtems_rfs_inode_close (fs, &inode);
40010bcc: d0 07 bf 44 ld [ %fp + -188 ], %o0
40010bd0: 40 00 03 a2 call 40011a58 <rtems_rfs_inode_close>
40010bd4: 92 07 bf 54 add %fp, -172, %o1
if (rc != 0)
40010bd8: ba 92 20 00 orcc %o0, 0, %i5
40010bdc: 12 80 00 b6 bne 40010eb4 <rtems_rfs_format+0xdfc>
<== NEVER TAKEN
40010be0: 01 00 00 00 nop
rc = rtems_rfs_fs_close (fs);
40010be4: 40 00 2f c0 call 4001cae4 <rtems_rfs_fs_close>
40010be8: d0 07 bf 44 ld [ %fp + -188 ], %o0
if (rc != 0)
40010bec: b0 92 20 00 orcc %o0, 0, %i0
40010bf0: 12 80 00 a5 bne 40010e84 <rtems_rfs_format+0xdcc>
<== NEVER TAKEN
40010bf4: 01 00 00 00 nop
errno = rc;
return -1;
}
return 0;
}
40010bf8: 81 c7 e0 08 ret
40010bfc: 81 e8 00 00 restore
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40010c00: 7f ff f8 de call 4000ef78 <rtems_rfs_bitmap_map_set>
<== NOT EXECUTED
40010c04: 90 07 bf 54 add %fp, -172, %o0
<== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
40010c08: 90 07 bf 54 add %fp, -172, %o0
<== NOT EXECUTED
40010c0c: 7f ff fa 2c call 4000f4bc <rtems_rfs_bitmap_close>
<== NOT EXECUTED
40010c10: ac 10 20 01 mov 1, %l6
<== NOT EXECUTED
if (rc > 0)
40010c14: ae 92 20 00 orcc %o0, 0, %l7
<== NOT EXECUTED
40010c18: 04 bf ff a0 ble 40010a98 <rtems_rfs_format+0x9e0>
<== NOT EXECUTED
40010c1c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40010c20: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40010c24: 7f ff fb f0 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40010c28: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40010c2c: 90 10 00 17 mov %l7, %o0
<== NOT EXECUTED
handle->dirty = false;
40010c30: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010c34: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40010c38: 40 00 3a 1a call 4001f4a0 <strerror>
<== NOT EXECUTED
40010c3c: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40010c40: 94 10 00 17 mov %l7, %o2
<== NOT EXECUTED
40010c44: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40010c48: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010c4c: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010c50: 40 00 09 ce call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010c54: 90 12 23 30 or %o0, 0x330, %o0 ! 40022730 <ramdisk_ops+0xa18>
<== NOT EXECUTED
40010c58: 30 bf ff 39 b,a 4001093c <rtems_rfs_format+0x884>
<== NOT EXECUTED
rc = errno;
40010c5c: 40 00 36 3c call 4001e54c <__errno>
<== NOT EXECUTED
40010c60: 01 00 00 00 nop
<== NOT EXECUTED
40010c64: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
40010c68: 40 00 3a 0e call 4001f4a0 <strerror>
<== NOT EXECUTED
40010c6c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40010c70: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010c74: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010c78: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010c7c: 40 00 09 c3 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010c80: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400228e0 <ramdisk_ops+0xbc8>
<== NOT EXECUTED
if (rc != 0)
40010c84: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40010c88: 12 80 00 2d bne 40010d3c <rtems_rfs_format+0xc84>
<== NOT EXECUTED
40010c8c: 01 00 00 00 nop
<== NOT EXECUTED
}
40010c90: 81 c7 e0 08 ret
<== NOT EXECUTED
40010c94: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("\n");
40010c98: 40 00 09 d1 call 400133dc <__wrap_putchar>
<== NOT EXECUTED
40010c9c: 90 10 20 0a mov 0xa, %o0
<== NOT EXECUTED
40010ca0: 30 bf ff 9b b,a 40010b0c <rtems_rfs_format+0xa54>
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
40010ca4: c2 07 bf 50 ld [ %fp + -176 ], %g1
40010ca8: d4 07 bf 84 ld [ %fp + -124 ], %o2
40010cac: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40010cb0: 40 00 36 df call 4001e82c <memset>
40010cb4: 92 10 20 00 clr %o1
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40010cb8: 7f ff f9 3c call 4000f1a8 <rtems_rfs_bitmap_map_clear_all>
40010cbc: 90 07 bf 54 add %fp, -172, %o0
40010cc0: b6 10 00 08 mov %o0, %i3
if (rc > 0)
40010cc4: 80 a6 e0 00 cmp %i3, 0
40010cc8: 04 80 00 33 ble 40010d94 <rtems_rfs_format+0xcdc>
<== ALWAYS TAKEN
40010ccc: 90 07 bf 54 add %fp, -172, %o0
rtems_rfs_bitmap_close (&bitmap);
40010cd0: 7f ff f9 fb call 4000f4bc <rtems_rfs_bitmap_close>
<== NOT EXECUTED
40010cd4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40010cd8: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40010cdc: 7f ff fb c2 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40010ce0: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
40010ce4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40010ce8: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010cec: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40010cf0: 40 00 39 ec call 4001f4a0 <strerror>
<== NOT EXECUTED
40010cf4: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40010cf8: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40010cfc: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40010d00: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010d04: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010d08: 40 00 09 a0 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010d0c: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 400227d0 <ramdisk_ops+0xab8>
<== NOT EXECUTED
40010d10: 30 bf ff 0b b,a 4001093c <rtems_rfs_format+0x884>
<== NOT EXECUTED
printf (", inodes");
40010d14: 40 00 09 9d call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010d18: d0 07 bf 3c ld [ %fp + -196 ], %o0
<== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40010d1c: 10 bf ff 62 b 40010aa4 <rtems_rfs_format+0x9ec>
<== NOT EXECUTED
40010d20: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40010d24: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010d28: 40 00 09 98 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010d2c: 90 12 21 50 or %o0, 0x150, %o0 ! 40022950 <ramdisk_ops+0xc38>
<== NOT EXECUTED
rtems_rfs_fs_close (fs);
40010d30: 40 00 2f 6d call 4001cae4 <rtems_rfs_fs_close>
<== NOT EXECUTED
40010d34: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
return EINVAL;
40010d38: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
40010d3c: 40 00 39 d9 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010d40: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40010d44: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010d48: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010d4c: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010d50: 40 00 09 8e call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010d54: 90 12 22 90 or %o0, 0x290, %o0 ! 40022a90 <ramdisk_ops+0xd78>
<== NOT EXECUTED
errno = rc;
40010d58: 40 00 35 fd call 4001e54c <__errno>
<== NOT EXECUTED
40010d5c: 01 00 00 00 nop
<== NOT EXECUTED
40010d60: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
return -1;
40010d64: 81 c7 e0 08 ret
<== NOT EXECUTED
40010d68: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
40010d6c: 40 00 39 cd call 4001f4a0 <strerror>
<== NOT EXECUTED
40010d70: 01 00 00 00 nop
<== NOT EXECUTED
40010d74: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010d78: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010d7c: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010d80: 40 00 09 82 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010d84: 90 12 21 18 or %o0, 0x118, %o0 ! 40022918 <ramdisk_ops+0xc00>
<== NOT EXECUTED
rtems_rfs_fs_close (fs);
40010d88: 40 00 2f 57 call 4001cae4 <rtems_rfs_fs_close>
<== NOT EXECUTED
40010d8c: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
40010d90: 30 bf ff eb b,a 40010d3c <rtems_rfs_format+0xc84>
<== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
40010d94: 7f ff f9 ca call 4000f4bc <rtems_rfs_bitmap_close>
40010d98: 01 00 00 00 nop
if (rc > 0)
40010d9c: b6 92 20 00 orcc %o0, 0, %i3
40010da0: 14 80 00 2a bg 40010e48 <rtems_rfs_format+0xd90>
<== NEVER TAKEN
40010da4: 80 8d 60 ff btst 0xff, %l5
if (initialise_inodes)
40010da8: 02 80 00 5d be 40010f1c <rtems_rfs_format+0xe64>
<== ALWAYS TAKEN
40010dac: e6 2f bf 48 stb %l3, [ %fp + -184 ]
for (b = 0; b < blocks; b++)
40010db0: 80 a5 a0 00 cmp %l6, 0
<== NOT EXECUTED
40010db4: 04 80 00 5a ble 40010f1c <rtems_rfs_format+0xe64>
<== NOT EXECUTED
40010db8: b8 07 20 02 add %i4, 2, %i4
<== NOT EXECUTED
40010dbc: 10 80 00 0a b 40010de4 <rtems_rfs_format+0xd2c>
<== NOT EXECUTED
40010dc0: ac 05 80 1c add %l6, %i4, %l6
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40010dc4: c2 07 bf 50 ld [ %fp + -176 ], %g1
<== NOT EXECUTED
40010dc8: d4 07 bf 84 ld [ %fp + -124 ], %o2
<== NOT EXECUTED
40010dcc: 40 00 36 98 call 4001e82c <memset>
<== NOT EXECUTED
40010dd0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
<== NOT EXECUTED
40010dd4: b8 07 20 01 inc %i4
<== NOT EXECUTED
for (b = 0; b < blocks; b++)
40010dd8: 80 a5 80 1c cmp %l6, %i4
<== NOT EXECUTED
40010ddc: 02 80 00 50 be 40010f1c <rtems_rfs_format+0xe64>
<== NOT EXECUTED
40010de0: e6 2f bf 48 stb %l3, [ %fp + -184 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40010de4: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40010de8: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40010dec: 96 10 20 00 clr %o3
<== NOT EXECUTED
40010df0: 7f ff fa b6 call 4000f8c8 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
40010df4: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40010df8: 92 10 20 ff mov 0xff, %o1
<== NOT EXECUTED
if (rc > 0)
40010dfc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40010e00: 04 bf ff f1 ble 40010dc4 <rtems_rfs_format+0xd0c>
<== NOT EXECUTED
40010e04: b6 10 00 08 mov %o0, %i3
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40010e08: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40010e0c: 7f ff fb 76 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40010e10: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40010e14: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40010e18: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010e1c: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40010e20: 40 00 39 a0 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010e24: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40010e28: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
40010e2c: 98 10 00 08 mov %o0, %o4
<== NOT EXECUTED
40010e30: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40010e34: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010e38: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010e3c: 40 00 09 53 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010e40: 90 12 20 68 or %o0, 0x68, %o0 ! 40022868 <ramdisk_ops+0xb50>
<== NOT EXECUTED
40010e44: 30 bf fe be b,a 4001093c <rtems_rfs_format+0x884>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40010e48: 92 07 bf 48 add %fp, -184, %o1
<== NOT EXECUTED
40010e4c: 7f ff fb 66 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40010e50: 90 07 bf 7c add %fp, -132, %o0
<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
40010e54: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
handle->dirty = false;
40010e58: c0 2f bf 48 clrb [ %fp + -184 ]
<== NOT EXECUTED
handle->bnum = 0;
40010e5c: c0 27 bf 4c clr [ %fp + -180 ]
<== NOT EXECUTED
40010e60: 40 00 39 90 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010e64: c0 27 bf 50 clr [ %fp + -176 ]
<== NOT EXECUTED
40010e68: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40010e6c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40010e70: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010e74: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010e78: 40 00 09 44 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010e7c: 90 12 20 20 or %o0, 0x20, %o0 ! 40022820 <ramdisk_ops+0xb08>
<== NOT EXECUTED
40010e80: 30 bf fe af b,a 4001093c <rtems_rfs_format+0x884>
<== NOT EXECUTED
rc = errno;
40010e84: 40 00 35 b2 call 4001e54c <__errno>
<== NOT EXECUTED
40010e88: 01 00 00 00 nop
<== NOT EXECUTED
40010e8c: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
40010e90: 40 00 39 84 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010e94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40010e98: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010e9c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010ea0: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010ea4: 40 00 09 39 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010ea8: 90 12 22 58 or %o0, 0x258, %o0 ! 40022a58 <ramdisk_ops+0xd40>
<== NOT EXECUTED
if (rc != 0)
40010eac: 10 bf ff 77 b 40010c88 <rtems_rfs_format+0xbd0>
<== NOT EXECUTED
40010eb0: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40010eb4: 40 00 39 7b call 4001f4a0 <strerror>
<== NOT EXECUTED
40010eb8: 01 00 00 00 nop
<== NOT EXECUTED
40010ebc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010ec0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010ec4: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010ec8: 40 00 09 30 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010ecc: 90 12 22 28 or %o0, 0x228, %o0 ! 40022a28 <ramdisk_ops+0xd10>
<== NOT EXECUTED
40010ed0: 30 bf ff 45 b,a 40010be4 <rtems_rfs_format+0xb2c>
<== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40010ed4: 40 00 39 73 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010ed8: 01 00 00 00 nop
<== NOT EXECUTED
40010edc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010ee0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010ee4: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010ee8: 40 00 09 28 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010eec: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400229f0 <ramdisk_ops+0xcd8>
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
40010ef0: 10 bf ff 38 b 40010bd0 <rtems_rfs_format+0xb18>
<== NOT EXECUTED
40010ef4: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
40010ef8: 40 00 39 6a call 4001f4a0 <strerror>
<== NOT EXECUTED
40010efc: 01 00 00 00 nop
<== NOT EXECUTED
40010f00: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010f04: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010f08: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010f0c: 40 00 09 1f call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010f10: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400229b8 <ramdisk_ops+0xca0>
<== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40010f14: 10 bf ff 25 b 40010ba8 <rtems_rfs_format+0xaf0>
<== NOT EXECUTED
40010f18: d8 07 bf 48 ld [ %fp + -184 ], %o4
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40010f1c: 92 07 bf 48 add %fp, -184, %o1
40010f20: 7f ff fb 31 call 4000fbe4 <rtems_rfs_buffer_handle_release>
40010f24: 90 07 bf 7c add %fp, -132, %o0
for (group = 0; group < fs.group_count; group++)
40010f28: c2 07 bf a0 ld [ %fp + -96 ], %g1
40010f2c: ba 07 60 01 inc %i5
40010f30: 80 a0 40 1d cmp %g1, %i5
40010f34: 04 bf fe f2 ble 40010afc <rtems_rfs_format+0xa44>
<== ALWAYS TAKEN
40010f38: f6 07 bf a4 ld [ %fp + -92 ], %i3
if (group_base > rtems_rfs_fs_blocks (fs))
40010f3c: c2 07 bf 80 ld [ %fp + -128 ], %g1
<== NOT EXECUTED
group_base = rtems_rfs_fs_block (fs, group, 0);
40010f40: a0 5f 40 1b smul %i5, %i3, %l0
<== NOT EXECUTED
40010f44: b8 04 20 01 add %l0, 1, %i4
<== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
40010f48: 80 a7 00 01 cmp %i4, %g1
<== NOT EXECUTED
40010f4c: 18 bf fe 83 bgu 40010958 <rtems_rfs_format+0x8a0>
<== NOT EXECUTED
40010f50: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
40010f54: ea 0e 60 14 ldub [ %i1 + 0x14 ], %l5
<== NOT EXECUTED
40010f58: 10 bf fe 59 b 400108bc <rtems_rfs_format+0x804>
<== NOT EXECUTED
40010f5c: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2
<== NOT EXECUTED
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
40010f60: 40 00 39 50 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010f64: 01 00 00 00 nop
<== NOT EXECUTED
40010f68: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010f6c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010f70: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40010f74: 40 00 09 05 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010f78: 90 12 21 88 or %o0, 0x188, %o0 ! 40022988 <ramdisk_ops+0xc70>
<== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
40010f7c: d4 07 bf 48 ld [ %fp + -184 ], %o2
<== NOT EXECUTED
40010f80: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
40010f84: 40 00 01 9a call 400115ec <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40010f88: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_rfs_fs_close (fs);
40010f8c: 40 00 2e d6 call 4001cae4 <rtems_rfs_fs_close>
<== NOT EXECUTED
40010f90: d0 07 bf 44 ld [ %fp + -188 ], %o0
<== NOT EXECUTED
40010f94: 30 bf ff 6a b,a 40010d3c <rtems_rfs_format+0xc84>
<== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
40010f98: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
40010f9c: 40 00 08 fb call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010fa0: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 400222b8 <ramdisk_ops+0x5a0>
<== NOT EXECUTED
errno = EINVAL;
40010fa4: 40 00 35 6a call 4001e54c <__errno>
<== NOT EXECUTED
40010fa8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40010fac: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40010fb0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
40010fb4: 81 c7 e0 08 ret
<== NOT EXECUTED
40010fb8: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
40010fbc: 40 00 39 39 call 4001f4a0 <strerror>
<== NOT EXECUTED
40010fc0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40010fc4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010fc8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010fcc: 11 10 00 89 sethi %hi(0x40022400), %o0
<== NOT EXECUTED
40010fd0: 40 00 08 ee call 40013388 <__wrap_printf>
<== NOT EXECUTED
40010fd4: 90 12 21 30 or %o0, 0x130, %o0 ! 40022530 <ramdisk_ops+0x818>
<== NOT EXECUTED
errno = rc;
40010fd8: 40 00 35 5d call 4001e54c <__errno>
<== NOT EXECUTED
40010fdc: 01 00 00 00 nop
<== NOT EXECUTED
40010fe0: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
40010fe4: 81 c7 e0 08 ret
<== NOT EXECUTED
40010fe8: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
40010fec: 40 00 39 2d call 4001f4a0 <strerror>
<== NOT EXECUTED
40010ff0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40010ff4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40010ff8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40010ffc: 11 10 00 88 sethi %hi(0x40022000), %o0
<== NOT EXECUTED
40011000: 40 00 08 e2 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011004: 90 12 22 88 or %o0, 0x288, %o0 ! 40022288 <ramdisk_ops+0x570>
<== NOT EXECUTED
errno = rc;
40011008: 40 00 35 51 call 4001e54c <__errno>
<== NOT EXECUTED
4001100c: 01 00 00 00 nop
<== NOT EXECUTED
40011010: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
40011014: 81 c7 e0 08 ret
<== NOT EXECUTED
40011018: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
4001101c: 40 00 39 21 call 4001f4a0 <strerror>
<== NOT EXECUTED
40011020: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40011024: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40011028: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001102c: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40011030: 40 00 08 d6 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011034: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400228b0 <ramdisk_ops+0xb98>
<== NOT EXECUTED
errno = rc;
40011038: 40 00 35 45 call 4001e54c <__errno>
<== NOT EXECUTED
4001103c: 01 00 00 00 nop
<== NOT EXECUTED
40011040: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
40011044: 81 c7 e0 08 ret
<== NOT EXECUTED
40011048: 81 e8 00 00 restore
<== NOT EXECUTED
4001cae4 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001cae4: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
4001cae8: 90 10 20 00 clr %o0
4001caec: 92 10 20 02 mov 2, %o1
4001caf0: 7f ff d9 98 call 40013150 <rtems_rfs_trace>
4001caf4: ba 10 00 18 mov %i0, %i5
4001caf8: 80 a2 20 00 cmp %o0, 0
4001cafc: 12 80 00 18 bne 4001cb5c <rtems_rfs_fs_close+0x78>
<== NEVER TAKEN
4001cb00: 11 10 00 91 sethi %hi(0x40024400), %o0
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
4001cb04: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4001cb08: 80 a0 60 00 cmp %g1, 0
4001cb0c: 04 80 00 0d ble 4001cb40 <rtems_rfs_fs_close+0x5c>
<== NEVER TAKEN
4001cb10: 01 00 00 00 nop
4001cb14: b6 10 20 00 clr %i3 ! 0 <PROM_START>
4001cb18: b8 10 20 00 clr %i4
rtems_rfs_group_close (fs, &fs->groups[group]);
4001cb1c: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
4001cb20: 92 02 40 1b add %o1, %i3, %o1
4001cb24: 7f ff d1 d8 call 40011284 <rtems_rfs_group_close>
4001cb28: 90 10 00 1d mov %i5, %o0
for (group = 0; group < fs->group_count; group++)
4001cb2c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4001cb30: b8 07 20 01 inc %i4
4001cb34: 80 a0 40 1c cmp %g1, %i4
4001cb38: 14 bf ff f9 bg 4001cb1c <rtems_rfs_fs_close+0x38>
<== NEVER TAKEN
4001cb3c: b6 06 e0 50 add %i3, 0x50, %i3
rtems_rfs_buffer_close (fs);
4001cb40: 7f ff cd 25 call 4000ffd4 <rtems_rfs_buffer_close>
4001cb44: 90 10 00 1d mov %i5, %o0
free (fs);
return 0;
}
4001cb48: b0 10 20 00 clr %i0
free (fs);
4001cb4c: 7f ff a6 a3 call 400065d8 <free>
4001cb50: 90 10 00 1d mov %i5, %o0
}
4001cb54: 81 c7 e0 08 ret
4001cb58: 81 e8 00 00 restore
printf ("rtems-rfs: close\n");
4001cb5c: 7f ff da 1a call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001cb60: 90 12 20 b8 or %o0, 0xb8, %o0
<== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
4001cb64: 10 bf ff e9 b 4001cb08 <rtems_rfs_fs_close+0x24>
<== NOT EXECUTED
4001cb68: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
<== NOT EXECUTED
4001c2bc <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)
{
4001c2bc: 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))
4001c2c0: 90 10 20 00 clr %o0
4001c2c4: 7f ff db a3 call 40013150 <rtems_rfs_trace>
4001c2c8: 92 10 20 01 mov 1, %o1
4001c2cc: 80 a2 20 00 cmp %o0, 0
4001c2d0: 12 80 00 ef bne 4001c68c <rtems_rfs_fs_open+0x3d0>
<== NEVER TAKEN
4001c2d4: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
4001c2d8: 7f ff a9 cf call 40006a14 <malloc>
4001c2dc: 90 10 20 84 mov 0x84, %o0
4001c2e0: d0 27 00 00 st %o0, [ %i4 ]
if (!*fs)
4001c2e4: 80 a2 20 00 cmp %o0, 0
4001c2e8: 02 80 01 e1 be 4001ca6c <rtems_rfs_fs_open+0x7b0>
<== NEVER TAKEN
4001c2ec: 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));
4001c2f0: 94 10 20 7c mov 0x7c, %o2
4001c2f4: 92 10 20 00 clr %o1
4001c2f8: 40 00 09 4d call 4001e82c <memset>
4001c2fc: 90 02 20 04 add %o0, 4, %o0
return &the_chain->Tail.Node;
4001c300: 84 07 60 44 add %i5, 0x44, %g2
4001c304: 82 07 60 48 add %i5, 0x48, %g1
tail->previous = head;
4001c308: c4 27 60 4c st %g2, [ %i5 + 0x4c ]
return &the_chain->Tail.Node;
4001c30c: 84 07 60 54 add %i5, 0x54, %g2
head->next = tail;
4001c310: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
return &the_chain->Tail.Node;
4001c314: 82 07 60 58 add %i5, 0x58, %g1
tail->previous = head;
4001c318: c4 27 60 5c st %g2, [ %i5 + 0x5c ]
return &the_chain->Tail.Node;
4001c31c: 84 07 60 64 add %i5, 0x64, %g2
head->next = tail;
4001c320: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
return &the_chain->Tail.Node;
4001c324: 82 07 60 68 add %i5, 0x68, %g1
tail->previous = head;
4001c328: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
return &the_chain->Tail.Node;
4001c32c: 84 07 60 74 add %i5, 0x74, %g2
head->next = tail;
4001c330: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
return &the_chain->Tail.Node;
4001c334: 82 07 60 78 add %i5, 0x78, %g1
(*fs)->user = user;
4001c338: f2 27 60 80 st %i1, [ %i5 + 0x80 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001c33c: 92 10 00 1d mov %i5, %o1
tail->previous = head;
4001c340: c4 27 60 7c st %g2, [ %i5 + 0x7c ]
4001c344: 90 10 00 18 mov %i0, %o0
head->next = tail;
4001c348: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
4001c34c: f6 27 60 40 st %i3, [ %i5 + 0x40 ]
rc = rtems_rfs_buffer_open (name, *fs);
4001c350: 7f ff ce 2e call 4000fc08 <rtems_rfs_buffer_open>
4001c354: f4 27 40 00 st %i2, [ %i5 ]
if (rc > 0)
4001c358: ba 92 20 00 orcc %o0, 0, %i5
4001c35c: 14 80 01 7c bg 4001c94c <rtems_rfs_fs_open+0x690>
<== NEVER TAKEN
4001c360: 96 10 20 01 mov 1, %o3
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
4001c364: f6 07 00 00 ld [ %i4 ], %i3
handle->dirty = false;
4001c368: c0 2f bf d8 clrb [ %fp + -40 ]
handle->bnum = 0;
4001c36c: c0 27 bf dc clr [ %fp + -36 ]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
4001c370: 94 10 20 00 clr %o2
handle->buffer = NULL;
4001c374: c0 27 bf e0 clr [ %fp + -32 ]
4001c378: 92 07 bf d8 add %fp, -40, %o1
4001c37c: 7f ff cd 53 call 4000f8c8 <rtems_rfs_buffer_handle_request>
4001c380: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001c384: ba 92 20 00 orcc %o0, 0, %i5
4001c388: 14 80 00 ac bg 4001c638 <rtems_rfs_fs_open+0x37c>
<== NEVER TAKEN
4001c38c: c2 07 bf e0 ld [ %fp + -32 ], %g1
sb = rtems_rfs_buffer_data (&handle);
4001c390: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
4001c394: c8 0f 40 00 ldub [ %i5 ], %g4
4001c398: c4 0f 60 01 ldub [ %i5 + 1 ], %g2
4001c39c: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
4001c3a0: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
4001c3a4: 89 29 20 18 sll %g4, 0x18, %g4
4001c3a8: 85 28 a0 10 sll %g2, 0x10, %g2
4001c3ac: 84 10 80 04 or %g2, %g4, %g2
4001c3b0: 83 28 60 08 sll %g1, 8, %g1
4001c3b4: 82 10 40 02 or %g1, %g2, %g1
4001c3b8: 05 0a 02 48 sethi %hi(0x28092000), %g2
4001c3bc: 82 10 c0 01 or %g3, %g1, %g1
4001c3c0: 84 10 a0 01 or %g2, 1, %g2
4001c3c4: 80 a0 40 02 cmp %g1, %g2
4001c3c8: 32 80 00 b5 bne,a 4001c69c <rtems_rfs_fs_open+0x3e0>
<== NEVER TAKEN
4001c3cc: 90 10 20 00 clr %o0
<== NOT EXECUTED
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
4001c3d0: c8 0f 60 0c ldub [ %i5 + 0xc ], %g4
4001c3d4: c6 0f 60 0d ldub [ %i5 + 0xd ], %g3
4001c3d8: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
4001c3dc: c4 0f 60 0f ldub [ %i5 + 0xf ], %g2
4001c3e0: 89 29 20 18 sll %g4, 0x18, %g4
4001c3e4: 87 28 e0 10 sll %g3, 0x10, %g3
4001c3e8: 83 28 60 08 sll %g1, 8, %g1
4001c3ec: 86 10 c0 04 or %g3, %g4, %g3
4001c3f0: 82 10 40 03 or %g1, %g3, %g1
4001c3f4: 84 10 80 01 or %g2, %g1, %g2
4001c3f8: c4 26 e0 04 st %g2, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001c3fc: f2 0f 60 0b ldub [ %i5 + 0xb ], %i1
4001c400: c8 0f 60 08 ldub [ %i5 + 8 ], %g4
4001c404: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
4001c408: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
4001c40c: f4 06 e0 10 ld [ %i3 + 0x10 ], %i2
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001c410: 89 29 20 18 sll %g4, 0x18, %g4
4001c414: 87 28 e0 10 sll %g3, 0x10, %g3
4001c418: 83 28 60 08 sll %g1, 8, %g1
4001c41c: 86 10 c0 04 or %g3, %g4, %g3
4001c420: 82 10 40 03 or %g1, %g3, %g1
4001c424: 82 16 40 01 or %i1, %g1, %g1
4001c428: c2 26 e0 08 st %g1, [ %i3 + 8 ]
return blocks * block_size;
4001c42c: 86 50 80 01 umul %g2, %g1, %g3
4001c430: 85 40 00 00 rd %y, %g2
return media_blocks * media_block_size;
4001c434: f0 06 a0 1c ld [ %i2 + 0x1c ], %i0
4001c438: c8 06 a0 20 ld [ %i2 + 0x20 ], %g4
4001c43c: b2 56 00 04 umul %i0, %g4, %i1
4001c440: b1 40 00 00 rd %y, %i0
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
4001c444: 80 a0 80 18 cmp %g2, %i0
4001c448: 38 80 00 d0 bgu,a 4001c788 <rtems_rfs_fs_open+0x4cc>
<== NEVER TAKEN
4001c44c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c450: 02 80 00 cb be 4001c77c <rtems_rfs_fs_open+0x4c0>
<== ALWAYS TAKEN
4001c454: 80 a0 c0 19 cmp %g3, %i1
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
4001c458: f4 0f 60 24 ldub [ %i5 + 0x24 ], %i2
<== NOT EXECUTED
4001c45c: c6 0f 60 25 ldub [ %i5 + 0x25 ], %g3
4001c460: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
4001c464: c8 0f 60 27 ldub [ %i5 + 0x27 ], %g4
4001c468: b5 2e a0 18 sll %i2, 0x18, %i2
4001c46c: 87 28 e0 10 sll %g3, 0x10, %g3
4001c470: 85 28 a0 08 sll %g2, 8, %g2
4001c474: 86 10 c0 1a or %g3, %i2, %g3
4001c478: 84 10 80 03 or %g2, %g3, %g2
4001c47c: 84 11 00 02 or %g4, %g2, %g2
4001c480: 80 a0 a0 38 cmp %g2, 0x38
4001c484: 32 80 00 a9 bne,a 4001c728 <rtems_rfs_fs_open+0x46c>
<== NEVER TAKEN
4001c488: 90 10 20 00 clr %o0
<== NOT EXECUTED
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
4001c48c: c8 0f 60 13 ldub [ %i5 + 0x13 ], %g4
4001c490: f4 0f 60 10 ldub [ %i5 + 0x10 ], %i2
4001c494: c6 0f 60 11 ldub [ %i5 + 0x11 ], %g3
4001c498: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
4001c49c: b5 2e a0 18 sll %i2, 0x18, %i2
4001c4a0: 87 28 e0 10 sll %g3, 0x10, %g3
4001c4a4: 85 28 a0 08 sll %g2, 8, %g2
4001c4a8: 86 10 c0 1a or %g3, %i2, %g3
4001c4ac: 84 10 80 03 or %g2, %g3, %g2
4001c4b0: 84 11 00 02 or %g4, %g2, %g2
4001c4b4: c4 26 e0 18 st %g2, [ %i3 + 0x18 ]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
4001c4b8: 87 30 60 02 srl %g1, 2, %g3
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
4001c4bc: f4 0f 60 17 ldub [ %i5 + 0x17 ], %i2
4001c4c0: f2 0f 60 14 ldub [ %i5 + 0x14 ], %i1
4001c4c4: c8 0f 60 15 ldub [ %i5 + 0x15 ], %g4
4001c4c8: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
4001c4cc: b3 2e 60 18 sll %i1, 0x18, %i1
4001c4d0: 89 29 20 10 sll %g4, 0x10, %g4
4001c4d4: 85 28 a0 08 sll %g2, 8, %g2
4001c4d8: 88 11 00 19 or %g4, %i1, %g4
4001c4dc: 84 10 80 04 or %g2, %g4, %g2
4001c4e0: 84 16 80 02 or %i2, %g2, %g2
4001c4e4: c4 26 e0 1c st %g2, [ %i3 + 0x1c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001c4e8: b2 58 c0 03 smul %g3, %g3, %i1
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
4001c4ec: f0 0f 60 1b ldub [ %i5 + 0x1b ], %i0
4001c4f0: f4 0f 60 18 ldub [ %i5 + 0x18 ], %i2
4001c4f4: c8 0f 60 19 ldub [ %i5 + 0x19 ], %g4
4001c4f8: c4 0f 60 1a ldub [ %i5 + 0x1a ], %g2
4001c4fc: b5 2e a0 18 sll %i2, 0x18, %i2
4001c500: 89 29 20 10 sll %g4, 0x10, %g4
4001c504: 85 28 a0 08 sll %g2, 8, %g2
4001c508: 88 11 00 1a or %g4, %i2, %g4
4001c50c: 84 10 80 04 or %g2, %g4, %g2
4001c510: 84 16 00 02 or %i0, %g2, %g2
4001c514: c4 26 e0 24 st %g2, [ %i3 + 0x24 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001c518: 9b 28 e0 02 sll %g3, 2, %o5
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
4001c51c: de 0f 60 1c ldub [ %i5 + 0x1c ], %o7
4001c520: f4 0f 60 1d ldub [ %i5 + 0x1d ], %i2
4001c524: c8 0f 60 1e ldub [ %i5 + 0x1e ], %g4
4001c528: f0 0f 60 1f ldub [ %i5 + 0x1f ], %i0
4001c52c: 9f 2b e0 18 sll %o7, 0x18, %o7
4001c530: b5 2e a0 10 sll %i2, 0x10, %i2
4001c534: 89 29 20 08 sll %g4, 8, %g4
4001c538: b4 16 80 0f or %i2, %o7, %i2
4001c53c: 88 11 00 1a or %g4, %i2, %g4
4001c540: b0 16 00 04 or %i0, %g4, %i0
4001c544: f0 26 e0 28 st %i0, [ %i3 + 0x28 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001c548: 9a 03 40 03 add %o5, %g3, %o5
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001c54c: d8 0f 60 20 ldub [ %i5 + 0x20 ], %o4
4001c550: f4 0f 60 21 ldub [ %i5 + 0x21 ], %i2
4001c554: c8 0f 60 22 ldub [ %i5 + 0x22 ], %g4
4001c558: de 0f 60 23 ldub [ %i5 + 0x23 ], %o7
4001c55c: 99 2b 20 18 sll %o4, 0x18, %o4
4001c560: bb 2e a0 10 sll %i2, 0x10, %i5
4001c564: ba 17 40 0c or %i5, %o4, %i5
4001c568: 89 29 20 08 sll %g4, 8, %g4
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001c56c: b5 2e 60 02 sll %i1, 2, %i2
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001c570: 88 11 00 1d or %g4, %i5, %g4
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001c574: b2 06 80 19 add %i2, %i1, %i1
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001c578: 88 13 c0 04 or %o7, %g4, %g4
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001c57c: bb 30 60 03 srl %g1, 3, %i5
fs->inodes = fs->group_count * fs->group_inodes;
4001c580: 84 58 80 04 smul %g2, %g4, %g2
fs->blocks_per_block =
4001c584: c6 26 e0 34 st %g3, [ %i3 + 0x34 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001c588: 07 09 24 92 sethi %hi(0x24924800), %g3
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001c58c: c8 26 e0 2c st %g4, [ %i3 + 0x2c ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001c590: 86 10 e1 25 or %g3, 0x125, %g3
fs->block_map_singly_blocks =
4001c594: da 26 e0 38 st %o5, [ %i3 + 0x38 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001c598: 80 57 40 03 umul %i5, %g3, %g0
4001c59c: 87 40 00 00 rd %y, %g3
fs->block_map_doubly_blocks =
4001c5a0: f2 26 e0 3c st %i1, [ %i3 + 0x3c ]
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
4001c5a4: 83 28 60 03 sll %g1, 3, %g1
fs->inodes = fs->group_count * fs->group_inodes;
4001c5a8: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
rtems_rfs_buffer_handle_release (fs, handle);
4001c5ac: 92 07 bf d8 add %fp, -40, %o1
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001c5b0: c6 26 e0 30 st %g3, [ %i3 + 0x30 ]
if (fs->group_blocks >
4001c5b4: 80 a6 00 01 cmp %i0, %g1
4001c5b8: 18 80 00 46 bgu 4001c6d0 <rtems_rfs_fs_open+0x414>
<== NEVER TAKEN
4001c5bc: 90 10 00 1b mov %i3, %o0
4001c5c0: 7f ff cd 89 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001c5c4: 01 00 00 00 nop
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
4001c5c8: d2 06 e0 08 ld [ %i3 + 8 ], %o1
4001c5cc: 90 10 00 1b mov %i3, %o0
handle->dirty = false;
4001c5d0: c0 2f bf d8 clrb [ %fp + -40 ]
handle->bnum = 0;
4001c5d4: c0 27 bf dc clr [ %fp + -36 ]
4001c5d8: 7f ff ce 3e call 4000fed0 <rtems_rfs_buffer_setblksize>
4001c5dc: c0 27 bf e0 clr [ %fp + -32 ]
if (rc > 0)
4001c5e0: ba 92 20 00 orcc %o0, 0, %i5
4001c5e4: 04 80 00 7b ble 4001c7d0 <rtems_rfs_fs_open+0x514>
<== ALWAYS TAKEN
4001c5e8: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_buffer_handle_release (fs, handle);
4001c5ec: 7f ff cd 7e call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001c5f0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c5f4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c5f8: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001c5fc: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
handle->bnum = 0;
4001c600: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4001c604: 7f ff da d3 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c608: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001c60c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c610: 02 80 00 10 be 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001c614: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
4001c618: 40 00 0b a2 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001c61c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c620: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c624: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c628: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c62c: 7f ff db 57 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c630: 90 12 23 38 or %o0, 0x338, %o0 ! 40024338 <status_code_to_errno+0xe1c>
<== NOT EXECUTED
4001c634: 30 80 00 07 b,a 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c638: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c63c: 7f ff da c5 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c640: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c644: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c648: 12 80 00 30 bne 4001c708 <rtems_rfs_fs_open+0x44c>
<== NOT EXECUTED
4001c64c: 01 00 00 00 nop
<== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
4001c650: 7f ff ce 61 call 4000ffd4 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001c654: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001c658: 7f ff a7 e0 call 400065d8 <free>
<== NOT EXECUTED
4001c65c: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c660: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c664: 7f ff da bb call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c668: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c66c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c670: 12 80 00 50 bne 4001c7b0 <rtems_rfs_fs_open+0x4f4>
<== NOT EXECUTED
4001c674: 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;
4001c678: 40 00 07 b5 call 4001e54c <__errno>
<== NOT EXECUTED
4001c67c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4001c680: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
4001c684: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c688: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
4001c68c: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c690: 7f ff db 3e call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c694: 90 12 21 78 or %o0, 0x178, %o0 ! 40024178 <status_code_to_errno+0xc5c>
<== NOT EXECUTED
4001c698: 30 bf ff 10 b,a 4001c2d8 <rtems_rfs_fs_open+0x1c>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c69c: 7f ff da ad call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c6a0: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c6a4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c6a8: 22 80 00 06 be,a 4001c6c0 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001c6ac: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
4001c6b0: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c6b4: 7f ff db 44 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001c6b8: 90 12 22 28 or %o0, 0x228, %o0 ! 40024228 <status_code_to_errno+0xd0c>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001c6bc: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001c6c0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4001c6c4: 7f ff cd 48 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001c6c8: ba 10 20 05 mov 5, %i5
<== NOT EXECUTED
4001c6cc: 30 bf ff e1 b,a 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001c6d0: 7f ff cd 45 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001c6d4: ba 10 20 05 mov 5, %i5
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c6d8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c6dc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001c6e0: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
handle->bnum = 0;
4001c6e4: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4001c6e8: 7f ff da 9a call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c6ec: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001c6f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c6f4: 02 bf ff d7 be 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001c6f8: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
4001c6fc: 7f ff db 32 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001c700: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 400242f0 <status_code_to_errno+0xdd4>
<== NOT EXECUTED
4001c704: 30 bf ff d3 b,a 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
4001c708: 40 00 0b 66 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001c70c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c710: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c714: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c718: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c71c: 7f ff db 1b call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c720: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400241f0 <status_code_to_errno+0xcd4>
<== NOT EXECUTED
4001c724: 30 bf ff cb b,a 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c728: 7f ff da 8a call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c72c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c730: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c734: 22 bf ff e3 be,a 4001c6c0 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001c738: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001c73c: c6 0f 60 04 ldub [ %i5 + 4 ], %g3
<== NOT EXECUTED
4001c740: c4 0f 60 05 ldub [ %i5 + 5 ], %g2
<== NOT EXECUTED
4001c744: c2 0f 60 06 ldub [ %i5 + 6 ], %g1
<== NOT EXECUTED
4001c748: d2 0f 60 07 ldub [ %i5 + 7 ], %o1
<== NOT EXECUTED
4001c74c: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
4001c750: 85 28 a0 10 sll %g2, 0x10, %g2
<== NOT EXECUTED
4001c754: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
4001c758: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
4001c75c: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
4001c760: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001c764: 92 12 40 01 or %o1, %g1, %o1
<== NOT EXECUTED
4001c768: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c76c: 7f ff db 07 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c770: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 400242a8 <status_code_to_errno+0xd8c>
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001c774: 10 bf ff d3 b 4001c6c0 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001c778: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
4001c77c: 28 bf ff 38 bleu,a 4001c45c <rtems_rfs_fs_open+0x1a0>
<== ALWAYS TAKEN
4001c780: f4 0f 60 24 ldub [ %i5 + 0x24 ], %i2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c784: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c788: 7f ff da 72 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c78c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c790: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c794: 22 bf ff cb be,a 4001c6c0 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001c798: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
4001c79c: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c7a0: 7f ff db 09 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001c7a4: 90 12 22 68 or %o0, 0x268, %o0 ! 40024268 <status_code_to_errno+0xd4c>
<== NOT EXECUTED
4001c7a8: 10 bf ff c6 b 4001c6c0 <rtems_rfs_fs_open+0x404>
<== NOT EXECUTED
4001c7ac: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
4001c7b0: 40 00 0b 3c call 4001f4a0 <strerror>
<== NOT EXECUTED
4001c7b4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c7b8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c7bc: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c7c0: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c7c4: 7f ff da f1 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c7c8: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 400243f8 <status_code_to_errno+0xedc>
<== NOT EXECUTED
4001c7cc: 30 bf ff ab b,a 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
4001c7d0: fa 06 e0 24 ld [ %i3 + 0x24 ], %i5
4001c7d4: 92 10 20 50 mov 0x50, %o1
4001c7d8: 7f ff a6 e0 call 40006358 <calloc>
4001c7dc: 90 10 00 1d mov %i5, %o0
if (!fs->groups)
4001c7e0: 80 a2 20 00 cmp %o0, 0
4001c7e4: 02 80 00 b0 be 4001caa4 <rtems_rfs_fs_open+0x7e8>
<== NEVER TAKEN
4001c7e8: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
for (group = 0; group < fs->group_count; group++)
4001c7ec: b2 10 20 00 clr %i1
4001c7f0: 80 a7 60 00 cmp %i5, 0
4001c7f4: 14 80 00 09 bg 4001c818 <rtems_rfs_fs_open+0x55c>
<== ALWAYS TAKEN
4001c7f8: b4 10 20 00 clr %i2
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001c7fc: 10 80 00 33 b 4001c8c8 <rtems_rfs_fs_open+0x60c>
<== NOT EXECUTED
4001c800: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
4001c804: b4 06 a0 01 inc %i2
4001c808: 80 a6 80 01 cmp %i2, %g1
4001c80c: 16 80 00 2e bge 4001c8c4 <rtems_rfs_fs_open+0x608>
<== ALWAYS TAKEN
4001c810: b2 06 60 50 add %i1, 0x50, %i1
4001c814: d0 06 e0 20 ld [ %i3 + 0x20 ], %o0
<== NOT EXECUTED
rtems_rfs_fs_block (fs, group, 0),
4001c818: d4 06 e0 28 ld [ %i3 + 0x28 ], %o2
rc = rtems_rfs_group_open (fs,
4001c81c: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
4001c820: 92 5e 80 0a smul %i2, %o2, %o1
rc = rtems_rfs_group_open (fs,
4001c824: 98 02 00 19 add %o0, %i1, %o4
4001c828: 92 02 60 01 inc %o1
4001c82c: 7f ff d2 08 call 4001104c <rtems_rfs_group_open>
4001c830: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001c834: ba 92 20 00 orcc %o0, 0, %i5
4001c838: 24 bf ff f3 ble,a 4001c804 <rtems_rfs_fs_open+0x548>
<== ALWAYS TAKEN
4001c83c: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
for (g = 0; g < group; g++)
4001c840: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001c844: 02 80 00 0d be 4001c878 <rtems_rfs_fs_open+0x5bc>
<== NOT EXECUTED
4001c848: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001c84c: b0 10 20 00 clr %i0
<== NOT EXECUTED
4001c850: b2 10 20 00 clr %i1
<== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
4001c854: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1
<== NOT EXECUTED
4001c858: 92 02 40 18 add %o1, %i0, %o1
<== NOT EXECUTED
4001c85c: 7f ff d2 8a call 40011284 <rtems_rfs_group_close>
<== NOT EXECUTED
4001c860: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
for (g = 0; g < group; g++)
4001c864: b2 06 60 01 inc %i1
<== NOT EXECUTED
4001c868: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
4001c86c: 12 bf ff fa bne 4001c854 <rtems_rfs_fs_open+0x598>
<== NOT EXECUTED
4001c870: b0 06 20 50 add %i0, 0x50, %i0
<== NOT EXECUTED
4001c874: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001c878: 7f ff cc db call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001c87c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c880: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c884: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001c888: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
handle->bnum = 0;
4001c88c: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4001c890: 7f ff da 30 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c894: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001c898: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c89c: 02 bf ff 6d be 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001c8a0: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
4001c8a4: 40 00 0a ff call 4001f4a0 <strerror>
<== NOT EXECUTED
4001c8a8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c8ac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c8b0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c8b4: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c8b8: 7f ff da b4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c8bc: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 400243b8 <status_code_to_errno+0xe9c>
<== NOT EXECUTED
4001c8c0: 30 bf ff 64 b,a 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
4001c8c4: d0 07 00 00 ld [ %i4 ], %o0
4001c8c8: 96 10 20 01 mov 1, %o3
4001c8cc: 94 07 bf d8 add %fp, -40, %o2
4001c8d0: 7f ff d3 eb call 4001187c <rtems_rfs_inode_open>
4001c8d4: 92 10 20 01 mov 1, %o1
if (rc > 0)
4001c8d8: ba 92 20 00 orcc %o0, 0, %i5
4001c8dc: 14 80 00 40 bg 4001c9dc <rtems_rfs_fs_open+0x720>
<== NEVER TAKEN
4001c8e0: 01 00 00 00 nop
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
4001c8e4: d0 07 00 00 ld [ %i4 ], %o0
4001c8e8: c2 02 00 00 ld [ %o0 ], %g1
4001c8ec: 80 88 60 04 btst 4, %g1
4001c8f0: 12 80 00 0f bne 4001c92c <rtems_rfs_fs_open+0x670>
4001c8f4: c4 07 bf e4 ld [ %fp + -28 ], %g2
return rtems_rfs_read_u16 (&handle->node->mode);
4001c8f8: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
4001c8fc: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
4001c900: 83 28 60 08 sll %g1, 8, %g1
4001c904: 82 10 40 02 or %g1, %g2, %g1
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
4001c908: 05 00 00 3f sethi %hi(0xfc00), %g2
4001c90c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
4001c910: 80 a0 40 02 cmp %g1, %g2
4001c914: 02 80 00 1e be 4001c98c <rtems_rfs_fs_open+0x6d0>
<== NEVER TAKEN
4001c918: 82 08 70 00 and %g1, -4096, %g1
4001c91c: 05 00 00 10 sethi %hi(0x4000), %g2
4001c920: 80 a0 40 02 cmp %g1, %g2
4001c924: 12 80 00 1a bne 4001c98c <rtems_rfs_fs_open+0x6d0>
<== NEVER TAKEN
4001c928: 01 00 00 00 nop
rc = rtems_rfs_inode_close (*fs, &inode);
4001c92c: 92 07 bf d8 add %fp, -40, %o1
4001c930: 7f ff d4 4a call 40011a58 <rtems_rfs_inode_close>
4001c934: b0 10 20 00 clr %i0
if (rc > 0)
4001c938: 80 a2 20 00 cmp %o0, 0
4001c93c: 14 80 00 3a bg 4001ca24 <rtems_rfs_fs_open+0x768>
<== NEVER TAKEN
4001c940: ba 10 00 08 mov %o0, %i5
}
return 0;
}
4001c944: 81 c7 e0 08 ret
4001c948: 81 e8 00 00 restore
free (*fs);
4001c94c: 7f ff a7 23 call 400065d8 <free>
<== NOT EXECUTED
4001c950: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c954: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c958: 7f ff d9 fe call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c95c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c960: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c964: 02 bf ff 45 be 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
4001c968: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
4001c96c: 40 00 0a cd call 4001f4a0 <strerror>
<== NOT EXECUTED
4001c970: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001c974: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001c978: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001c97c: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
4001c980: 7f ff da 82 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001c984: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 400241c0 <status_code_to_errno+0xca4>
<== NOT EXECUTED
4001c988: 30 bf ff 3c b,a 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
4001c98c: 7f ff d4 33 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001c990: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001c994: 7f ff cd 90 call 4000ffd4 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001c998: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001c99c: 7f ff a7 0f call 400065d8 <free>
<== NOT EXECUTED
4001c9a0: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c9a4: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c9a8: 7f ff d9 ea call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c9ac: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c9b0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c9b4: 02 80 00 04 be 4001c9c4 <rtems_rfs_fs_open+0x708>
<== NOT EXECUTED
4001c9b8: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
4001c9bc: 7f ff da 82 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001c9c0: 90 12 20 58 or %o0, 0x58, %o0 ! 40024458 <status_code_to_errno+0xf3c>
<== NOT EXECUTED
errno = EIO;
4001c9c4: 40 00 06 e2 call 4001e54c <__errno>
<== NOT EXECUTED
4001c9c8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001c9cc: 82 10 20 05 mov 5, %g1
<== NOT EXECUTED
4001c9d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
4001c9d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c9d8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001c9dc: 7f ff cd 7e call 4000ffd4 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001c9e0: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001c9e4: 7f ff a6 fd call 400065d8 <free>
<== NOT EXECUTED
4001c9e8: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001c9ec: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001c9f0: 7f ff d9 d8 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001c9f4: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001c9f8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001c9fc: 02 bf ff 1f be 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
4001ca00: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
4001ca04: 40 00 0a a7 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001ca08: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001ca0c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001ca10: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001ca14: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001ca18: 7f ff da 5c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001ca1c: 90 12 20 28 or %o0, 0x28, %o0 ! 40024428 <status_code_to_errno+0xf0c>
<== NOT EXECUTED
4001ca20: 30 bf ff 16 b,a 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001ca24: 7f ff cd 6c call 4000ffd4 <rtems_rfs_buffer_close>
<== NOT EXECUTED
4001ca28: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
free (*fs);
4001ca2c: 7f ff a6 eb call 400065d8 <free>
<== NOT EXECUTED
4001ca30: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ca34: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ca38: 7f ff d9 c6 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001ca3c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001ca40: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ca44: 02 bf ff 0d be 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
4001ca48: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
4001ca4c: 40 00 0a 95 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001ca50: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001ca54: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001ca58: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001ca5c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001ca60: 7f ff da 4a call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001ca64: 90 12 20 88 or %o0, 0x88, %o0 ! 40024488 <status_code_to_errno+0xf6c>
<== NOT EXECUTED
4001ca68: 30 bf ff 04 b,a 4001c678 <rtems_rfs_fs_open+0x3bc>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001ca6c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001ca70: 7f ff d9 b8 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001ca74: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
4001ca78: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001ca7c: 02 80 00 04 be 4001ca8c <rtems_rfs_fs_open+0x7d0>
<== NOT EXECUTED
4001ca80: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
4001ca84: 7f ff da 50 call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001ca88: 90 12 21 90 or %o0, 0x190, %o0 ! 40024190 <status_code_to_errno+0xc74>
<== NOT EXECUTED
errno = ENOMEM;
4001ca8c: 40 00 06 b0 call 4001e54c <__errno>
<== NOT EXECUTED
4001ca90: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001ca94: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
4001ca98: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return -1;
4001ca9c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001caa0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001caa4: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001caa8: 7f ff cc 4f call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001caac: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001cab0: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001cab4: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
handle->dirty = false;
4001cab8: c0 2f bf d8 clrb [ %fp + -40 ]
<== NOT EXECUTED
return ENOMEM;
4001cabc: ba 10 20 0c mov 0xc, %i5
<== NOT EXECUTED
handle->bnum = 0;
4001cac0: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001cac4: 7f ff d9 a3 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001cac8: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4001cacc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cad0: 02 bf fe e0 be 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001cad4: 11 10 00 90 sethi %hi(0x40024000), %o0
<== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
4001cad8: 7f ff da 3b call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001cadc: 90 12 23 80 or %o0, 0x380, %o0 ! 40024380 <status_code_to_errno+0xe64>
<== NOT EXECUTED
4001cae0: 30 bf fe dc b,a 4001c650 <rtems_rfs_fs_open+0x394>
<== NOT EXECUTED
4001c288 <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;
4001c288: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
4001c28c: d0 02 20 08 ld [ %o0 + 8 ], %o0
<== NOT EXECUTED
}
4001c290: 92 50 80 08 umul %g2, %o0, %o1
<== NOT EXECUTED
4001c294: 91 40 00 00 rd %y, %o0
<== NOT EXECUTED
4001c298: 81 c3 e0 08 retl
<== NOT EXECUTED
4001c29c: 01 00 00 00 nop
<== NOT EXECUTED
40011334 <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)
{
40011334: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40011338: 80 a6 a0 00 cmp %i2, 0
4001133c: 02 80 00 58 be 4001149c <rtems_rfs_group_bitmap_alloc+0x168>
40011340: 80 a6 60 00 cmp %i1, 0
{
size = fs->group_inodes;
40011344: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
40011348: b2 06 7f ff add %i1, -1, %i1
*/
if (goal >= RTEMS_RFS_ROOT_INO)
goal -= RTEMS_RFS_ROOT_INO;
}
group_start = goal / size;
4001134c: 81 80 20 00 wr %g0, %y
40011350: 01 00 00 00 nop
40011354: 01 00 00 00 nop
40011358: 01 00 00 00 nop
4001135c: a0 76 40 11 udiv %i1, %l1, %l0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40011360: c0 2f bf fb clrb [ %fp + -5 ]
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011364: 82 5c 00 11 smul %l0, %l1, %g1
40011368: b2 26 40 01 sub %i1, %g1, %i1
4001136c: 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);
40011370: ba 10 00 10 mov %l0, %i5
direction = 1;
40011374: a4 10 20 01 mov 1, %l2
updown = true;
40011378: a6 10 20 01 mov 1, %l3
bool allocated = false;
4001137c: 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))
40011380: 80 a7 60 00 cmp %i5, 0
40011384: 06 80 00 2e bl 4001143c <rtems_rfs_group_bitmap_alloc+0x108>
<== NEVER TAKEN
40011388: a2 04 7f ff add %l1, -1, %l1
group = group_start + (direction * offset);
4001138c: a8 04 00 19 add %l0, %i1, %l4
if ((group < 0) || (group >= fs->group_count))
40011390: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40011394: 80 a0 40 1d cmp %g1, %i5
40011398: 04 80 00 2a ble 40011440 <rtems_rfs_group_bitmap_alloc+0x10c>
4001139c: 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)
400113a0: aa 0c e0 ff and %l3, 0xff, %l5
400113a4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400113a8: b9 2f 60 02 sll %i5, 2, %i4
if (inode)
400113ac: 80 a6 a0 00 cmp %i2, 0
400113b0: b8 07 00 1d add %i4, %i5, %i4
400113b4: b9 2f 20 04 sll %i4, 4, %i4
400113b8: 82 00 40 1c add %g1, %i4, %g1
400113bc: 12 80 00 3c bne 400114ac <rtems_rfs_group_bitmap_alloc+0x178>
400113c0: ac 00 60 08 add %g1, 8, %l6
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
400113c4: d2 07 bf fc ld [ %fp + -4 ], %o1
400113c8: 96 07 bf fc add %fp, -4, %o3
400113cc: 94 07 bf fb add %fp, -5, %o2
400113d0: 7f ff f7 a8 call 4000f270 <rtems_rfs_bitmap_map_alloc>
400113d4: 90 10 00 16 mov %l6, %o0
if (rc > 0)
400113d8: 80 a2 20 00 cmp %o0, 0
400113dc: 14 80 00 21 bg 40011460 <rtems_rfs_group_bitmap_alloc+0x12c>
<== NEVER TAKEN
400113e0: 01 00 00 00 nop
if (rtems_rfs_fs_release_bitmaps (fs))
400113e4: c2 06 00 00 ld [ %i0 ], %g1
400113e8: 80 88 60 01 btst 1, %g1
400113ec: 22 80 00 46 be,a 40011504 <rtems_rfs_group_bitmap_alloc+0x1d0>
<== ALWAYS TAKEN
400113f0: d2 05 80 00 ld [ %l6 ], %o1
if (allocated)
400113f4: c2 0f bf fb ldub [ %fp + -5 ], %g1
<== NOT EXECUTED
400113f8: 80 88 60 ff btst 0xff, %g1
400113fc: 12 80 00 5b bne 40011568 <rtems_rfs_group_bitmap_alloc+0x234>
40011400: 80 a5 60 00 cmp %l5, 0
if (updown)
40011404: 22 80 00 2c be,a 400114b4 <rtems_rfs_group_bitmap_alloc+0x180>
<== NEVER TAKEN
40011408: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
{
direction = direction > 0 ? -1 : 1;
4001140c: 80 a4 a0 01 cmp %l2, 1
40011410: 12 80 00 41 bne 40011514 <rtems_rfs_group_bitmap_alloc+0x1e0>
<== NEVER TAKEN
40011414: a4 10 3f ff mov -1, %l2
bool allocated = false;
40011418: c0 2f bf fb clrb [ %fp + -5 ]
group = group_start + (direction * offset);
4001141c: ba 38 00 19 xnor %g0, %i1, %i5
40011420: ba 07 40 10 add %i5, %l0, %i5
if ( direction == -1 )
offset++;
40011424: b2 06 60 01 inc %i1
bit = direction > 0 ? 0 : size - 1;
40011428: 82 10 00 11 mov %l1, %g1
4001142c: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((group < 0) || (group >= fs->group_count))
40011430: 80 a7 60 00 cmp %i5, 0
40011434: 36 bf ff d7 bge,a 40011390 <rtems_rfs_group_bitmap_alloc+0x5c>
40011438: a8 04 00 19 add %l0, %i1, %l4
if (!updown)
4001143c: 80 8c e0 ff btst 0xff, %l3
40011440: 12 80 00 0a bne 40011468 <rtems_rfs_group_bitmap_alloc+0x134>
40011444: 90 10 20 00 clr %o0
offset++;
}
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011448: 40 00 07 42 call 40013150 <rtems_rfs_trace>
4001144c: 13 00 00 80 sethi %hi(0x20000), %o1
40011450: 80 a2 20 00 cmp %o0, 0
40011454: 12 80 00 20 bne 400114d4 <rtems_rfs_group_bitmap_alloc+0x1a0>
<== NEVER TAKEN
40011458: 11 10 00 8b sethi %hi(0x40022c00), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
4001145c: 90 10 20 1c mov 0x1c, %o0
}
40011460: 81 c7 e0 08 ret
40011464: 91 e8 00 08 restore %g0, %o0, %o0
direction = direction > 0 ? -1 : 1;
40011468: 80 a4 a0 01 cmp %l2, 1
4001146c: 12 80 00 1e bne 400114e4 <rtems_rfs_group_bitmap_alloc+0x1b0>
<== ALWAYS TAKEN
40011470: c0 2f bf fb clrb [ %fp + -5 ]
40011474: ba 24 00 19 sub %l0, %i1, %i5
<== NOT EXECUTED
40011478: a4 10 3f ff mov -1, %l2
<== NOT EXECUTED
if (offset)
4001147c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40011480: 12 bf ff ea bne 40011428 <rtems_rfs_group_bitmap_alloc+0xf4>
<== NOT EXECUTED
40011484: a6 10 20 00 clr %l3
<== NOT EXECUTED
if ((group < 0) || (group >= fs->group_count))
40011488: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4001148c: 36 bf ff c1 bge,a 40011390 <rtems_rfs_group_bitmap_alloc+0x5c>
<== NOT EXECUTED
40011490: a8 04 00 19 add %l0, %i1, %l4
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011494: 10 bf ff ed b 40011448 <rtems_rfs_group_bitmap_alloc+0x114>
<== NOT EXECUTED
40011498: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (goal >= RTEMS_RFS_ROOT_INO)
4001149c: 04 bf ff ac ble 4001134c <rtems_rfs_group_bitmap_alloc+0x18>
400114a0: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
goal -= RTEMS_RFS_ROOT_INO;
400114a4: 10 bf ff aa b 4001134c <rtems_rfs_group_bitmap_alloc+0x18>
400114a8: b2 06 7f ff add %i1, -1, %i1
400114ac: 10 bf ff c6 b 400113c4 <rtems_rfs_group_bitmap_alloc+0x90>
400114b0: ac 00 60 2c add %g1, 0x2c, %l6
offset++;
400114b4: b2 06 60 01 inc %i1
<== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
400114b8: 80 a4 a0 01 cmp %l2, 1
<== NOT EXECUTED
400114bc: ba 5c 80 19 smul %l2, %i1, %i5
<== NOT EXECUTED
400114c0: 12 bf ff da bne 40011428 <rtems_rfs_group_bitmap_alloc+0xf4>
<== NOT EXECUTED
400114c4: ba 07 40 10 add %i5, %l0, %i5
<== NOT EXECUTED
400114c8: 82 10 20 00 clr %g1
<== NOT EXECUTED
400114cc: 10 bf ff d9 b 40011430 <rtems_rfs_group_bitmap_alloc+0xfc>
<== NOT EXECUTED
400114d0: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
400114d4: 40 00 07 bc call 400133c4 <__wrap_puts>
<== NOT EXECUTED
400114d8: 90 12 20 30 or %o0, 0x30, %o0
<== NOT EXECUTED
return ENOSPC;
400114dc: 10 bf ff e1 b 40011460 <rtems_rfs_group_bitmap_alloc+0x12c>
<== NOT EXECUTED
400114e0: 90 10 20 1c mov 0x1c, %o0
<== NOT EXECUTED
400114e4: ba 06 40 10 add %i1, %l0, %i5
if (offset)
400114e8: a4 10 20 01 mov 1, %l2
400114ec: a6 10 20 00 clr %l3
400114f0: 80 a6 60 00 cmp %i1, 0
400114f4: 02 bf ff e5 be 40011488 <rtems_rfs_group_bitmap_alloc+0x154>
<== NEVER TAKEN
400114f8: 82 10 20 00 clr %g1
bit = direction > 0 ? 0 : size - 1;
400114fc: 10 bf ff cd b 40011430 <rtems_rfs_group_bitmap_alloc+0xfc>
40011500: c2 27 bf fc st %g1, [ %fp + -4 ]
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40011504: 7f ff f9 b8 call 4000fbe4 <rtems_rfs_buffer_handle_release>
40011508: 90 10 00 18 mov %i0, %o0
if (allocated)
4001150c: 10 bf ff bb b 400113f8 <rtems_rfs_group_bitmap_alloc+0xc4>
40011510: c2 0f bf fb ldub [ %fp + -5 ], %g1
bool allocated = false;
40011514: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
if (offset)
40011518: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001151c: 02 80 00 05 be 40011530 <rtems_rfs_group_bitmap_alloc+0x1fc>
<== NOT EXECUTED
40011520: ba 10 00 14 mov %l4, %i5
<== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40011524: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40011528: 10 bf ff e9 b 400114cc <rtems_rfs_group_bitmap_alloc+0x198>
<== NOT EXECUTED
4001152c: 82 10 20 00 clr %g1
<== NOT EXECUTED
if ((group < 0) || (group >= fs->group_count))
40011530: 80 a5 20 00 cmp %l4, 0
<== NOT EXECUTED
40011534: 26 80 00 07 bl,a 40011550 <rtems_rfs_group_bitmap_alloc+0x21c>
<== NOT EXECUTED
40011538: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
4001153c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
<== NOT EXECUTED
40011540: 80 a0 80 14 cmp %g2, %l4
<== NOT EXECUTED
40011544: 14 bf ff 98 bg 400113a4 <rtems_rfs_group_bitmap_alloc+0x70>
<== NOT EXECUTED
40011548: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
bool allocated = false;
4001154c: c0 2f bf fb clrb [ %fp + -5 ]
<== NOT EXECUTED
40011550: a4 10 3f ff mov -1, %l2
<== NOT EXECUTED
if ((group < 0) || (group >= fs->group_count))
40011554: 80 a5 20 00 cmp %l4, 0
<== NOT EXECUTED
40011558: 16 bf ff 8e bge 40011390 <rtems_rfs_group_bitmap_alloc+0x5c>
<== NOT EXECUTED
4001155c: a6 10 00 01 mov %g1, %l3
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011560: 10 bf ff ba b 40011448 <rtems_rfs_group_bitmap_alloc+0x114>
<== NOT EXECUTED
40011564: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (inode)
40011568: 80 a6 a0 00 cmp %i2, 0
4001156c: 02 80 00 14 be 400115bc <rtems_rfs_group_bitmap_alloc+0x288>
40011570: c4 07 bf fc ld [ %fp + -4 ], %g2
*result = rtems_rfs_group_inode (fs, group, bit);
40011574: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
40011578: 84 00 a0 01 inc %g2
4001157c: 82 5f 40 01 smul %i5, %g1, %g1
40011580: 82 00 40 02 add %g1, %g2, %g1
40011584: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011588: 90 10 20 00 clr %o0
4001158c: 40 00 06 f1 call 40013150 <rtems_rfs_trace>
40011590: 13 00 00 80 sethi %hi(0x20000), %o1
40011594: 80 a2 20 00 cmp %o0, 0
40011598: 02 80 00 07 be 400115b4 <rtems_rfs_group_bitmap_alloc+0x280>
<== ALWAYS TAKEN
4001159c: 13 10 00 8a sethi %hi(0x40022800), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
400115a0: 92 12 63 f0 or %o1, 0x3f0, %o1 ! 40022bf0 <ramdisk_ops+0xed8>
<== NOT EXECUTED
400115a4: d4 06 c0 00 ld [ %i3 ], %o2
<== NOT EXECUTED
400115a8: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
400115ac: 40 00 07 77 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400115b0: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 40022bf8 <ramdisk_ops+0xee0>
<== NOT EXECUTED
return 0;
400115b4: 10 bf ff ab b 40011460 <rtems_rfs_group_bitmap_alloc+0x12c>
400115b8: 90 10 20 00 clr %o0
*result = rtems_rfs_group_block (&fs->groups[group], bit);
400115bc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400115c0: c2 00 40 1c ld [ %g1 + %i4 ], %g1
400115c4: 84 00 40 02 add %g1, %g2, %g2
400115c8: c4 26 c0 00 st %g2, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
400115cc: 90 10 20 00 clr %o0
400115d0: 40 00 06 e0 call 40013150 <rtems_rfs_trace>
400115d4: 13 00 00 80 sethi %hi(0x20000), %o1
400115d8: 80 a2 20 00 cmp %o0, 0
400115dc: 02 bf ff f6 be 400115b4 <rtems_rfs_group_bitmap_alloc+0x280>
<== ALWAYS TAKEN
400115e0: 13 10 00 8a sethi %hi(0x40022800), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
400115e4: 10 bf ff f0 b 400115a4 <rtems_rfs_group_bitmap_alloc+0x270>
<== NOT EXECUTED
400115e8: 92 12 63 e8 or %o1, 0x3e8, %o1 ! 40022be8 <ramdisk_ops+0xed0>
<== NOT EXECUTED
400115ec <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
400115ec: 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))
400115f0: 90 10 20 00 clr %o0
400115f4: 13 00 00 80 sethi %hi(0x20000), %o1
400115f8: 40 00 06 d6 call 40013150 <rtems_rfs_trace>
400115fc: b8 10 00 18 mov %i0, %i4
40011600: 80 a2 20 00 cmp %o0, 0
40011604: 22 80 00 0c be,a 40011634 <rtems_rfs_group_bitmap_free+0x48>
<== ALWAYS TAKEN
40011608: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
4001160c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40011610: 12 80 00 36 bne 400116e8 <rtems_rfs_group_bitmap_free+0xfc>
<== NOT EXECUTED
40011614: 13 10 00 8a sethi %hi(0x40022800), %o1
<== NOT EXECUTED
40011618: 13 10 00 8a sethi %hi(0x40022800), %o1
<== NOT EXECUTED
4001161c: 92 12 63 e8 or %o1, 0x3e8, %o1 ! 40022be8 <ramdisk_ops+0xed0>
<== NOT EXECUTED
40011620: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011624: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40011628: 40 00 07 58 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001162c: 90 12 20 68 or %o0, 0x68, %o0
<== NOT EXECUTED
40011630: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
<== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40011634: 80 a6 60 00 cmp %i1, 0
40011638: 02 80 00 17 be 40011694 <rtems_rfs_group_bitmap_free+0xa8>
4001163c: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
40011640: 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);
40011644: 81 80 20 00 wr %g0, %y
40011648: 01 00 00 00 nop
4001164c: 01 00 00 00 nop
40011650: 01 00 00 00 nop
40011654: 84 76 80 09 udiv %i2, %o1, %g2
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
40011658: 83 28 a0 02 sll %g2, 2, %g1
4001165c: 82 00 40 02 add %g1, %g2, %g1
40011660: 83 28 60 04 sll %g1, 4, %g1
bit = (rtems_rfs_bitmap_bit) (no % size);
40011664: 92 58 80 09 smul %g2, %o1, %o1
bitmap = &fs->groups[group].inode_bitmap;
40011668: ba 07 40 01 add %i5, %g1, %i5
bit = (rtems_rfs_bitmap_bit) (no % size);
4001166c: 92 26 80 09 sub %i2, %o1, %o1
bitmap = &fs->groups[group].inode_bitmap;
40011670: ba 07 60 2c add %i5, 0x2c, %i5
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40011674: 7f ff f6 68 call 4000f014 <rtems_rfs_bitmap_map_clear>
40011678: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4001167c: d2 07 40 00 ld [ %i5 ], %o1
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40011680: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40011684: 7f ff f9 58 call 4000fbe4 <rtems_rfs_buffer_handle_release>
40011688: 90 10 00 1c mov %i4, %o0
return rc;
}
4001168c: 81 c7 e0 08 ret
40011690: 81 e8 00 00 restore
size = fs->group_blocks;
40011694: d2 07 20 28 ld [ %i4 + 0x28 ], %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
40011698: 81 80 20 00 wr %g0, %y
4001169c: 01 00 00 00 nop
400116a0: 01 00 00 00 nop
400116a4: 01 00 00 00 nop
400116a8: 84 76 80 09 udiv %i2, %o1, %g2
bitmap = &fs->groups[group].block_bitmap;
400116ac: 83 28 a0 02 sll %g2, 2, %g1
400116b0: 82 00 40 02 add %g1, %g2, %g1
400116b4: 83 28 60 04 sll %g1, 4, %g1
bit = (rtems_rfs_bitmap_bit) (no % size);
400116b8: 92 58 80 09 smul %g2, %o1, %o1
bitmap = &fs->groups[group].block_bitmap;
400116bc: ba 07 40 01 add %i5, %g1, %i5
bit = (rtems_rfs_bitmap_bit) (no % size);
400116c0: 92 26 80 09 sub %i2, %o1, %o1
bitmap = &fs->groups[group].block_bitmap;
400116c4: ba 07 60 08 add %i5, 8, %i5
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400116c8: 7f ff f6 53 call 4000f014 <rtems_rfs_bitmap_map_clear>
400116cc: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400116d0: d2 07 40 00 ld [ %i5 ], %o1
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400116d4: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400116d8: 7f ff f9 43 call 4000fbe4 <rtems_rfs_buffer_handle_release>
400116dc: 90 10 00 1c mov %i4, %o0
}
400116e0: 81 c7 e0 08 ret
400116e4: 81 e8 00 00 restore
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
400116e8: 10 bf ff ce b 40011620 <rtems_rfs_group_bitmap_free+0x34>
<== NOT EXECUTED
400116ec: 92 12 63 f0 or %o1, 0x3f0, %o1
<== NOT EXECUTED
40011284 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40011284: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
40011288: 90 10 20 00 clr %o0
4001128c: 40 00 07 b1 call 40013150 <rtems_rfs_trace>
40011290: 13 00 00 40 sethi %hi(0x10000), %o1
40011294: 80 a2 20 00 cmp %o0, 0
40011298: 32 80 00 18 bne,a 400112f8 <rtems_rfs_group_close+0x74>
<== NEVER TAKEN
4001129c: 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);
400112a0: 7f ff f8 87 call 4000f4bc <rtems_rfs_bitmap_close>
400112a4: 90 06 60 2c add %i1, 0x2c, %o0
rtems_rfs_buffer_handle_release (fs, handle);
400112a8: 92 06 60 44 add %i1, 0x44, %o1
400112ac: ba 10 00 08 mov %o0, %i5
400112b0: 7f ff fa 4d call 4000fbe4 <rtems_rfs_buffer_handle_release>
400112b4: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
400112b8: 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);
400112bc: 90 06 60 08 add %i1, 8, %o0
handle->bnum = 0;
400112c0: c0 26 60 48 clr [ %i1 + 0x48 ]
400112c4: 7f ff f8 7e call 4000f4bc <rtems_rfs_bitmap_close>
400112c8: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
400112cc: 82 92 20 00 orcc %o0, 0, %g1
400112d0: 04 80 00 0e ble 40011308 <rtems_rfs_group_close+0x84>
<== ALWAYS TAKEN
400112d4: 92 06 60 20 add %i1, 0x20, %o1
rtems_rfs_buffer_handle_release (fs, handle);
400112d8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400112dc: 7f ff fa 42 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400112e0: b0 10 00 01 mov %g1, %i0
<== NOT EXECUTED
handle->dirty = false;
400112e4: c0 2e 60 20 clrb [ %i1 + 0x20 ]
<== NOT EXECUTED
handle->bnum = 0;
400112e8: c0 26 60 24 clr [ %i1 + 0x24 ]
<== NOT EXECUTED
handle->buffer = NULL;
400112ec: 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;
}
400112f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400112f4: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
400112f8: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
400112fc: 40 00 08 23 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011300: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 40022bc0 <ramdisk_ops+0xea8>
<== NOT EXECUTED
40011304: 30 bf ff e7 b,a 400112a0 <rtems_rfs_group_close+0x1c>
<== NOT EXECUTED
40011308: 82 38 00 1d xnor %g0, %i5, %g1
4001130c: 83 38 60 1f sra %g1, 0x1f, %g1
40011310: 82 0f 40 01 and %i5, %g1, %g1
rtems_rfs_buffer_handle_release (fs, handle);
40011314: 90 10 00 18 mov %i0, %o0
40011318: 7f ff fa 33 call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001131c: b0 10 00 01 mov %g1, %i0
handle->dirty = false;
40011320: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40011324: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
40011328: c0 26 60 28 clr [ %i1 + 0x28 ]
}
4001132c: 81 c7 e0 08 ret
40011330: 81 e8 00 00 restore
4001104c <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)
{
4001104c: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40011050: c2 06 20 04 ld [ %i0 + 4 ], %g1
40011054: 80 a0 40 19 cmp %g1, %i1
40011058: 08 80 00 56 bleu 400111b0 <rtems_rfs_group_open+0x164>
<== NEVER TAKEN
4001105c: 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))
40011060: 84 06 40 1a add %i1, %i2, %g2
40011064: 80 a0 40 02 cmp %g1, %g2
40011068: 28 80 00 02 bleu,a 40011070 <rtems_rfs_group_open+0x24>
<== ALWAYS TAKEN
4001106c: b4 20 40 19 sub %g1, %i1, %i2
40011070: 80 a6 80 1b cmp %i2, %i3
40011074: 18 80 00 25 bgu 40011108 <rtems_rfs_group_open+0xbc>
<== ALWAYS TAKEN
40011078: 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))
4001107c: 90 10 20 00 clr %o0
<== NOT EXECUTED
40011080: 40 00 08 34 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
40011084: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
40011088: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001108c: 12 80 00 42 bne 40011194 <rtems_rfs_group_open+0x148>
<== NOT EXECUTED
40011090: 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;
40011094: f2 27 00 00 st %i1, [ %i4 ]
<== NOT EXECUTED
group->size = size;
rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
40011098: b6 07 20 20 add %i4, 0x20, %i3
group->size = size;
4001109c: 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,
400110a0: a2 07 20 08 add %i4, 8, %l1
handle->dirty = false;
400110a4: c0 2f 20 20 clrb [ %i4 + 0x20 ]
400110a8: 98 10 00 19 mov %i1, %o4
handle->bnum = 0;
400110ac: c0 27 20 24 clr [ %i4 + 0x24 ]
400110b0: 96 10 00 1a mov %i2, %o3
handle->buffer = NULL;
400110b4: c0 27 20 28 clr [ %i4 + 0x28 ]
400110b8: 94 10 00 1b mov %i3, %o2
400110bc: 92 10 00 1d mov %i5, %o1
400110c0: 7f ff f8 ee call 4000f478 <rtems_rfs_bitmap_open>
400110c4: 90 10 00 11 mov %l1, %o0
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
400110c8: b0 92 20 00 orcc %o0, 0, %i0
400110cc: 04 80 00 18 ble 4001112c <rtems_rfs_group_open+0xe0>
<== ALWAYS TAKEN
400110d0: 92 10 00 1b mov %i3, %o1
rtems_rfs_buffer_handle_release (fs, handle);
400110d4: 7f ff fa c4 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
400110d8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
handle->dirty = false;
400110dc: 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))
400110e0: 90 10 20 00 clr %o0
<== NOT EXECUTED
handle->bnum = 0;
400110e4: c0 27 20 24 clr [ %i4 + 0x24 ]
<== NOT EXECUTED
400110e8: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
400110ec: 40 00 08 19 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
400110f0: c0 27 20 28 clr [ %i4 + 0x28 ]
<== NOT EXECUTED
400110f4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400110f8: 12 80 00 3e bne 400111f0 <rtems_rfs_group_open+0x1a4>
<== NOT EXECUTED
400110fc: 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;
}
40011100: 81 c7 e0 08 ret
<== NOT EXECUTED
40011104: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40011108: 90 10 20 00 clr %o0
4001110c: 13 00 00 20 sethi %hi(0x8000), %o1
40011110: 40 00 08 10 call 40013150 <rtems_rfs_trace>
40011114: a0 10 00 1b mov %i3, %l0
40011118: 80 a2 20 00 cmp %o0, 0
4001111c: 22 bf ff df be,a 40011098 <rtems_rfs_group_open+0x4c>
<== ALWAYS TAKEN
40011120: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40011124: 10 80 00 1c b 40011194 <rtems_rfs_group_open+0x148>
<== NOT EXECUTED
40011128: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
handle->dirty = false;
4001112c: c0 2f 20 44 clrb [ %i4 + 0x44 ]
rc = rtems_rfs_buffer_handle_open (fs, &group->inode_bitmap_buffer);
40011130: b4 07 20 44 add %i4, 0x44, %i2
handle->bnum = 0;
40011134: c0 27 20 48 clr [ %i4 + 0x48 ]
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
40011138: 96 10 00 10 mov %l0, %o3
handle->buffer = NULL;
4001113c: c0 27 20 4c clr [ %i4 + 0x4c ]
40011140: 94 10 00 1a mov %i2, %o2
40011144: d8 07 00 00 ld [ %i4 ], %o4
40011148: 98 03 20 01 inc %o4
4001114c: 92 10 00 1d mov %i5, %o1
40011150: 7f ff f8 ca call 4000f478 <rtems_rfs_bitmap_open>
40011154: 90 07 20 2c add %i4, 0x2c, %o0
if (rc > 0)
40011158: b0 92 20 00 orcc %o0, 0, %i0
4001115c: 14 80 00 2e bg 40011214 <rtems_rfs_group_open+0x1c8>
<== NEVER TAKEN
40011160: 92 10 00 1a mov %i2, %o1
if (rtems_rfs_fs_release_bitmaps (fs))
40011164: c2 07 40 00 ld [ %i5 ], %g1
40011168: 80 88 60 01 btst 1, %g1
4001116c: 12 bf ff e5 bne 40011100 <rtems_rfs_group_open+0xb4>
<== NEVER TAKEN
40011170: b0 10 20 00 clr %i0
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40011174: d2 07 20 08 ld [ %i4 + 8 ], %o1
40011178: 7f ff fa 9b call 4000fbe4 <rtems_rfs_buffer_handle_release>
4001117c: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40011180: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40011184: 7f ff fa 98 call 4000fbe4 <rtems_rfs_buffer_handle_release>
40011188: 90 10 00 1d mov %i5, %o0
}
4001118c: 81 c7 e0 08 ret
40011190: 81 e8 00 00 restore
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40011194: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40011198: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001119c: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
400111a0: 40 00 08 7a call 40013388 <__wrap_printf>
<== NOT EXECUTED
400111a4: 90 12 23 08 or %o0, 0x308, %o0 ! 40022b08 <ramdisk_ops+0xdf0>
<== NOT EXECUTED
group->base = base;
400111a8: 10 bf ff bc b 40011098 <rtems_rfs_group_open+0x4c>
<== NOT EXECUTED
400111ac: f2 27 00 00 st %i1, [ %i4 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
400111b0: 90 10 20 00 clr %o0
<== NOT EXECUTED
400111b4: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
400111b8: 40 00 07 e6 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
400111bc: b0 10 20 05 mov 5, %i0
<== NOT EXECUTED
400111c0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400111c4: 02 80 00 2e be 4001127c <rtems_rfs_group_open+0x230>
<== NOT EXECUTED
400111c8: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
400111cc: 40 00 38 b5 call 4001f4a0 <strerror>
<== NOT EXECUTED
400111d0: 90 10 20 05 mov 5, %o0 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
400111d4: 92 10 20 05 mov 5, %o1
<== NOT EXECUTED
400111d8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
400111dc: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
400111e0: 40 00 08 6a call 40013388 <__wrap_printf>
<== NOT EXECUTED
400111e4: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 40022ac8 <ramdisk_ops+0xdb0>
<== NOT EXECUTED
400111e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400111ec: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
400111f0: 40 00 38 ac call 4001f4a0 <strerror>
<== NOT EXECUTED
400111f4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400111f8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400111fc: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40011200: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40011204: 40 00 08 61 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011208: 90 12 23 40 or %o0, 0x340, %o0 ! 40022b40 <ramdisk_ops+0xe28>
<== NOT EXECUTED
4001120c: 81 c7 e0 08 ret
<== NOT EXECUTED
40011210: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40011214: 7f ff fa 74 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40011218: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
handle->dirty = false;
4001121c: c0 2f 20 44 clrb [ %i4 + 0x44 ]
<== NOT EXECUTED
rtems_rfs_bitmap_close (&group->block_bitmap);
40011220: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
handle->bnum = 0;
40011224: c0 27 20 48 clr [ %i4 + 0x48 ]
<== NOT EXECUTED
40011228: 7f ff f8 a5 call 4000f4bc <rtems_rfs_bitmap_close>
<== NOT EXECUTED
4001122c: c0 27 20 4c clr [ %i4 + 0x4c ]
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40011230: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40011234: 7f ff fa 6c call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40011238: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
handle->dirty = false;
4001123c: c0 2f 20 20 clrb [ %i4 + 0x20 ]
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40011240: 90 10 20 00 clr %o0
<== NOT EXECUTED
handle->bnum = 0;
40011244: c0 27 20 24 clr [ %i4 + 0x24 ]
<== NOT EXECUTED
40011248: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
4001124c: 40 00 07 c1 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
40011250: c0 27 20 28 clr [ %i4 + 0x28 ]
<== NOT EXECUTED
40011254: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011258: 02 80 00 09 be 4001127c <rtems_rfs_group_open+0x230>
<== NOT EXECUTED
4001125c: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40011260: 40 00 38 90 call 4001f4a0 <strerror>
<== NOT EXECUTED
40011264: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40011268: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001126c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40011270: 11 10 00 8a sethi %hi(0x40022800), %o0
<== NOT EXECUTED
40011274: 40 00 08 45 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011278: 90 12 23 80 or %o0, 0x380, %o0 ! 40022b80 <ramdisk_ops+0xe68>
<== NOT EXECUTED
4001127c: 81 c7 e0 08 ret
<== NOT EXECUTED
40011280: 81 e8 00 00 restore
<== NOT EXECUTED
400116f0 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
400116f0: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
*inodes = 0;
400116f4: c0 22 80 00 clr [ %o2 ]
<== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
400116f8: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
<== NOT EXECUTED
400116fc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011700: 04 80 00 20 ble 40011780 <rtems_rfs_group_usage+0x90>
<== NOT EXECUTED
40011704: 86 10 20 00 clr %g3
<== NOT EXECUTED
40011708: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
<== NOT EXECUTED
4001170c: 82 00 60 14 add %g1, 0x14, %g1
<== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
40011710: da 00 40 00 ld [ %g1 ], %o5
<== NOT EXECUTED
40011714: c8 00 60 04 ld [ %g1 + 4 ], %g4
<== NOT EXECUTED
40011718: c4 02 40 00 ld [ %o1 ], %g2
<== NOT EXECUTED
4001171c: 84 00 80 0d add %g2, %o5, %g2
<== NOT EXECUTED
40011720: 84 20 80 04 sub %g2, %g4, %g2
<== NOT EXECUTED
40011724: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40011728: 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 +=
4001172c: c8 00 60 28 ld [ %g1 + 0x28 ], %g4
<== NOT EXECUTED
40011730: da 00 60 24 ld [ %g1 + 0x24 ], %o5
<== NOT EXECUTED
40011734: c4 02 80 00 ld [ %o2 ], %g2
<== NOT EXECUTED
40011738: 84 00 80 0d add %g2, %o5, %g2
<== NOT EXECUTED
4001173c: 84 20 80 04 sub %g2, %g4, %g2
<== NOT EXECUTED
40011740: c4 22 80 00 st %g2, [ %o2 ]
<== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40011744: c8 02 20 24 ld [ %o0 + 0x24 ], %g4
<== NOT EXECUTED
40011748: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4001174c: 14 bf ff f1 bg 40011710 <rtems_rfs_group_usage+0x20>
<== NOT EXECUTED
40011750: 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))
40011754: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
40011758: c6 02 40 00 ld [ %o1 ], %g3
<== NOT EXECUTED
4001175c: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40011760: 38 80 00 0e bgu,a 40011798 <rtems_rfs_group_usage+0xa8>
<== NOT EXECUTED
40011764: c2 22 40 00 st %g1, [ %o1 ]
<== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
40011768: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
4001176c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011770: 2a 80 00 02 bcs,a 40011778 <rtems_rfs_group_usage+0x88>
<== NOT EXECUTED
40011774: c2 22 80 00 st %g1, [ %o2 ]
<== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
40011778: 81 c3 e0 08 retl
<== NOT EXECUTED
4001177c: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (*blocks > rtems_rfs_fs_blocks (fs))
40011780: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
40011784: c4 02 40 00 ld [ %o1 ], %g2
<== NOT EXECUTED
40011788: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001178c: 08 bf ff fb bleu 40011778 <rtems_rfs_group_usage+0x88>
<== NOT EXECUTED
40011790: 01 00 00 00 nop
<== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
40011794: c2 22 40 00 st %g1, [ %o1 ]
<== NOT EXECUTED
40011798: 10 bf ff f4 b 40011768 <rtems_rfs_group_usage+0x78>
<== NOT EXECUTED
4001179c: c4 02 80 00 ld [ %o2 ], %g2
<== NOT EXECUTED
40011a58 <rtems_rfs_inode_close>:
{
40011a58: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40011a5c: 90 10 20 00 clr %o0
40011a60: 40 00 05 bc call 40013150 <rtems_rfs_trace>
40011a64: 13 00 02 00 sethi %hi(0x80000), %o1
40011a68: 80 a2 20 00 cmp %o0, 0
40011a6c: 32 80 00 16 bne,a 40011ac4 <rtems_rfs_inode_close+0x6c>
<== NEVER TAKEN
40011a70: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40011a74: 90 10 00 18 mov %i0, %o0
40011a78: 94 10 20 01 mov 1, %o2
40011a7c: 7f ff ff b9 call 40011960 <rtems_rfs_inode_unload>
40011a80: 92 10 00 19 mov %i1, %o1
if ((rc == 0) && (handle->loads > 0))
40011a84: b0 92 20 00 orcc %o0, 0, %i0
40011a88: 32 80 00 0d bne,a 40011abc <rtems_rfs_inode_close+0x64>
<== NEVER TAKEN
40011a8c: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
40011a90: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40011a94: 80 a0 60 00 cmp %g1, 0
40011a98: 04 80 00 08 ble 40011ab8 <rtems_rfs_inode_close+0x60>
<== ALWAYS TAKEN
40011a9c: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40011aa0: 13 00 02 00 sethi %hi(0x80000), %o1
<== NOT EXECUTED
40011aa4: 40 00 05 ab call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
40011aa8: b0 10 20 05 mov 5, %i0
<== NOT EXECUTED
40011aac: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011ab0: 32 80 00 0a bne,a 40011ad8 <rtems_rfs_inode_close+0x80>
<== NOT EXECUTED
40011ab4: d2 06 60 24 ld [ %i1 + 0x24 ], %o1
<== NOT EXECUTED
handle->ino = 0;
40011ab8: c0 26 60 08 clr [ %i1 + 8 ]
}
40011abc: 81 c7 e0 08 ret
40011ac0: 81 e8 00 00 restore
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
40011ac4: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011ac8: 40 00 06 30 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011acc: 90 12 21 40 or %o0, 0x140, %o0 ! 40022d40 <ramdisk_ops+0x1028>
<== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40011ad0: 10 bf ff ea b 40011a78 <rtems_rfs_inode_close+0x20>
<== NOT EXECUTED
40011ad4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
40011ad8: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011adc: 40 00 06 2b call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011ae0: 90 12 21 68 or %o0, 0x168, %o0 ! 40022d68 <ramdisk_ops+0x1050>
<== NOT EXECUTED
40011ae4: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
40011ae8: 81 c7 e0 08 ret
<== NOT EXECUTED
40011aec: 81 e8 00 00 restore
<== NOT EXECUTED
40011dfc <rtems_rfs_inode_create>:
{
40011dfc: 9d e3 bf 50 save %sp, -176, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40011e00: 90 10 20 00 clr %o0
{
40011e04: e6 17 a0 5e lduh [ %fp + 0x5e ], %l3
40011e08: e8 17 a0 62 lduh [ %fp + 0x62 ], %l4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40011e0c: 13 00 10 00 sethi %hi(0x400000), %o1
40011e10: 40 00 04 d0 call 40013150 <rtems_rfs_trace>
40011e14: a2 0f 30 00 and %i4, -4096, %l1
{
40011e18: aa 10 00 18 mov %i0, %l5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40011e1c: 80 a2 20 00 cmp %o0, 0
40011e20: 02 80 00 2c be 40011ed0 <rtems_rfs_inode_create+0xd4>
<== ALWAYS TAKEN
40011e24: a3 2c 60 10 sll %l1, 0x10, %l1
if (RTEMS_RFS_S_ISDIR (mode))
40011e28: 83 34 60 10 srl %l1, 0x10, %g1
<== NOT EXECUTED
40011e2c: 05 00 00 10 sethi %hi(0x4000), %g2
<== NOT EXECUTED
40011e30: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011e34: 02 80 00 11 be 40011e78 <rtems_rfs_inode_create+0x7c>
<== NOT EXECUTED
40011e38: 05 00 00 08 sethi %hi(0x2000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
40011e3c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011e40: 02 80 00 56 be 40011f98 <rtems_rfs_inode_create+0x19c>
<== NOT EXECUTED
40011e44: 05 00 00 18 sethi %hi(0x6000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
40011e48: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011e4c: 02 80 00 50 be 40011f8c <rtems_rfs_inode_create+0x190>
<== NOT EXECUTED
40011e50: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
40011e54: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011e58: 02 80 00 73 be 40012024 <rtems_rfs_inode_create+0x228>
<== NOT EXECUTED
40011e5c: 05 00 00 28 sethi %hi(0xa000), %g2
<== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
40011e60: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011e64: 22 80 00 73 be,a 40012030 <rtems_rfs_inode_create+0x234>
<== NOT EXECUTED
40011e68: 31 10 00 8b sethi %hi(0x40022c00), %i0
<== NOT EXECUTED
const char* type = "unknown";
40011e6c: 31 10 00 8b sethi %hi(0x40022c00), %i0
<== NOT EXECUTED
40011e70: 10 80 00 04 b 40011e80 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40011e74: b0 16 21 e0 or %i0, 0x1e0, %i0 ! 40022de0 <ramdisk_ops+0x10c8>
<== NOT EXECUTED
type = "dir";
40011e78: 31 10 00 8b sethi %hi(0x40022c00), %i0
<== NOT EXECUTED
40011e7c: b0 16 21 c8 or %i0, 0x1c8, %i0 ! 40022dc8 <ramdisk_ops+0x10b0>
<== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
40011e80: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40011e84: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011e88: 40 00 05 40 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011e8c: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 40022df0 <ramdisk_ops+0x10d8>
<== NOT EXECUTED
for (c = 0; c < length; c++)
40011e90: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
40011e94: 02 80 00 0a be 40011ebc <rtems_rfs_inode_create+0xc0>
<== NOT EXECUTED
40011e98: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011e9c: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
40011ea0: a4 06 c0 1a add %i3, %i2, %l2
<== NOT EXECUTED
printf ("%c", name[c]);
40011ea4: 40 00 05 4e call 400133dc <__wrap_putchar>
<== NOT EXECUTED
40011ea8: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
40011eac: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
40011eb0: 80 a4 80 10 cmp %l2, %l0
<== NOT EXECUTED
40011eb4: 12 bf ff fc bne 40011ea4 <rtems_rfs_inode_create+0xa8>
<== NOT EXECUTED
40011eb8: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
40011ebc: 96 0f 23 ff and %i4, 0x3ff, %o3
<== NOT EXECUTED
40011ec0: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40011ec4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40011ec8: 40 00 05 30 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011ecc: 90 12 22 20 or %o0, 0x220, %o0
<== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
40011ed0: 83 34 60 10 srl %l1, 0x10, %g1
40011ed4: 05 00 00 18 sethi %hi(0x6000), %g2
40011ed8: 80 a0 40 02 cmp %g1, %g2
40011edc: 02 80 00 14 be 40011f2c <rtems_rfs_inode_create+0x130>
<== NEVER TAKEN
40011ee0: 92 10 00 19 mov %i1, %o1
40011ee4: 18 80 00 0b bgu 40011f10 <rtems_rfs_inode_create+0x114>
40011ee8: 05 00 00 20 sethi %hi(0x8000), %g2
40011eec: 05 00 00 08 sethi %hi(0x2000), %g2
40011ef0: 80 a0 40 02 cmp %g1, %g2
40011ef4: 02 80 00 0e be 40011f2c <rtems_rfs_inode_create+0x130>
<== NEVER TAKEN
40011ef8: 05 00 00 10 sethi %hi(0x4000), %g2
40011efc: 80 a0 40 02 cmp %g1, %g2
40011f00: 02 80 00 0c be 40011f30 <rtems_rfs_inode_create+0x134>
<== ALWAYS TAKEN
40011f04: 94 10 20 01 mov 1, %o2
return EINVAL;
40011f08: 81 c7 e0 08 ret
<== NOT EXECUTED
40011f0c: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
40011f10: 80 a0 40 02 cmp %g1, %g2
40011f14: 02 80 00 05 be 40011f28 <rtems_rfs_inode_create+0x12c>
40011f18: 05 00 00 28 sethi %hi(0xa000), %g2
40011f1c: 80 a0 40 02 cmp %g1, %g2
40011f20: 12 bf ff fa bne 40011f08 <rtems_rfs_inode_create+0x10c>
<== NEVER TAKEN
40011f24: 01 00 00 00 nop
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
40011f28: 92 10 00 19 mov %i1, %o1
40011f2c: 94 10 20 01 mov 1, %o2
40011f30: 96 07 bf d8 add %fp, -40, %o3
40011f34: 7f ff fd 00 call 40011334 <rtems_rfs_group_bitmap_alloc>
40011f38: 90 10 00 15 mov %l5, %o0
*ino = bit;
40011f3c: d2 07 bf d8 ld [ %fp + -40 ], %o1
40011f40: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
40011f44: d2 20 40 00 st %o1, [ %g1 ]
if (rc > 0)
40011f48: 80 a2 20 00 cmp %o0, 0
40011f4c: 14 80 00 0e bg 40011f84 <rtems_rfs_inode_create+0x188>
<== NEVER TAKEN
40011f50: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
40011f54: 96 10 20 01 mov 1, %o3
40011f58: 94 07 bf d8 add %fp, -40, %o2
40011f5c: 7f ff fe 48 call 4001187c <rtems_rfs_inode_open>
40011f60: 90 10 00 15 mov %l5, %o0
if (rc > 0)
40011f64: b0 92 20 00 orcc %o0, 0, %i0
40011f68: 04 80 00 0f ble 40011fa4 <rtems_rfs_inode_create+0x1a8>
<== ALWAYS TAKEN
40011f6c: 98 10 00 14 mov %l4, %o4
return rtems_rfs_group_bitmap_free (fs, true, bit);
40011f70: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
40011f74: d4 00 40 00 ld [ %g1 ], %o2
<== NOT EXECUTED
40011f78: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40011f7c: 7f ff fd 9c call 400115ec <rtems_rfs_group_bitmap_free>
<== NOT EXECUTED
40011f80: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
40011f84: 81 c7 e0 08 ret
<== NOT EXECUTED
40011f88: 81 e8 00 00 restore
<== NOT EXECUTED
type = "block";
40011f8c: 31 10 00 8a sethi %hi(0x40022800), %i0
<== NOT EXECUTED
40011f90: 10 bf ff bc b 40011e80 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40011f94: b0 16 23 e8 or %i0, 0x3e8, %i0 ! 40022be8 <ramdisk_ops+0xed0>
<== NOT EXECUTED
type = "char";
40011f98: 31 10 00 8b sethi %hi(0x40022c00), %i0
<== NOT EXECUTED
40011f9c: 10 bf ff b9 b 40011e80 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40011fa0: b0 16 21 d0 or %i0, 0x1d0, %i0 ! 40022dd0 <ramdisk_ops+0x10b8>
<== NOT EXECUTED
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
40011fa4: 96 10 00 13 mov %l3, %o3
40011fa8: 94 10 00 1c mov %i4, %o2
40011fac: 92 10 00 1d mov %i5, %o1
40011fb0: 7f ff ff 43 call 40011cbc <rtems_rfs_inode_initialise>
40011fb4: 90 07 bf d8 add %fp, -40, %o0
if (rc > 0)
40011fb8: b0 92 20 00 orcc %o0, 0, %i0
40011fbc: 14 80 00 16 bg 40012014 <rtems_rfs_inode_create+0x218>
<== NEVER TAKEN
40011fc0: 92 07 bf d8 add %fp, -40, %o1
if (RTEMS_RFS_S_ISDIR (mode))
40011fc4: 03 10 00 00 sethi %hi(0x40000000), %g1
40011fc8: 80 a4 40 01 cmp %l1, %g1
40011fcc: 02 80 00 3d be 400120c0 <rtems_rfs_inode_create+0x2c4>
40011fd0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40011fd4: 96 10 20 01 mov 1, %o3
40011fd8: 94 07 bf b0 add %fp, -80, %o2
40011fdc: 92 10 00 19 mov %i1, %o1
40011fe0: 7f ff fe 27 call 4001187c <rtems_rfs_inode_open>
40011fe4: 90 10 00 15 mov %l5, %o0
if (rc > 0)
40011fe8: b0 92 20 00 orcc %o0, 0, %i0
40011fec: 04 80 00 13 ble 40012038 <rtems_rfs_inode_create+0x23c>
<== ALWAYS TAKEN
40011ff0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rtems_rfs_inode_delete (fs, &inode);
40011ff4: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40011ff8: 7f ff fe be call 40011af0 <rtems_rfs_inode_delete>
<== NOT EXECUTED
40011ffc: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012000: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40012004: 7f ff fe 95 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
40012008: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
4001200c: 81 c7 e0 08 ret
<== NOT EXECUTED
40012010: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012014: 7f ff fe 91 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
40012018: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
4001201c: 10 bf ff d6 b 40011f74 <rtems_rfs_inode_create+0x178>
<== NOT EXECUTED
40012020: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
type = "file";
40012024: 31 10 00 8b sethi %hi(0x40022c00), %i0
<== NOT EXECUTED
40012028: 10 bf ff 96 b 40011e80 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
4001202c: b0 16 21 d8 or %i0, 0x1d8, %i0 ! 40022dd8 <ramdisk_ops+0x10c0>
<== NOT EXECUTED
type = "link";
40012030: 10 bf ff 94 b 40011e80 <rtems_rfs_inode_create+0x84>
<== NOT EXECUTED
40012034: b0 16 21 e8 or %i0, 0x1e8, %i0
<== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
40012038: d8 00 40 00 ld [ %g1 ], %o4
4001203c: 96 10 00 1b mov %i3, %o3
40012040: 94 10 00 1a mov %i2, %o2
40012044: 92 07 bf b0 add %fp, -80, %o1
40012048: 40 00 20 d1 call 4001a38c <rtems_rfs_dir_add_entry>
4001204c: 90 10 00 15 mov %l5, %o0
if (rc > 0)
40012050: b0 92 20 00 orcc %o0, 0, %i0
40012054: 14 80 00 32 bg 4001211c <rtems_rfs_inode_create+0x320>
<== NEVER TAKEN
40012058: 03 10 00 00 sethi %hi(0x40000000), %g1
if (RTEMS_RFS_S_ISDIR (mode))
4001205c: 80 a4 40 01 cmp %l1, %g1
40012060: 02 80 00 3a be 40012148 <rtems_rfs_inode_create+0x34c>
40012064: c6 07 bf bc ld [ %fp + -68 ], %g3
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40012068: 94 10 20 01 mov 1, %o2
4001206c: 92 10 20 01 mov 1, %o1
40012070: 7f ff fe ea call 40011c18 <rtems_rfs_inode_time_stamp_now>
40012074: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
40012078: b0 92 20 00 orcc %o0, 0, %i0
4001207c: 14 bf ff df bg 40011ff8 <rtems_rfs_inode_create+0x1fc>
<== NEVER TAKEN
40012080: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
40012084: 92 07 bf b0 add %fp, -80, %o1
40012088: 7f ff fe 74 call 40011a58 <rtems_rfs_inode_close>
4001208c: 90 10 00 15 mov %l5, %o0
rtems_rfs_inode_delete (fs, &inode);
40012090: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
40012094: b0 10 00 08 mov %o0, %i0
if (rc > 0)
40012098: 80 a6 20 00 cmp %i0, 0
4001209c: 04 80 00 3e ble 40012194 <rtems_rfs_inode_create+0x398>
<== ALWAYS TAKEN
400120a0: 90 10 00 15 mov %l5, %o0
rtems_rfs_inode_delete (fs, &inode);
400120a4: 7f ff fe 93 call 40011af0 <rtems_rfs_inode_delete>
<== NOT EXECUTED
400120a8: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400120ac: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
400120b0: 7f ff fe 6a call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
400120b4: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
400120b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400120bc: 81 e8 00 00 restore
<== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
400120c0: d8 00 40 00 ld [ %g1 ], %o4
400120c4: 96 10 20 01 mov 1, %o3
400120c8: 92 07 bf d8 add %fp, -40, %o1
400120cc: 15 10 00 85 sethi %hi(0x40021400), %o2
400120d0: 90 10 00 15 mov %l5, %o0
400120d4: 40 00 20 ae call 4001a38c <rtems_rfs_dir_add_entry>
400120d8: 94 12 a1 d0 or %o2, 0x1d0, %o2
if (rc == 0)
400120dc: b0 92 20 00 orcc %o0, 0, %i0
400120e0: 12 80 00 0b bne 4001210c <rtems_rfs_inode_create+0x310>
<== NEVER TAKEN
400120e4: 80 a6 20 00 cmp %i0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
400120e8: 98 10 00 19 mov %i1, %o4
400120ec: 96 10 20 02 mov 2, %o3
400120f0: 92 07 bf d8 add %fp, -40, %o1
400120f4: 15 10 00 86 sethi %hi(0x40021800), %o2
400120f8: 90 10 00 15 mov %l5, %o0
400120fc: 40 00 20 a4 call 4001a38c <rtems_rfs_dir_add_entry>
40012100: 94 12 a3 d8 or %o2, 0x3d8, %o2
40012104: b0 10 00 08 mov %o0, %i0
if (rc > 0)
40012108: 80 a6 20 00 cmp %i0, 0
4001210c: 04 bf ff b3 ble 40011fd8 <rtems_rfs_inode_create+0x1dc>
<== ALWAYS TAKEN
40012110: 96 10 20 01 mov 1, %o3
40012114: 10 bf ff b9 b 40011ff8 <rtems_rfs_inode_create+0x1fc>
<== NOT EXECUTED
40012118: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
4001211c: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
40012120: 7f ff fe 74 call 40011af0 <rtems_rfs_inode_delete>
<== NOT EXECUTED
40012124: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012128: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001212c: 7f ff fe 4b call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
40012130: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40012134: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
40012138: 7f ff fe 48 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001213c: 90 10 00 15 mov %l5, %o0
<== NOT EXECUTED
return rc;
40012140: 81 c7 e0 08 ret
<== NOT EXECUTED
40012144: 81 e8 00 00 restore
<== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
40012148: c4 08 e0 01 ldub [ %g3 + 1 ], %g2
4001214c: c2 08 c0 00 ldub [ %g3 ], %g1
40012150: 83 28 60 08 sll %g1, 8, %g1
if (links == 0xffff)
40012154: 09 00 00 3f sethi %hi(0xfc00), %g4
links = rtems_rfs_read_u16 (&handle->node->links);
40012158: 82 10 40 02 or %g1, %g2, %g1
if (links == 0xffff)
4001215c: 88 11 23 ff or %g4, 0x3ff, %g4
40012160: 80 a0 40 04 cmp %g1, %g4
40012164: 12 80 00 03 bne 40012170 <rtems_rfs_inode_create+0x374>
<== ALWAYS TAKEN
40012168: 84 10 00 01 mov %g1, %g2
links = 0;
4001216c: 84 10 20 00 clr %g2
<== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode,
40012170: 82 00 a0 01 add %g2, 1, %g1
rtems_rfs_write_u16 (&handle->node->links, links);
40012174: 85 28 60 10 sll %g1, 0x10, %g2
40012178: 85 30 a0 18 srl %g2, 0x18, %g2
4001217c: c4 28 c0 00 stb %g2, [ %g3 ]
40012180: c4 07 bf bc ld [ %fp + -68 ], %g2
40012184: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012188: 82 10 20 01 mov 1, %g1
4001218c: 10 bf ff b7 b 40012068 <rtems_rfs_inode_create+0x26c>
40012190: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rc = rtems_rfs_inode_close (fs, &inode);
40012194: 7f ff fe 31 call 40011a58 <rtems_rfs_inode_close>
40012198: 01 00 00 00 nop
if (rc > 0)
4001219c: b0 92 20 00 orcc %o0, 0, %i0
400121a0: 14 bf ff 75 bg 40011f74 <rtems_rfs_inode_create+0x178>
<== NEVER TAKEN
400121a4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
}
400121a8: 81 c7 e0 08 ret
400121ac: 91 e8 20 00 restore %g0, 0, %o0
40011af0 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40011af0: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
40011af4: 90 10 20 00 clr %o0
40011af8: 40 00 05 96 call 40013150 <rtems_rfs_trace>
40011afc: 13 00 20 00 sethi %hi(0x800000), %o1
40011b00: 80 a2 20 00 cmp %o0, 0
40011b04: 02 80 00 0b be 40011b30 <rtems_rfs_inode_delete+0x40>
<== ALWAYS TAKEN
40011b08: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
40011b0c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011b10: 02 80 00 14 be 40011b60 <rtems_rfs_inode_delete+0x70>
<== NOT EXECUTED
40011b14: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
40011b18: 15 10 00 8b sethi %hi(0x40022c00), %o2
<== NOT EXECUTED
40011b1c: 94 12 a0 98 or %o2, 0x98, %o2 ! 40022c98 <ramdisk_ops+0xf80>
<== NOT EXECUTED
40011b20: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011b24: 40 00 06 19 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011b28: 90 12 21 98 or %o0, 0x198, %o0 ! 40022d98 <ramdisk_ops+0x1080>
<== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40011b2c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
40011b30: 80 a0 60 00 cmp %g1, 0
40011b34: 02 80 00 09 be 40011b58 <rtems_rfs_inode_delete+0x68>
<== NEVER TAKEN
40011b38: ba 10 20 00 clr %i5
return rtems_rfs_group_bitmap_free (fs, true, bit);
40011b3c: d4 06 60 08 ld [ %i1 + 8 ], %o2
40011b40: 92 10 20 01 mov 1, %o1
40011b44: 7f ff fe aa call 400115ec <rtems_rfs_group_bitmap_free>
40011b48: 90 10 00 18 mov %i0, %o0
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
if (rc > 0)
40011b4c: ba 92 20 00 orcc %o0, 0, %i5
40011b50: 04 80 00 07 ble 40011b6c <rtems_rfs_inode_delete+0x7c>
<== ALWAYS TAKEN
40011b54: 92 10 00 19 mov %i1, %o1
if (rrc > 0)
rc = rrc;
}
}
return rc;
}
40011b58: 81 c7 e0 08 ret
40011b5c: 91 e8 00 1d restore %g0, %i5, %o0
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
40011b60: 15 10 00 8b sethi %hi(0x40022c00), %o2
<== NOT EXECUTED
40011b64: 10 bf ff ef b 40011b20 <rtems_rfs_inode_delete+0x30>
<== NOT EXECUTED
40011b68: 94 12 a0 a0 or %o2, 0xa0, %o2 ! 40022ca0 <ramdisk_ops+0xf88>
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, handle, &map);
40011b6c: 94 07 bf b0 add %fp, -80, %o2
40011b70: 40 00 1d 64 call 40019100 <rtems_rfs_block_map_open>
40011b74: 90 10 00 18 mov %i0, %o0
if (rc == 0)
40011b78: ba 92 20 00 orcc %o0, 0, %i5
40011b7c: 12 bf ff f7 bne 40011b58 <rtems_rfs_inode_delete+0x68>
<== NEVER TAKEN
40011b80: 92 07 bf b0 add %fp, -80, %o1
rrc = rtems_rfs_block_map_free_all (fs, &map);
40011b84: 40 00 20 77 call 40019d60 <rtems_rfs_block_map_free_all>
40011b88: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
40011b8c: 92 07 bf b0 add %fp, -80, %o1
rrc = rtems_rfs_block_map_free_all (fs, &map);
40011b90: b6 10 00 08 mov %o0, %i3
rc = rtems_rfs_block_map_close (fs, &map);
40011b94: 40 00 1d ba call 4001927c <rtems_rfs_block_map_close>
40011b98: 90 10 00 18 mov %i0, %o0
40011b9c: b8 06 60 10 add %i1, 0x10, %i4
40011ba0: ba 10 00 08 mov %o0, %i5
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40011ba4: 94 10 20 38 mov 0x38, %o2
40011ba8: d0 06 60 0c ld [ %i1 + 0xc ], %o0
if (rc > 0)
40011bac: 80 a7 60 00 cmp %i5, 0
40011bb0: 04 80 00 0c ble 40011be0 <rtems_rfs_inode_delete+0xf0>
<== ALWAYS TAKEN
40011bb4: 92 10 20 ff mov 0xff, %o1
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40011bb8: 40 00 33 1d call 4001e82c <memset>
<== NOT EXECUTED
40011bbc: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011bc0: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
40011bc4: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40011bc8: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40011bcc: 7f ff f8 06 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
40011bd0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->loads = 0;
40011bd4: c0 26 60 24 clr [ %i1 + 0x24 ]
<== NOT EXECUTED
handle->node = NULL;
40011bd8: 10 bf ff e0 b 40011b58 <rtems_rfs_inode_delete+0x68>
<== NOT EXECUTED
40011bdc: c0 26 60 0c clr [ %i1 + 0xc ]
<== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40011be0: 40 00 33 13 call 4001e82c <memset>
40011be4: 01 00 00 00 nop
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011be8: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
40011bec: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40011bf0: 92 10 00 1c mov %i4, %o1
40011bf4: 7f ff f7 fc call 4000fbe4 <rtems_rfs_buffer_handle_release>
40011bf8: 90 10 00 18 mov %i0, %o0
handle->loads = 0;
40011bfc: c0 26 60 24 clr [ %i1 + 0x24 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40011c00: ba 10 00 08 mov %o0, %i5
if (rrc > 0)
40011c04: 80 a6 e0 00 cmp %i3, 0
40011c08: 04 bf ff d4 ble 40011b58 <rtems_rfs_inode_delete+0x68>
<== ALWAYS TAKEN
40011c0c: c0 26 60 0c clr [ %i1 + 0xc ]
40011c10: 10 bf ff d2 b 40011b58 <rtems_rfs_inode_delete+0x68>
<== NOT EXECUTED
40011c14: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
400117c8 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400117c8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
400117cc: 90 10 20 00 clr %o0
400117d0: 40 00 06 60 call 40013150 <rtems_rfs_trace>
400117d4: 13 00 04 00 sethi %hi(0x100000), %o1
400117d8: 80 a2 20 00 cmp %o0, 0
400117dc: 02 80 00 0c be 4001180c <rtems_rfs_inode_load+0x44>
<== ALWAYS TAKEN
400117e0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
400117e4: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
400117e8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400117ec: 02 80 00 11 be 40011830 <rtems_rfs_inode_load+0x68>
<== NOT EXECUTED
400117f0: d4 06 60 24 ld [ %i1 + 0x24 ], %o2
<== NOT EXECUTED
400117f4: 17 10 00 8b sethi %hi(0x40022c00), %o3
<== NOT EXECUTED
400117f8: 96 12 e0 98 or %o3, 0x98, %o3 ! 40022c98 <ramdisk_ops+0xf80>
<== NOT EXECUTED
400117fc: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011800: 40 00 06 e2 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011804: 90 12 20 a8 or %o0, 0xa8, %o0 ! 40022ca8 <ramdisk_ops+0xf90>
<== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
40011808: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
4001180c: 80 a0 60 00 cmp %g1, 0
40011810: 22 80 00 0b be,a 4001183c <rtems_rfs_inode_load+0x74>
40011814: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
40011818: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4001181c: 82 00 60 01 inc %g1
40011820: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
40011824: b0 10 20 00 clr %i0
}
40011828: 81 c7 e0 08 ret
4001182c: 81 e8 00 00 restore
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40011830: 17 10 00 8b sethi %hi(0x40022c00), %o3
<== NOT EXECUTED
40011834: 10 bf ff f2 b 400117fc <rtems_rfs_inode_load+0x34>
<== NOT EXECUTED
40011838: 96 12 e0 a0 or %o3, 0xa0, %o3 ! 40022ca0 <ramdisk_ops+0xf88>
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
4001183c: 90 10 00 18 mov %i0, %o0
40011840: 96 10 20 01 mov 1, %o3
40011844: 7f ff f8 21 call 4000f8c8 <rtems_rfs_buffer_handle_request>
40011848: 92 06 60 10 add %i1, 0x10, %o1
if (rc > 0)
4001184c: b0 92 20 00 orcc %o0, 0, %i0
40011850: 14 bf ff f6 bg 40011828 <rtems_rfs_inode_load+0x60>
<== NEVER TAKEN
40011854: 01 00 00 00 nop
handle->node = rtems_rfs_buffer_data (&handle->buffer);
40011858: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
handle->node += handle->offset;
4001185c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
40011860: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
40011864: 83 28 e0 03 sll %g3, 3, %g1
40011868: 82 20 40 03 sub %g1, %g3, %g1
4001186c: 83 28 60 03 sll %g1, 3, %g1
40011870: 82 00 80 01 add %g2, %g1, %g1
40011874: 10 bf ff e9 b 40011818 <rtems_rfs_inode_load+0x50>
40011878: c2 26 60 0c st %g1, [ %i1 + 0xc ]
4001187c <rtems_rfs_inode_open>:
{
4001187c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
40011880: 90 10 20 00 clr %o0
40011884: 40 00 06 33 call 40013150 <rtems_rfs_trace>
40011888: 13 00 01 00 sethi %hi(0x40000), %o1
4001188c: 80 a2 20 00 cmp %o0, 0
40011890: 32 80 00 2f bne,a 4001194c <rtems_rfs_inode_open+0xd0>
<== NEVER TAKEN
40011894: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
40011898: 80 a6 60 00 cmp %i1, 0
4001189c: 02 80 00 29 be 40011940 <rtems_rfs_inode_open+0xc4>
<== NEVER TAKEN
400118a0: 82 06 7f ff add %i1, -1, %g1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
400118a4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
400118a8: 80 a0 40 02 cmp %g1, %g2
400118ac: 18 80 00 25 bgu 40011940 <rtems_rfs_inode_open+0xc4>
<== NEVER TAKEN
400118b0: 80 a6 e0 00 cmp %i3, 0
group = gino / fs->group_inodes;
400118b4: fa 06 20 2c ld [ %i0 + 0x2c ], %i5
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400118b8: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
400118bc: c8 06 20 30 ld [ %i0 + 0x30 ], %g4
gino = gino % fs->group_inodes;
400118c0: 81 80 20 00 wr %g0, %y
400118c4: 01 00 00 00 nop
400118c8: 01 00 00 00 nop
400118cc: 01 00 00 00 nop
400118d0: 84 70 40 1d udiv %g1, %i5, %g2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400118d4: 87 28 a0 02 sll %g2, 2, %g3
400118d8: 86 00 c0 02 add %g3, %g2, %g3
gino = gino % fs->group_inodes;
400118dc: 84 58 80 1d smul %g2, %i5, %g2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400118e0: 87 28 e0 04 sll %g3, 4, %g3
400118e4: c6 07 00 03 ld [ %i4 + %g3 ], %g3
gino = gino % fs->group_inodes;
400118e8: 82 20 40 02 sub %g1, %g2, %g1
handle->ino = ino;
400118ec: f2 26 a0 08 st %i1, [ %i2 + 8 ]
handle->offset = gino % fs->inodes_per_block;
400118f0: 81 80 20 00 wr %g0, %y
400118f4: 01 00 00 00 nop
400118f8: 01 00 00 00 nop
400118fc: 01 00 00 00 nop
40011900: 84 70 40 04 udiv %g1, %g4, %g2
handle->node = NULL;
40011904: c0 26 a0 0c clr [ %i2 + 0xc ]
handle->offset = gino % fs->inodes_per_block;
40011908: 88 58 80 04 smul %g2, %g4, %g4
handle->loads = 0;
4001190c: c0 26 a0 24 clr [ %i2 + 0x24 ]
handle->offset = gino % fs->inodes_per_block;
40011910: 82 20 40 04 sub %g1, %g4, %g1
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40011914: 84 00 a0 02 add %g2, 2, %g2
handle->offset = gino % fs->inodes_per_block;
40011918: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4001191c: 84 00 c0 02 add %g3, %g2, %g2
handle->dirty = false;
40011920: c0 2e a0 10 clrb [ %i2 + 0x10 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
40011924: 82 10 20 00 clr %g1
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40011928: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
handle->bnum = 0;
4001192c: c0 26 a0 14 clr [ %i2 + 0x14 ]
if ((rc == 0) && load)
40011930: 02 80 00 05 be 40011944 <rtems_rfs_inode_open+0xc8>
<== NEVER TAKEN
40011934: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_inode_load (fs, handle);
40011938: 7f ff ff a4 call 400117c8 <rtems_rfs_inode_load>
4001193c: 93 e8 00 1a restore %g0, %i2, %o1
return EINVAL;
40011940: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
}
40011944: 81 c7 e0 08 ret
<== NOT EXECUTED
40011948: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
4001194c: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011950: 40 00 06 8e call 40013388 <__wrap_printf>
<== NOT EXECUTED
40011954: 90 12 20 e0 or %o0, 0xe0, %o0 ! 40022ce0 <ramdisk_ops+0xfc8>
<== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
40011958: 10 bf ff d1 b 4001189c <rtems_rfs_inode_open+0x20>
<== NOT EXECUTED
4001195c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40011c18 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40011c18: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40011c1c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
{
40011c20: ba 10 00 18 mov %i0, %i5
if (!rtems_rfs_inode_is_loaded (handle))
40011c24: 80 a0 60 00 cmp %g1, 0
40011c28: 02 80 00 23 be 40011cb4 <rtems_rfs_inode_time_stamp_now+0x9c>
<== NEVER TAKEN
40011c2c: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
40011c30: 40 00 37 4c call 4001f960 <time>
40011c34: 90 10 20 00 clr %o0
if (atime)
40011c38: 80 a6 60 00 cmp %i1, 0
40011c3c: 02 80 00 0f be 40011c78 <rtems_rfs_inode_time_stamp_now+0x60>
<== NEVER TAKEN
40011c40: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_write_u32 (&handle->node->atime, atime);
40011c44: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011c48: 85 32 60 18 srl %o1, 0x18, %g2
40011c4c: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
40011c50: 83 32 60 10 srl %o1, 0x10, %g1
40011c54: c4 07 60 0c ld [ %i5 + 0xc ], %g2
40011c58: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
40011c5c: 83 32 60 08 srl %o1, 8, %g1
40011c60: c4 07 60 0c ld [ %i5 + 0xc ], %g2
40011c64: c2 28 a0 12 stb %g1, [ %g2 + 0x12 ]
40011c68: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011c6c: d2 28 60 13 stb %o1, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011c70: 82 10 20 01 mov 1, %g1
40011c74: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
40011c78: 02 80 00 0f be 40011cb4 <rtems_rfs_inode_time_stamp_now+0x9c>
<== NEVER TAKEN
40011c7c: b0 10 20 00 clr %i0
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
40011c80: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011c84: 85 32 60 18 srl %o1, 0x18, %g2
40011c88: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
40011c8c: 85 32 60 10 srl %o1, 0x10, %g2
40011c90: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011c94: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
40011c98: 85 32 60 08 srl %o1, 8, %g2
40011c9c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011ca0: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
40011ca4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40011ca8: d2 28 60 17 stb %o1, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011cac: 82 10 20 01 mov 1, %g1
40011cb0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
40011cb4: 81 c7 e0 08 ret
40011cb8: 81 e8 00 00 restore
40011960 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
40011960: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
40011964: 90 10 20 00 clr %o0
40011968: 40 00 05 fa call 40013150 <rtems_rfs_trace>
4001196c: 13 00 08 00 sethi %hi(0x200000), %o1
40011970: 80 a2 20 00 cmp %o0, 0
40011974: 02 80 00 0c be 400119a4 <rtems_rfs_inode_unload+0x44>
<== ALWAYS TAKEN
40011978: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
4001197c: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
40011980: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011984: 02 80 00 22 be 40011a0c <rtems_rfs_inode_unload+0xac>
<== NOT EXECUTED
40011988: d4 06 60 24 ld [ %i1 + 0x24 ], %o2
<== NOT EXECUTED
4001198c: 17 10 00 8b sethi %hi(0x40022c00), %o3
<== NOT EXECUTED
40011990: 96 12 e0 98 or %o3, 0x98, %o3 ! 40022c98 <ramdisk_ops+0xf80>
<== NOT EXECUTED
40011994: 11 10 00 8b sethi %hi(0x40022c00), %o0
<== NOT EXECUTED
40011998: 40 00 06 7c call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001199c: 90 12 21 08 or %o0, 0x108, %o0 ! 40022d08 <ramdisk_ops+0xff0>
<== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
400119a0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
400119a4: 80 a0 60 00 cmp %g1, 0
400119a8: 22 80 00 17 be,a 40011a04 <rtems_rfs_inode_unload+0xa4>
400119ac: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
400119b0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
400119b4: 80 a0 60 00 cmp %g1, 0
400119b8: 02 80 00 10 be 400119f8 <rtems_rfs_inode_unload+0x98>
<== NEVER TAKEN
400119bc: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
400119c0: 82 00 7f ff add %g1, -1, %g1
if (handle->loads == 0)
400119c4: 80 a0 60 00 cmp %g1, 0
400119c8: 12 80 00 0e bne 40011a00 <rtems_rfs_inode_unload+0xa0>
400119cc: 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)
400119d0: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
400119d4: 80 a0 60 00 cmp %g1, 0
400119d8: 02 80 00 04 be 400119e8 <rtems_rfs_inode_unload+0x88>
400119dc: 80 a6 a0 00 cmp %i2, 0
400119e0: 12 80 00 0e bne 40011a18 <rtems_rfs_inode_unload+0xb8>
<== ALWAYS TAKEN
400119e4: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
400119e8: 92 06 60 10 add %i1, 0x10, %o1
400119ec: 7f ff f8 7e call 4000fbe4 <rtems_rfs_buffer_handle_release>
400119f0: 90 10 00 18 mov %i0, %o0
handle->node = NULL;
400119f4: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
400119f8: 81 c7 e0 08 ret
400119fc: 91 e8 00 08 restore %g0, %o0, %o0
int rc = 0;
40011a00: 90 10 20 00 clr %o0
}
40011a04: 81 c7 e0 08 ret
40011a08: 91 e8 00 08 restore %g0, %o0, %o0
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40011a0c: 17 10 00 8b sethi %hi(0x40022c00), %o3
<== NOT EXECUTED
40011a10: 10 bf ff e1 b 40011994 <rtems_rfs_inode_unload+0x34>
<== NOT EXECUTED
40011a14: 96 12 e0 a0 or %o3, 0xa0, %o3 ! 40022ca0 <ramdisk_ops+0xf88>
<== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
40011a18: 40 00 37 d2 call 4001f960 <time>
40011a1c: 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);
40011a20: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40011a24: 85 32 60 18 srl %o1, 0x18, %g2
40011a28: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
40011a2c: 85 32 60 10 srl %o1, 0x10, %g2
40011a30: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40011a34: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
40011a38: 85 32 60 08 srl %o1, 8, %g2
40011a3c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40011a40: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
40011a44: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40011a48: d2 28 60 1b stb %o1, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40011a4c: 82 10 20 01 mov 1, %g1
40011a50: 10 bf ff e6 b 400119e8 <rtems_rfs_inode_unload+0x88>
40011a54: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
4001cb6c <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
4001cb6c: 9d e3 bf 50 save %sp, -176, %sp
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
4001cb70: 90 10 20 00 clr %o0
4001cb74: 13 00 40 00 sethi %hi(0x1000000), %o1
4001cb78: 7f ff d9 76 call 40013150 <rtems_rfs_trace>
4001cb7c: a2 10 00 18 mov %i0, %l1
4001cb80: 80 a2 20 00 cmp %o0, 0
4001cb84: 12 80 00 50 bne 4001ccc4 <rtems_rfs_link+0x158>
<== NEVER TAKEN
4001cb88: 96 10 20 01 mov 1, %o3
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001cb8c: 94 07 bf d8 add %fp, -40, %o2
4001cb90: 92 10 00 1c mov %i4, %o1
4001cb94: 7f ff d3 3a call 4001187c <rtems_rfs_inode_open>
4001cb98: 90 10 00 11 mov %l1, %o0
if (rc)
4001cb9c: b0 92 20 00 orcc %o0, 0, %i0
4001cba0: 12 80 00 3c bne 4001cc90 <rtems_rfs_link+0x124>
<== NEVER TAKEN
4001cba4: 80 a7 60 00 cmp %i5, 0
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
4001cba8: 12 80 00 0a bne 4001cbd0 <rtems_rfs_link+0x64>
<== NEVER TAKEN
4001cbac: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001cbb0: 05 00 00 3c sethi %hi(0xf000), %g2
4001cbb4: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001cbb8: 83 28 60 08 sll %g1, 8, %g1
4001cbbc: 82 08 40 02 and %g1, %g2, %g1
4001cbc0: 05 00 00 10 sethi %hi(0x4000), %g2
4001cbc4: 80 a0 40 02 cmp %g1, %g2
4001cbc8: 02 80 00 5a be 4001cd30 <rtems_rfs_link+0x1c4>
<== NEVER TAKEN
4001cbcc: b0 10 20 86 mov 0x86, %i0
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001cbd0: 96 10 20 01 mov 1, %o3
4001cbd4: 94 07 bf b0 add %fp, -80, %o2
4001cbd8: 92 10 00 1b mov %i3, %o1
4001cbdc: 7f ff d3 28 call 4001187c <rtems_rfs_inode_open>
4001cbe0: 90 10 00 11 mov %l1, %o0
if (rc)
4001cbe4: b0 92 20 00 orcc %o0, 0, %i0
4001cbe8: 12 80 00 26 bne 4001cc80 <rtems_rfs_link+0x114>
<== NEVER TAKEN
4001cbec: 98 10 00 1c mov %i4, %o4
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
4001cbf0: 96 10 00 1a mov %i2, %o3
4001cbf4: 94 10 00 19 mov %i1, %o2
4001cbf8: 92 07 bf b0 add %fp, -80, %o1
4001cbfc: 7f ff f5 e4 call 4001a38c <rtems_rfs_dir_add_entry>
4001cc00: 90 10 00 11 mov %l1, %o0
if (rc > 0)
4001cc04: b0 92 20 00 orcc %o0, 0, %i0
4001cc08: 14 80 00 43 bg 4001cd14 <rtems_rfs_link+0x1a8>
<== NEVER TAKEN
4001cc0c: c4 07 bf e4 ld [ %fp + -28 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
4001cc10: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001cc14: c2 08 80 00 ldub [ %g2 ], %g1
4001cc18: 83 28 60 08 sll %g1, 8, %g1
4001cc1c: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
4001cc20: 07 00 00 3f sethi %hi(0xfc00), %g3
4001cc24: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
4001cc28: 80 a0 40 03 cmp %g1, %g3
4001cc2c: 22 80 00 3f be,a 4001cd28 <rtems_rfs_link+0x1bc>
<== NEVER TAKEN
4001cc30: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4001cc34: 82 00 60 01 inc %g1
4001cc38: 87 28 60 10 sll %g1, 0x10, %g3
4001cc3c: 87 30 e0 18 srl %g3, 0x18, %g3
rtems_rfs_write_u16 (&handle->node->links, links);
4001cc40: c6 28 80 00 stb %g3, [ %g2 ]
}
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);
4001cc44: 92 10 20 01 mov 1, %o1
4001cc48: c4 07 bf e4 ld [ %fp + -28 ], %g2
4001cc4c: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001cc50: 82 10 20 01 mov 1, %g1
4001cc54: 94 10 20 01 mov 1, %o2
4001cc58: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4001cc5c: 7f ff d3 ef call 40011c18 <rtems_rfs_inode_time_stamp_now>
4001cc60: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
4001cc64: 92 07 bf b0 add %fp, -80, %o1
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001cc68: b0 10 00 08 mov %o0, %i0
if (rc > 0)
4001cc6c: 80 a6 20 00 cmp %i0, 0
4001cc70: 04 80 00 0a ble 4001cc98 <rtems_rfs_link+0x12c>
<== ALWAYS TAKEN
4001cc74: 90 10 00 11 mov %l1, %o0
rtems_rfs_inode_close (fs, &parent_inode);
4001cc78: 7f ff d3 78 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cc7c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cc80: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001cc84: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4001cc88: 7f ff d3 74 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cc8c: 01 00 00 00 nop
<== NOT EXECUTED
return rc;
4001cc90: 81 c7 e0 08 ret
<== NOT EXECUTED
4001cc94: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001cc98: 7f ff d3 70 call 40011a58 <rtems_rfs_inode_close>
4001cc9c: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
4001cca0: 92 07 bf d8 add %fp, -40, %o1
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001cca4: b0 10 00 08 mov %o0, %i0
if (rc > 0)
4001cca8: 80 a6 20 00 cmp %i0, 0
4001ccac: 14 bf ff f7 bg 4001cc88 <rtems_rfs_link+0x11c>
<== NEVER TAKEN
4001ccb0: 90 10 00 11 mov %l1, %o0
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
4001ccb4: 7f ff d3 69 call 40011a58 <rtems_rfs_inode_close>
4001ccb8: 01 00 00 00 nop
return rc;
}
4001ccbc: 81 c7 e0 08 ret
4001ccc0: 91 e8 00 08 restore %g0, %o0, %o0
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
4001ccc4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001ccc8: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cccc: 7f ff d9 af call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001ccd0: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400244d0 <status_code_to_errno+0xfb4>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001ccd4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001ccd8: 04 80 00 09 ble 4001ccfc <rtems_rfs_link+0x190>
<== NOT EXECUTED
4001ccdc: b0 06 80 19 add %i2, %i1, %i0
<== NOT EXECUTED
4001cce0: a0 10 00 19 mov %i1, %l0
<== NOT EXECUTED
printf ("%c", name[c]);
4001cce4: 7f ff d9 be call 400133dc <__wrap_putchar>
<== NOT EXECUTED
4001cce8: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
4001ccec: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001ccf0: 80 a6 00 10 cmp %i0, %l0
<== NOT EXECUTED
4001ccf4: 12 bf ff fc bne 4001cce4 <rtems_rfs_link+0x178>
<== NOT EXECUTED
4001ccf8: 01 00 00 00 nop
<== NOT EXECUTED
printf ("(%" PRIu32 ")\n", target);
4001ccfc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001cd00: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cd04: 7f ff d9 a1 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001cd08: 90 12 20 f8 or %o0, 0xf8, %o0 ! 400244f8 <status_code_to_errno+0xfdc>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001cd0c: 10 bf ff a0 b 4001cb8c <rtems_rfs_link+0x20>
<== NOT EXECUTED
4001cd10: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001cd14: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001cd18: 7f ff d3 50 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cd1c: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cd20: 10 bf ff d9 b 4001cc84 <rtems_rfs_link+0x118>
<== NOT EXECUTED
4001cd24: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
if (links == 0xffff)
4001cd28: 10 bf ff c6 b 4001cc40 <rtems_rfs_link+0xd4>
<== NOT EXECUTED
4001cd2c: 86 10 20 00 clr %g3
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cd30: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001cd34: 7f ff d3 49 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cd38: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
return ENOTSUP;
4001cd3c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001cd40: 81 e8 00 00 restore
<== NOT EXECUTED
40022e80 <rtems_rfs_ops>:
40022e80: 40 01 2b a4 40 01 2b 8c 40 01 2b 10 40 01 28 90 @.+.@.+.@.+.@.(.
40022e90: 40 00 44 08 40 01 29 a0 40 01 27 20 40 01 23 98 @.D.@.).@.' @.#.
40022ea0: 40 01 22 ec 40 01 64 3c 40 01 64 68 40 01 66 88 @.".@.d<@.dh@.f.
40022eb0: 40 01 67 4c 40 01 2b b8 40 01 22 38 40 01 29 20 @.gL@.+.@."8@.)
40022ec0: 40 01 28 dc 40 01 28 00 40 01 27 68 @.(.@.(.@.'h
40024724 <rtems_rfs_rtems_device_handlers>:
40024724: 40 01 d6 94 40 01 d6 80 40 01 d6 6c 40 01 d6 58 @...@...@..l@..X
40024734: 40 01 d6 44 40 01 65 34 40 01 24 28 40 01 d6 3c @..D@.e4@.$(@..<
40024744: 40 01 64 70 40 01 64 70 40 01 64 60 40 01 66 ac @.dp@.dp@.d`@.f.
40024754: 40 01 64 e8 40 01 66 d0 40 01 67 84 40 01 66 6c @.d.@.f.@.g.@.fl
40024764 <rtems_rfs_rtems_dir_handlers>:
40024764: 40 01 d8 d4 40 01 d7 c0 40 01 d7 c8 40 01 67 68 @...@...@...@.gh
40024774: 40 01 64 cc 40 01 64 f0 40 01 24 28 40 01 64 94 @.d.@.d.@.$(@.d.
40024784: 40 01 64 70 40 01 2e 10 40 01 64 60 40 01 66 ac @.dp@...@.d`@.f.
40024794: 40 01 64 e8 40 01 66 d0 40 01 67 84 40 01 66 6c @.d.@.f.@.g.@.fl
40012e10 <rtems_rfs_rtems_fdatasync>:
{
40012e10: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40012e14: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
40012e18: 7f ff f3 e4 call 4000fda8 <rtems_rfs_buffer_sync>
<== NOT EXECUTED
40012e1c: d0 00 60 08 ld [ %g1 + 8 ], %o0
<== NOT EXECUTED
if (rc)
40012e20: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40012e24: 12 80 00 04 bne 40012e34 <rtems_rfs_rtems_fdatasync+0x24>
<== NOT EXECUTED
40012e28: 01 00 00 00 nop
<== NOT EXECUTED
}
40012e2c: 81 c7 e0 08 ret
<== NOT EXECUTED
40012e30: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
40012e34: 40 00 2d c6 call 4001e54c <__errno>
<== NOT EXECUTED
40012e38: 01 00 00 00 nop
<== NOT EXECUTED
40012e3c: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
40012e40: 81 c7 e0 08 ret
<== NOT EXECUTED
40012e44: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
400247a4 <rtems_rfs_rtems_file_handlers>:
400247a4: 40 01 df 58 40 01 de f8 40 01 dd 58 40 01 db 14 @..X@...@..X@...
400247b4: 40 01 64 cc 40 01 da 24 40 01 24 28 40 01 d9 b8 @.d.@..$@.$(@...
400247c4: 40 01 2e 10 40 01 2e 10 40 01 64 60 40 01 66 ac @...@...@.d`@.f.
400247d4: 40 01 64 e8 40 01 66 d0 40 01 67 84 40 01 66 6c @.d.@.f.@.g.@.fl
400247e4: 00 00 00 00 28 64 65 66 61 75 6c 74 29 00 00 00 ....(default)...
40012428 <rtems_rfs_rtems_fstat>:
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
40012428: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4001242c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40012430: 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);
40012434: d2 06 20 08 ld [ %i0 + 8 ], %o1
40012438: 96 10 20 01 mov 1, %o3
4001243c: 94 07 bf d8 add %fp, -40, %o2
40012440: 7f ff fd 0f call 4001187c <rtems_rfs_inode_open>
40012444: 90 10 00 1d mov %i5, %o0
if (rc)
40012448: b0 92 20 00 orcc %o0, 0, %i0
4001244c: 12 80 00 b0 bne 4001270c <rtems_rfs_rtems_fstat+0x2e4>
<== NEVER TAKEN
40012450: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_read_u16 (&handle->node->mode);
40012454: c4 08 60 03 ldub [ %g1 + 3 ], %g2
40012458: d0 08 60 02 ldub [ %g1 + 2 ], %o0
4001245c: 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))
40012460: 07 00 00 08 sethi %hi(0x2000), %g3
40012464: 90 12 00 02 or %o0, %g2, %o0
40012468: 05 3f ff ec sethi %hi(0xffffb000), %g2
4001246c: 84 0a 00 02 and %o0, %g2, %g2
40012470: 80 a0 80 03 cmp %g2, %g3
40012474: 22 80 00 46 be,a 4001258c <rtems_rfs_rtems_fstat+0x164>
<== NEVER TAKEN
40012478: 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);
4001247c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40012480: c2 26 60 04 st %g1, [ %i1 + 4 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
40012484: c2 07 bf e0 ld [ %fp + -32 ], %g1
40012488: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = rtems_rfs_rtems_mode (mode);
4001248c: 40 00 03 2f call 40013148 <rtems_rfs_rtems_mode>
40012490: c0 26 40 00 clr [ %i1 ]
40012494: d0 26 60 0c st %o0, [ %i1 + 0xc ]
40012498: c4 07 bf e4 ld [ %fp + -28 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
4001249c: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
400124a0: c2 08 80 00 ldub [ %g2 ], %g1
400124a4: 83 28 60 08 sll %g1, 8, %g1
400124a8: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
400124ac: 07 00 00 3f sethi %hi(0xfc00), %g3
400124b0: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
400124b4: 80 a0 40 03 cmp %g1, %g3
400124b8: 12 80 00 03 bne 400124c4 <rtems_rfs_rtems_fstat+0x9c>
<== ALWAYS TAKEN
400124bc: 88 10 00 01 mov %g1, %g4
links = 0;
400124c0: 88 10 20 00 clr %g4
<== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
400124c4: 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));
400124c8: 90 10 00 1d mov %i5, %o0
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
400124cc: c6 08 a0 06 ldub [ %g2 + 6 ], %g3
400124d0: c2 08 a0 07 ldub [ %g2 + 7 ], %g1
400124d4: 87 28 e0 08 sll %g3, 8, %g3
400124d8: 82 10 40 03 or %g1, %g3, %g1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
400124dc: c2 36 60 12 sth %g1, [ %i1 + 0x12 ]
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
400124e0: c2 08 a0 05 ldub [ %g2 + 5 ], %g1
400124e4: c6 08 a0 04 ldub [ %g2 + 4 ], %g3
400124e8: 85 28 e0 18 sll %g3, 0x18, %g2
400124ec: 83 28 60 10 sll %g1, 0x10, %g1
400124f0: 82 10 40 02 or %g1, %g2, %g1
400124f4: 83 30 60 10 srl %g1, 0x10, %g1
400124f8: c2 36 60 14 sth %g1, [ %i1 + 0x14 ]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
400124fc: 40 00 27 4d call 4001c230 <rtems_rfs_file_get_shared>
40012500: d2 07 bf e0 ld [ %fp + -32 ], %o1
if (shared)
40012504: 80 a2 20 00 cmp %o0, 0
40012508: 02 80 00 3b be 400125f4 <rtems_rfs_rtems_fstat+0x1cc>
4001250c: 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);
40012510: c4 02 20 94 ld [ %o0 + 0x94 ], %g2
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
40012514: c2 02 20 84 ld [ %o0 + 0x84 ], %g1
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
40012518: c8 02 20 8c ld [ %o0 + 0x8c ], %g4
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4001251c: c6 02 20 90 ld [ %o0 + 0x90 ], %g3
40012520: c6 26 60 3c st %g3, [ %i1 + 0x3c ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40012524: c4 26 60 4c st %g2, [ %i1 + 0x4c ]
if (S_ISLNK (buf->st_mode))
40012528: 05 00 00 3c sethi %hi(0xf000), %g2
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4001252c: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
40012530: c0 26 60 28 clr [ %i1 + 0x28 ]
40012534: c8 26 60 2c st %g4, [ %i1 + 0x2c ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40012538: c0 26 60 38 clr [ %i1 + 0x38 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4001253c: c0 26 60 48 clr [ %i1 + 0x48 ]
if (S_ISLNK (buf->st_mode))
40012540: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40012544: 82 08 40 02 and %g1, %g2, %g1
40012548: 05 00 00 28 sethi %hi(0xa000), %g2
4001254c: 80 a0 40 02 cmp %g1, %g2
40012550: 12 80 00 25 bne 400125e4 <rtems_rfs_rtems_fstat+0x1bc>
<== ALWAYS TAKEN
40012554: 92 02 20 84 add %o0, 0x84, %o1
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
40012558: c2 12 20 8a lduh [ %o0 + 0x8a ], %g1
<== NOT EXECUTED
4001255c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
<== NOT EXECUTED
40012560: 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);
40012564: 90 10 00 1d mov %i5, %o0
buf->st_blksize = rtems_rfs_fs_block_size (fs);
40012568: c2 07 60 08 ld [ %i5 + 8 ], %g1
4001256c: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
rc = rtems_rfs_inode_close (fs, &inode);
40012570: 7f ff fd 3a call 40011a58 <rtems_rfs_inode_close>
40012574: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
40012578: ba 92 20 00 orcc %o0, 0, %i5
4001257c: 14 80 00 5f bg 400126f8 <rtems_rfs_rtems_fstat+0x2d0>
<== NEVER TAKEN
40012580: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
return 0;
}
40012584: 81 c7 e0 08 ret
40012588: 81 e8 00 00 restore
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4001258c: f8 08 60 21 ldub [ %g1 + 0x21 ], %i4
<== NOT EXECUTED
40012590: c8 08 60 22 ldub [ %g1 + 0x22 ], %g4
<== NOT EXECUTED
40012594: f4 08 60 23 ldub [ %g1 + 0x23 ], %i2
<== NOT EXECUTED
40012598: de 08 60 1c ldub [ %g1 + 0x1c ], %o7
<== NOT EXECUTED
4001259c: c6 08 60 1d ldub [ %g1 + 0x1d ], %g3
<== NOT EXECUTED
400125a0: c4 08 60 1e ldub [ %g1 + 0x1e ], %g2
<== NOT EXECUTED
400125a4: f6 08 60 1f ldub [ %g1 + 0x1f ], %i3
<== NOT EXECUTED
400125a8: 83 2b 60 18 sll %o5, 0x18, %g1
<== NOT EXECUTED
400125ac: b9 2f 20 10 sll %i4, 0x10, %i4
<== NOT EXECUTED
400125b0: b8 17 00 01 or %i4, %g1, %i4
<== NOT EXECUTED
400125b4: 83 2b e0 18 sll %o7, 0x18, %g1
<== NOT EXECUTED
400125b8: 89 29 20 08 sll %g4, 8, %g4
<== NOT EXECUTED
400125bc: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
400125c0: 88 11 00 1c or %g4, %i4, %g4
<== NOT EXECUTED
400125c4: 86 10 c0 01 or %g3, %g1, %g3
<== NOT EXECUTED
400125c8: 88 16 80 04 or %i2, %g4, %g4
<== NOT EXECUTED
400125cc: 83 28 a0 08 sll %g2, 8, %g1
<== NOT EXECUTED
buf->st_rdev =
400125d0: c8 26 60 1c st %g4, [ %i1 + 0x1c ]
<== NOT EXECUTED
400125d4: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
400125d8: 82 16 c0 01 or %i3, %g1, %g1
<== NOT EXECUTED
400125dc: 10 bf ff a8 b 4001247c <rtems_rfs_rtems_fstat+0x54>
<== NOT EXECUTED
400125e0: 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);
400125e4: 40 00 1a b4 call 400190b4 <rtems_rfs_block_get_size>
400125e8: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
400125ec: 10 bf ff de b 40012564 <rtems_rfs_rtems_fstat+0x13c>
400125f0: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
return rtems_rfs_read_u32 (&handle->node->atime);
400125f4: c8 08 60 13 ldub [ %g1 + 0x13 ], %g4
400125f8: f8 08 60 10 ldub [ %g1 + 0x10 ], %i4
400125fc: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
40012600: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
40012604: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
40012608: c0 26 60 28 clr [ %i1 + 0x28 ]
4001260c: 87 28 e0 10 sll %g3, 0x10, %g3
40012610: 85 28 a0 08 sll %g2, 8, %g2
40012614: 86 10 c0 1c or %g3, %i4, %g3
40012618: 84 10 80 03 or %g2, %g3, %g2
4001261c: 84 11 00 02 or %g4, %g2, %g2
40012620: c4 26 60 2c st %g2, [ %i1 + 0x2c ]
return rtems_rfs_read_u32 (&handle->node->mtime);
40012624: c8 08 60 17 ldub [ %g1 + 0x17 ], %g4
40012628: f8 08 60 14 ldub [ %g1 + 0x14 ], %i4
4001262c: c6 08 60 15 ldub [ %g1 + 0x15 ], %g3
40012630: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
40012634: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
40012638: c0 26 60 38 clr [ %i1 + 0x38 ]
4001263c: 87 28 e0 10 sll %g3, 0x10, %g3
40012640: 85 28 a0 08 sll %g2, 8, %g2
40012644: 86 10 c0 1c or %g3, %i4, %g3
40012648: 84 10 80 03 or %g2, %g3, %g2
4001264c: 84 11 00 02 or %g4, %g2, %g2
40012650: c4 26 60 3c st %g2, [ %i1 + 0x3c ]
return rtems_rfs_read_u32 (&handle->node->ctime);
40012654: c8 08 60 1b ldub [ %g1 + 0x1b ], %g4
40012658: f8 08 60 18 ldub [ %g1 + 0x18 ], %i4
4001265c: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
40012660: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
40012664: b9 2f 20 18 sll %i4, 0x18, %i4
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
40012668: c0 26 60 48 clr [ %i1 + 0x48 ]
4001266c: 87 28 e0 10 sll %g3, 0x10, %g3
40012670: 85 28 a0 08 sll %g2, 8, %g2
40012674: 86 10 c0 1c or %g3, %i4, %g3
40012678: 84 10 80 03 or %g2, %g3, %g2
4001267c: 84 11 00 02 or %g4, %g2, %g2
40012680: c4 26 60 4c st %g2, [ %i1 + 0x4c ]
return rtems_rfs_read_u32 (&handle->node->block_count);
40012684: f8 08 60 0c ldub [ %g1 + 0xc ], %i4
40012688: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4001268c: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
40012690: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
40012694: b9 2f 20 18 sll %i4, 0x18, %i4
40012698: 87 28 e0 10 sll %g3, 0x10, %g3
4001269c: 85 28 a0 08 sll %g2, 8, %g2
400126a0: 86 10 c0 1c or %g3, %i4, %g3
400126a4: 84 10 80 03 or %g2, %g3, %g2
400126a8: 84 11 00 02 or %g4, %g2, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
400126ac: c4 26 60 5c st %g2, [ %i1 + 0x5c ]
if (S_ISLNK (buf->st_mode))
400126b0: 07 00 00 3c sethi %hi(0xf000), %g3
400126b4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
400126b8: 84 08 80 03 and %g2, %g3, %g2
400126bc: 07 00 00 28 sethi %hi(0xa000), %g3
400126c0: 80 a0 80 03 cmp %g2, %g3
400126c4: 12 80 00 09 bne 400126e8 <rtems_rfs_rtems_fstat+0x2c0>
400126c8: 92 07 bf d8 add %fp, -40, %o1
return rtems_rfs_read_u16 (&handle->node->block_offset);
400126cc: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
400126d0: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
400126d4: 83 28 a0 08 sll %g2, 8, %g1
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
400126d8: c0 26 60 20 clr [ %i1 + 0x20 ]
400126dc: 82 10 40 03 or %g1, %g3, %g1
400126e0: 10 bf ff a1 b 40012564 <rtems_rfs_rtems_fstat+0x13c>
400126e4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
400126e8: 7f ff fe b2 call 400121b0 <rtems_rfs_inode_get_size>
400126ec: 90 10 00 1d mov %i5, %o0
400126f0: 10 bf ff 9d b 40012564 <rtems_rfs_rtems_fstat+0x13c>
400126f4: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
return rtems_rfs_rtems_error ("stat: closing inode", rc);
400126f8: 40 00 2f 95 call 4001e54c <__errno>
<== NOT EXECUTED
400126fc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40012700: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
}
40012704: 81 c7 e0 08 ret
<== NOT EXECUTED
40012708: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
4001270c: 40 00 2f 90 call 4001e54c <__errno>
<== NOT EXECUTED
40012710: 01 00 00 00 nop
<== NOT EXECUTED
40012714: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
40012718: 81 c7 e0 08 ret
<== NOT EXECUTED
4001271c: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40012e48 <rtems_rfs_rtems_initialise>:
{
40012e48: 9d e3 bf 98 save %sp, -104, %sp
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
40012e4c: a2 10 20 05 mov 5, %l1
while (options)
40012e50: 80 a6 60 00 cmp %i1, 0
40012e54: 02 80 00 1f be 40012ed0 <rtems_rfs_rtems_initialise+0x88>
<== ALWAYS TAKEN
40012e58: ba 10 20 00 clr %i5
printf ("options=%s\n", options);
40012e5c: 37 10 00 8b sethi %hi(0x40022c00), %i3
<== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40012e60: 39 10 00 8b sethi %hi(0x40022c00), %i4
<== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
40012e64: 35 10 00 8b sethi %hi(0x40022c00), %i2
<== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40012e68: 21 10 00 8b sethi %hi(0x40022c00), %l0
<== NOT EXECUTED
printf ("options=%s\n", options);
40012e6c: b6 16 e2 40 or %i3, 0x240, %i3
<== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40012e70: b8 17 22 50 or %i4, 0x250, %i4
<== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
40012e74: b4 16 a2 60 or %i2, 0x260, %i2
<== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40012e78: a0 14 22 70 or %l0, 0x270, %l0
<== NOT EXECUTED
printf ("options=%s\n", options);
40012e7c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40012e80: 40 00 01 42 call 40013388 <__wrap_printf>
<== NOT EXECUTED
40012e84: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40012e88: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40012e8c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40012e90: 40 00 31 c2 call 4001f598 <strncmp>
<== NOT EXECUTED
40012e94: 94 10 20 0c mov 0xc, %o2
<== NOT EXECUTED
40012e98: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012e9c: 12 80 00 36 bne 40012f74 <rtems_rfs_rtems_initialise+0x12c>
<== NOT EXECUTED
40012ea0: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
40012ea4: ba 17 60 01 or %i5, 1, %i5
<== NOT EXECUTED
options = strchr (options, ',');
40012ea8: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40012eac: 40 00 2f 07 call 4001eac8 <strchr>
<== NOT EXECUTED
40012eb0: 92 10 20 2c mov 0x2c, %o1
<== NOT EXECUTED
if (options)
40012eb4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012eb8: 22 80 00 07 be,a 40012ed4 <rtems_rfs_rtems_initialise+0x8c>
<== NOT EXECUTED
40012ebc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
if (*options == '\0')
40012ec0: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1
<== NOT EXECUTED
40012ec4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012ec8: 12 80 00 33 bne 40012f94 <rtems_rfs_rtems_initialise+0x14c>
<== NOT EXECUTED
40012ecc: b2 82 20 01 addcc %o0, 1, %i1
<== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40012ed0: 92 10 20 01 mov 1, %o1
40012ed4: 7f ff cd 21 call 40006358 <calloc>
40012ed8: 90 10 20 18 mov 0x18, %o0
if (!rtems)
40012edc: b8 92 20 00 orcc %o0, 0, %i4
40012ee0: 02 80 00 59 be 40013044 <rtems_rfs_rtems_initialise+0x1fc>
<== NEVER TAKEN
40012ee4: 01 00 00 00 nop
rc = rtems_rfs_mutex_create (&rtems->access);
40012ee8: 40 00 29 c8 call 4001d608 <rtems_rfs_mutex_create>
40012eec: 01 00 00 00 nop
40012ef0: b6 10 00 08 mov %o0, %i3
if (rc > 0)
40012ef4: 80 a6 e0 00 cmp %i3, 0
40012ef8: 14 80 00 4c bg 40013028 <rtems_rfs_rtems_initialise+0x1e0>
<== NEVER TAKEN
40012efc: 90 10 00 1c mov %i4, %o0
40012f00: 7f ff e0 07 call 4000af1c <_Mutex_recursive_Acquire>
40012f04: 01 00 00 00 nop
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
40012f08: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
40012f0c: 94 10 00 1d mov %i5, %o2
40012f10: 98 07 bf fc add %fp, -4, %o4
40012f14: 96 10 00 11 mov %l1, %o3
40012f18: 40 00 24 e9 call 4001c2bc <rtems_rfs_fs_open>
40012f1c: 92 10 00 1c mov %i4, %o1
if (rc)
40012f20: ba 92 20 00 orcc %o0, 0, %i5
40012f24: 12 80 00 2b bne 40012fd0 <rtems_rfs_rtems_initialise+0x188>
<== NEVER TAKEN
40012f28: c2 07 bf fc ld [ %fp + -4 ], %g1
mt_entry->ops = &rtems_rfs_ops;
40012f2c: 05 10 00 8b sethi %hi(0x40022c00), %g2
40012f30: 84 10 a2 80 or %g2, 0x280, %g2 ! 40022e80 <rtems_rfs_ops>
mt_entry->fs_info = fs;
40012f34: c2 26 20 08 st %g1, [ %i0 + 8 ]
rtems_rfs_buffers_release (fs);
40012f38: 90 10 00 01 mov %g1, %o0
mt_entry->ops = &rtems_rfs_ops;
40012f3c: c4 26 20 0c st %g2, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40012f40: 84 10 20 01 mov 1, %g2
40012f44: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
40012f48: c4 20 e0 08 st %g2, [ %g3 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
40012f4c: 05 10 00 91 sethi %hi(0x40024400), %g2
40012f50: 84 10 a3 64 or %g2, 0x364, %g2 ! 40024764 <rtems_rfs_rtems_dir_handlers>
40012f54: c4 20 e0 10 st %g2, [ %g3 + 0x10 ]
40012f58: 7f ff f3 ba call 4000fe40 <rtems_rfs_buffers_release>
40012f5c: f8 00 60 80 ld [ %g1 + 0x80 ], %i4
_Mutex_recursive_Release( mutex );
40012f60: 7f ff e0 14 call 4000afb0 <_Mutex_recursive_Release>
40012f64: 90 10 00 1c mov %i4, %o0
}
40012f68: b0 10 00 1d mov %i5, %i0
40012f6c: 81 c7 e0 08 ret
40012f70: 81 e8 00 00 restore
else if (strncmp (options, "no-local-cache",
40012f74: 94 10 20 0e mov 0xe, %o2
<== NOT EXECUTED
40012f78: 40 00 31 88 call 4001f598 <strncmp>
<== NOT EXECUTED
40012f7c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40012f80: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012f84: 12 80 00 08 bne 40012fa4 <rtems_rfs_rtems_initialise+0x15c>
<== NOT EXECUTED
40012f88: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
40012f8c: 10 bf ff c7 b 40012ea8 <rtems_rfs_rtems_initialise+0x60>
<== NOT EXECUTED
40012f90: ba 17 60 02 or %i5, 2, %i5
<== NOT EXECUTED
while (options)
40012f94: 32 bf ff bb bne,a 40012e80 <rtems_rfs_rtems_initialise+0x38>
<== NOT EXECUTED
40012f98: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40012f9c: 10 bf ff ce b 40012ed4 <rtems_rfs_rtems_initialise+0x8c>
<== NOT EXECUTED
40012fa0: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
40012fa4: 94 10 20 0d mov 0xd, %o2
<== NOT EXECUTED
40012fa8: 40 00 31 7c call 4001f598 <strncmp>
<== NOT EXECUTED
40012fac: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40012fb0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012fb4: 12 80 00 17 bne 40013010 <rtems_rfs_rtems_initialise+0x1c8>
<== NOT EXECUTED
40012fb8: 94 10 20 00 clr %o2
<== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
40012fbc: 92 10 20 00 clr %o1
<== NOT EXECUTED
40012fc0: 40 00 32 5a call 4001f928 <strtoul>
<== NOT EXECUTED
40012fc4: 90 06 60 0e add %i1, 0xe, %o0
<== NOT EXECUTED
40012fc8: 10 bf ff b8 b 40012ea8 <rtems_rfs_rtems_initialise+0x60>
<== NOT EXECUTED
40012fcc: a2 10 00 08 mov %o0, %l1
<== NOT EXECUTED
40012fd0: 7f ff df f8 call 4000afb0 <_Mutex_recursive_Release>
<== NOT EXECUTED
40012fd4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
40012fd8: 40 00 29 97 call 4001d634 <rtems_rfs_mutex_destroy>
<== NOT EXECUTED
40012fdc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
free (rtems);
40012fe0: 7f ff cd 7e call 400065d8 <free>
<== NOT EXECUTED
40012fe4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
40012fe8: 40 00 2d 59 call 4001e54c <__errno>
<== NOT EXECUTED
40012fec: 01 00 00 00 nop
<== NOT EXECUTED
40012ff0: 40 00 2d 57 call 4001e54c <__errno>
<== NOT EXECUTED
40012ff4: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
40012ff8: c2 07 40 00 ld [ %i5 ], %g1
<== NOT EXECUTED
40012ffc: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
40013000: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40013004: ba 60 20 00 subx %g0, 0, %i5
<== NOT EXECUTED
}
40013008: 81 c7 e0 08 ret
<== NOT EXECUTED
4001300c: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
40013010: 40 00 2d 4f call 4001e54c <__errno>
<== NOT EXECUTED
40013014: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
40013018: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4001301c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40013020: 81 c7 e0 08 ret
<== NOT EXECUTED
40013024: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
free (rtems);
40013028: 7f ff cd 6c call 400065d8 <free>
<== NOT EXECUTED
4001302c: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
40013030: 40 00 2d 47 call 4001e54c <__errno>
<== NOT EXECUTED
40013034: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
40013038: f6 22 00 00 st %i3, [ %o0 ]
<== NOT EXECUTED
4001303c: 81 c7 e0 08 ret
<== NOT EXECUTED
40013040: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
40013044: 40 00 2d 42 call 4001e54c <__errno>
<== NOT EXECUTED
40013048: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
4001304c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40013050: 10 bf ff c6 b 40012f68 <rtems_rfs_rtems_initialise+0x120>
<== NOT EXECUTED
40013054: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40022ecc <rtems_rfs_rtems_link_handlers>:
40022ecc: 40 01 66 a4 40 01 64 44 40 01 66 b4 40 01 67 68 @.f.@.dD@.f.@.gh
40022edc: 40 01 64 cc 40 01 66 50 40 01 24 28 40 01 64 b0 @.d.@.fP@.$(@.d.
40022eec: 40 01 64 70 40 01 64 70 40 01 64 60 40 01 66 ac @.dp@.dp@.d`@.f.
40022efc: 40 01 64 e8 40 01 66 d0 40 01 67 84 40 01 66 6c @.d.@.f.@.g.@.fl
40013058 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
40013058: 9d e3 bf a0 save %sp, -96, %sp
4001305c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40013060: d2 08 60 02 ldub [ %g1 + 2 ], %o1
40013064: c2 08 60 03 ldub [ %g1 + 3 ], %g1
40013068: 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))
4001306c: 05 00 00 10 sethi %hi(0x4000), %g2
40013070: 92 12 40 01 or %o1, %g1, %o1
40013074: 82 0a 70 00 and %o1, -4096, %g1
40013078: 80 a0 40 02 cmp %g1, %g2
4001307c: 02 80 00 1b be 400130e8 <rtems_rfs_rtems_set_handlers+0x90>
40013080: 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))
40013084: 05 3f ff ec sethi %hi(0xffffb000), %g2
40013088: 07 00 00 08 sethi %hi(0x2000), %g3
4001308c: 84 0a 40 02 and %o1, %g2, %g2
40013090: 80 a0 80 03 cmp %g2, %g3
40013094: 02 80 00 0e be 400130cc <rtems_rfs_rtems_set_handlers+0x74>
<== NEVER TAKEN
40013098: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
4001309c: 80 a0 40 02 cmp %g1, %g2
400130a0: 02 80 00 20 be 40013120 <rtems_rfs_rtems_set_handlers+0xc8>
400130a4: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
400130a8: 80 a0 40 02 cmp %g1, %g2
400130ac: 02 80 00 16 be 40013104 <rtems_rfs_rtems_set_handlers+0xac>
<== ALWAYS TAKEN
400130b0: 11 10 00 8b sethi %hi(0x40022c00), %o0
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
400130b4: 40 00 00 b5 call 40013388 <__wrap_printf>
<== NOT EXECUTED
400130b8: 90 12 23 18 or %o0, 0x318, %o0 ! 40022f18 <rtems_rfs_rtems_eval_config+0xc>
<== NOT EXECUTED
return false;
400130bc: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
return true;
}
400130c0: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
400130c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400130c8: 81 e8 00 00 restore
<== NOT EXECUTED
return true;
400130cc: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
400130d0: 05 10 00 91 sethi %hi(0x40024400), %g2
<== NOT EXECUTED
400130d4: 84 10 a3 24 or %g2, 0x324, %g2 ! 40024724 <rtems_rfs_rtems_device_handlers>
<== NOT EXECUTED
400130d8: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
}
400130dc: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
400130e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400130e4: 81 e8 00 00 restore
<== NOT EXECUTED
return true;
400130e8: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (dir);
400130ec: 05 10 00 91 sethi %hi(0x40024400), %g2
400130f0: 84 10 a3 64 or %g2, 0x364, %g2 ! 40024764 <rtems_rfs_rtems_dir_handlers>
400130f4: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
400130f8: b0 08 60 01 and %g1, 1, %i0
400130fc: 81 c7 e0 08 ret
40013100: 81 e8 00 00 restore
return true;
40013104: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (file);
40013108: 05 10 00 91 sethi %hi(0x40024400), %g2
4001310c: 84 10 a3 a4 or %g2, 0x3a4, %g2 ! 400247a4 <rtems_rfs_rtems_file_handlers>
40013110: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
40013114: b0 08 60 01 and %g1, 1, %i0
40013118: 81 c7 e0 08 ret
4001311c: 81 e8 00 00 restore
return true;
40013120: 82 10 20 01 mov 1, %g1
loc->handlers = rtems_rfs_rtems_handlers (link);
40013124: 05 10 00 8b sethi %hi(0x40022c00), %g2
40013128: 84 10 a2 cc or %g2, 0x2cc, %g2 ! 40022ecc <rtems_rfs_rtems_link_handlers>
4001312c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
}
40013130: b0 08 60 01 and %g1, 1, %i0
40013134: 81 c7 e0 08 ret
40013138: 81 e8 00 00 restore
40012bb8 <rtems_rfs_rtems_shutdown>:
/**
* Shutdown the file system.
*/
void
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
40012bb8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = mt_entry->fs_info;
40012bbc: 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);
40012bc0: 40 00 27 c9 call 4001cae4 <rtems_rfs_fs_close>
40012bc4: f0 02 20 80 ld [ %o0 + 0x80 ], %i0
rtems_rfs_mutex_destroy (&rtems->access);
40012bc8: 40 00 2a 9b call 4001d634 <rtems_rfs_mutex_destroy>
40012bcc: 90 10 00 18 mov %i0, %o0
free (rtems);
40012bd0: 7f ff ce 82 call 400065d8 <free>
<== NOT EXECUTED
40012bd4: 81 e8 00 00 restore
4001d19c <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
4001d19c: 9d e3 bf 00 save %sp, -256, %sp
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
4001d1a0: 90 10 20 02 mov 2, %o0
{
4001d1a4: e2 17 a0 5e lduh [ %fp + 0x5e ], %l1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
4001d1a8: 7f ff d7 ea call 40013150 <rtems_rfs_trace>
4001d1ac: 92 10 20 00 clr %o1
4001d1b0: 80 a2 20 00 cmp %o0, 0
4001d1b4: 32 80 00 19 bne,a 4001d218 <rtems_rfs_symlink+0x7c>
<== NEVER TAKEN
4001d1b8: 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))
4001d1bc: c2 06 20 08 ld [ %i0 + 8 ], %g1
4001d1c0: 80 a0 40 1c cmp %g1, %i4
4001d1c4: 08 80 00 13 bleu 4001d210 <rtems_rfs_symlink+0x74>
<== NEVER TAKEN
4001d1c8: b4 10 20 5b mov 0x5b, %i2
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4001d1cc: 40 00 08 c3 call 4001f4d8 <strlen>
4001d1d0: 90 10 00 19 mov %i1, %o0
4001d1d4: 82 07 bf 74 add %fp, -140, %g1
4001d1d8: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
4001d1dc: 96 10 00 08 mov %o0, %o3
4001d1e0: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4001d1e4: 9a 10 20 01 mov 1, %o5
4001d1e8: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4001d1ec: 94 10 00 19 mov %i1, %o2
4001d1f0: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
4001d1f4: 19 00 00 28 sethi %hi(0xa000), %o4
4001d1f8: 90 10 00 18 mov %i0, %o0
4001d1fc: 7f ff d3 00 call 40011dfc <rtems_rfs_inode_create>
4001d200: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
4001d204: b4 92 20 00 orcc %o0, 0, %i2
4001d208: 04 80 00 20 ble 4001d288 <rtems_rfs_symlink+0xec>
<== ALWAYS TAKEN
4001d20c: d2 07 bf 74 ld [ %fp + -140 ], %o1
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
4001d210: 81 c7 e0 08 ret
4001d214: 91 e8 00 1a restore %g0, %i2, %o0
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
4001d218: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d21c: 7f ff d8 5b call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d220: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 400246d0 <status_code_to_errno+0x11b4>
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001d224: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001d228: 04 80 00 0a ble 4001d250 <rtems_rfs_symlink+0xb4>
<== NOT EXECUTED
4001d22c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d230: a0 10 00 19 mov %i1, %l0
<== NOT EXECUTED
4001d234: b4 06 80 19 add %i2, %i1, %i2
<== NOT EXECUTED
printf ("%c", name[c]);
4001d238: 7f ff d8 69 call 400133dc <__wrap_putchar>
<== NOT EXECUTED
4001d23c: d0 4c 00 00 ldsb [ %l0 ], %o0
<== NOT EXECUTED
4001d240: a0 04 20 01 inc %l0
<== NOT EXECUTED
for (c = 0; c < length; c++)
4001d244: 80 a4 00 1a cmp %l0, %i2
<== NOT EXECUTED
4001d248: 12 bf ff fc bne 4001d238 <rtems_rfs_symlink+0x9c>
<== NOT EXECUTED
4001d24c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
printf (" link:");
4001d250: 7f ff d8 4e call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d254: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 400246f8 <status_code_to_errno+0x11dc>
<== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001d258: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4001d25c: 04 bf ff d8 ble 4001d1bc <rtems_rfs_symlink+0x20>
<== NOT EXECUTED
4001d260: a0 07 00 1b add %i4, %i3, %l0
<== NOT EXECUTED
4001d264: b4 10 00 1b mov %i3, %i2
<== NOT EXECUTED
printf ("%c", link[c]);
4001d268: 7f ff d8 5d call 400133dc <__wrap_putchar>
<== NOT EXECUTED
4001d26c: d0 4e 80 00 ldsb [ %i2 ], %o0
<== NOT EXECUTED
4001d270: b4 06 a0 01 inc %i2
<== NOT EXECUTED
for (c = 0; c < link_length; c++)
4001d274: 80 a4 00 1a cmp %l0, %i2
<== NOT EXECUTED
4001d278: 12 bf ff fc bne 4001d268 <rtems_rfs_symlink+0xcc>
<== NOT EXECUTED
4001d27c: 01 00 00 00 nop
<== NOT EXECUTED
4001d280: 10 bf ff d0 b 4001d1c0 <rtems_rfs_symlink+0x24>
<== NOT EXECUTED
4001d284: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4001d288: 96 10 20 01 mov 1, %o3
4001d28c: 94 07 bf 88 add %fp, -120, %o2
4001d290: 7f ff d1 7b call 4001187c <rtems_rfs_inode_open>
4001d294: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d298: b4 92 20 00 orcc %o0, 0, %i2
4001d29c: 14 bf ff dd bg 4001d210 <rtems_rfs_symlink+0x74>
<== NEVER TAKEN
4001d2a0: 80 a7 20 13 cmp %i4, 0x13
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
4001d2a4: 18 80 00 1f bgu 4001d320 <rtems_rfs_symlink+0x184>
<== NEVER TAKEN
4001d2a8: 92 07 bf 88 add %fp, -120, %o1
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
4001d2ac: fa 07 bf 94 ld [ %fp + -108 ], %i5
4001d2b0: 82 07 60 1c add %i5, 0x1c, %g1
4001d2b4: 94 10 20 14 mov 0x14, %o2
4001d2b8: 90 10 00 01 mov %g1, %o0
4001d2bc: 40 00 05 5c call 4001e82c <memset>
4001d2c0: 92 10 20 00 clr %o1
memcpy (inode.node->data.name, link, link_length);
4001d2c4: 94 10 00 1c mov %i4, %o2
4001d2c8: 40 00 04 cf call 4001e604 <memcpy>
4001d2cc: 92 10 00 1b mov %i3, %o1
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
4001d2d0: c0 2f 60 0c clrb [ %i5 + 0xc ]
4001d2d4: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001d2d8: c0 28 60 0d clrb [ %g1 + 0xd ]
4001d2dc: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001d2e0: c0 28 60 0e clrb [ %g1 + 0xe ]
4001d2e4: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001d2e8: c0 28 60 0f clrb [ %g1 + 0xf ]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001d2ec: 83 2f 20 10 sll %i4, 0x10, %g1
4001d2f0: c4 07 bf 94 ld [ %fp + -108 ], %g2
4001d2f4: 83 30 60 18 srl %g1, 0x18, %g1
4001d2f8: c2 28 a0 0a stb %g1, [ %g2 + 0xa ]
rc = rtems_rfs_inode_close (fs, &inode);
4001d2fc: 92 07 bf 88 add %fp, -120, %o1
4001d300: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001d304: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001d308: 82 10 20 01 mov 1, %g1
4001d30c: 90 10 00 18 mov %i0, %o0
4001d310: 7f ff d1 d2 call 40011a58 <rtems_rfs_inode_close>
4001d314: c2 2f bf 98 stb %g1, [ %fp + -104 ]
return rc;
4001d318: 10 bf ff be b 4001d210 <rtems_rfs_symlink+0x74>
4001d31c: b4 10 00 08 mov %o0, %i2
rc = rtems_rfs_block_map_open (fs, &inode, &map);
4001d320: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001d324: 7f ff ef 77 call 40019100 <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001d328: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d32c: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001d330: 04 80 00 05 ble 4001d344 <rtems_rfs_symlink+0x1a8>
<== NOT EXECUTED
4001d334: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001d338: 7f ff d1 c8 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001d33c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rc;
4001d340: 30 bf ff b4 b,a 4001d210 <rtems_rfs_symlink+0x74>
<== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001d344: 96 07 bf 78 add %fp, -136, %o3
<== NOT EXECUTED
4001d348: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4001d34c: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d350: 7f ff f0 c2 call 40019658 <rtems_rfs_block_map_grow>
<== NOT EXECUTED
4001d354: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d358: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001d35c: 04 80 00 07 ble 4001d378 <rtems_rfs_symlink+0x1dc>
<== NOT EXECUTED
4001d360: d4 07 bf 78 ld [ %fp + -136 ], %o2
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001d364: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d368: 7f ff ef c5 call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d36c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001d370: 10 bf ff f2 b 4001d338 <rtems_rfs_symlink+0x19c>
<== NOT EXECUTED
4001d374: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
handle->dirty = false;
4001d378: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4001d37c: 96 10 20 00 clr %o3
<== NOT EXECUTED
handle->bnum = 0;
4001d380: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001d384: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
handle->buffer = NULL;
4001d388: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
4001d38c: 7f ff c9 4f call 4000f8c8 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001d390: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d394: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001d398: 14 bf ff f4 bg 4001d368 <rtems_rfs_symlink+0x1cc>
<== NOT EXECUTED
4001d39c: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
4001d3a0: c2 07 bf 84 ld [ %fp + -124 ], %g1
<== NOT EXECUTED
4001d3a4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
4001d3a8: d4 06 20 08 ld [ %i0 + 8 ], %o2
<== NOT EXECUTED
4001d3ac: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4001d3b0: 40 00 05 1f call 4001e82c <memset>
<== NOT EXECUTED
4001d3b4: 92 10 20 ff mov 0xff, %o1
<== NOT EXECUTED
memcpy (data, link, link_length);
4001d3b8: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4001d3bc: 40 00 04 92 call 4001e604 <memcpy>
<== NOT EXECUTED
4001d3c0: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d3c4: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
4001d3c8: 7f ff ca 07 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001d3cc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
4001d3d0: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001d3d4: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
4001d3d8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001d3dc: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001d3e0: 7f ff ef a7 call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d3e4: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
if (rc > 0)
4001d3e8: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4001d3ec: 04 bf ff c1 ble 4001d2f0 <rtems_rfs_symlink+0x154>
<== NOT EXECUTED
4001d3f0: 83 2f 20 10 sll %i4, 0x10, %g1
<== NOT EXECUTED
4001d3f4: 10 bf ff d1 b 4001d338 <rtems_rfs_symlink+0x19c>
<== NOT EXECUTED
4001d3f8: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
4001d3fc <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)
{
4001d3fc: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
4001d400: 90 10 20 04 mov 4, %o0
4001d404: 7f ff d7 53 call 40013150 <rtems_rfs_trace>
4001d408: 92 10 20 00 clr %o1
4001d40c: 80 a2 20 00 cmp %o0, 0
4001d410: 12 80 00 2f bne 4001d4cc <rtems_rfs_symlink_read+0xd0>
<== NEVER TAKEN
4001d414: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001d418: 96 10 20 01 mov 1, %o3
4001d41c: 94 07 bf 88 add %fp, -120, %o2
4001d420: 92 10 00 19 mov %i1, %o1
4001d424: 7f ff d1 16 call 4001187c <rtems_rfs_inode_open>
4001d428: 90 10 00 18 mov %i0, %o0
if (rc)
4001d42c: ba 92 20 00 orcc %o0, 0, %i5
4001d430: 12 80 00 25 bne 4001d4c4 <rtems_rfs_symlink_read+0xc8>
<== NEVER TAKEN
4001d434: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
4001d438: 05 00 00 3c sethi %hi(0xf000), %g2
return rtems_rfs_read_u16 (&handle->node->mode);
4001d43c: c2 0a 60 02 ldub [ %o1 + 2 ], %g1
4001d440: 83 28 60 08 sll %g1, 8, %g1
4001d444: 82 08 40 02 and %g1, %g2, %g1
4001d448: 05 00 00 28 sethi %hi(0xa000), %g2
4001d44c: 80 a0 40 02 cmp %g1, %g2
4001d450: 32 80 00 3e bne,a 4001d548 <rtems_rfs_symlink_read+0x14c>
<== NEVER TAKEN
4001d454: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001d458: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
4001d45c: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
4001d460: 95 2a a0 08 sll %o2, 8, %o2
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4001d464: 94 12 80 01 or %o2, %g1, %o2
4001d468: 80 a2 80 1b cmp %o2, %i3
4001d46c: 38 80 00 28 bgu,a 4001d50c <rtems_rfs_symlink_read+0x110>
4001d470: 94 10 00 1b mov %i3, %o2
4001d474: d4 27 00 00 st %o2, [ %i4 ]
return rtems_rfs_read_u32 (&handle->node->block_count);
4001d478: c6 0a 60 0c ldub [ %o1 + 0xc ], %g3
4001d47c: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
4001d480: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
4001d484: c8 0a 60 0f ldub [ %o1 + 0xf ], %g4
4001d488: 87 28 e0 18 sll %g3, 0x18, %g3
4001d48c: 85 28 a0 10 sll %g2, 0x10, %g2
4001d490: 83 28 60 08 sll %g1, 8, %g1
4001d494: 84 10 80 03 or %g2, %g3, %g2
4001d498: 82 10 40 02 or %g1, %g2, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001d49c: 80 91 00 01 orcc %g4, %g1, %g0
4001d4a0: 32 80 00 10 bne,a 4001d4e0 <rtems_rfs_symlink_read+0xe4>
<== NEVER TAKEN
4001d4a4: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
4001d4a8: 92 02 60 1c add %o1, 0x1c, %o1
4001d4ac: 40 00 04 56 call 4001e604 <memcpy>
4001d4b0: 90 10 00 1a mov %i2, %o0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
4001d4b4: 92 07 bf 88 add %fp, -120, %o1
4001d4b8: 7f ff d1 68 call 40011a58 <rtems_rfs_inode_close>
4001d4bc: 90 10 00 18 mov %i0, %o0
4001d4c0: ba 10 00 08 mov %o0, %i5
return rc;
}
4001d4c4: 81 c7 e0 08 ret
4001d4c8: 91 e8 00 1d restore %g0, %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
4001d4cc: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d4d0: 7f ff d7 ae call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d4d4: 90 12 23 00 or %o0, 0x300, %o0 ! 40024700 <status_code_to_errno+0x11e4>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
4001d4d8: 10 bf ff d1 b 4001d41c <rtems_rfs_symlink_read+0x20>
<== NOT EXECUTED
4001d4dc: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
4001d4e0: 94 07 bf b0 add %fp, -80, %o2
<== NOT EXECUTED
4001d4e4: 7f ff ef 07 call 40019100 <rtems_rfs_block_map_open>
<== NOT EXECUTED
4001d4e8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d4ec: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001d4f0: 04 80 00 1b ble 4001d55c <rtems_rfs_symlink_read+0x160>
<== NOT EXECUTED
4001d4f4: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001d4f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001d4fc: 7f ff d1 57 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001d500: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4001d504: 81 c7 e0 08 ret
<== NOT EXECUTED
4001d508: 81 e8 00 00 restore
<== NOT EXECUTED
4001d50c: d4 27 00 00 st %o2, [ %i4 ]
4001d510: c6 0a 60 0c ldub [ %o1 + 0xc ], %g3
4001d514: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
4001d518: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
4001d51c: c8 0a 60 0f ldub [ %o1 + 0xf ], %g4
4001d520: 87 28 e0 18 sll %g3, 0x18, %g3
4001d524: 85 28 a0 10 sll %g2, 0x10, %g2
4001d528: 83 28 60 08 sll %g1, 8, %g1
4001d52c: 84 10 80 03 or %g2, %g3, %g2
4001d530: 82 10 40 02 or %g1, %g2, %g1
if (rtems_rfs_inode_get_block_count (&inode) == 0)
4001d534: 80 91 00 01 orcc %g4, %g1, %g0
4001d538: 32 bf ff ea bne,a 4001d4e0 <rtems_rfs_symlink_read+0xe4>
<== NEVER TAKEN
4001d53c: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
memcpy (path, inode.node->data.name, *length);
4001d540: 10 bf ff db b 4001d4ac <rtems_rfs_symlink_read+0xb0>
4001d544: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
4001d548: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001d54c: 7f ff d1 43 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001d550: ba 10 20 16 mov 0x16, %i5
<== NOT EXECUTED
}
4001d554: 81 c7 e0 08 ret
<== NOT EXECUTED
4001d558: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001d55c: 98 07 bf 78 add %fp, -136, %o4
<== NOT EXECUTED
4001d560: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001d564: 96 10 20 00 clr %o3
<== NOT EXECUTED
4001d568: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d56c: 7f ff f0 10 call 400195ac <rtems_rfs_block_map_seek>
<== NOT EXECUTED
4001d570: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d574: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001d578: 04 80 00 07 ble 4001d594 <rtems_rfs_symlink_read+0x198>
<== NOT EXECUTED
4001d57c: d4 07 bf 78 ld [ %fp + -136 ], %o2
<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001d580: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001d584: 7f ff ef 3e call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d588: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4001d58c: 10 bf ff db b 4001d4f8 <rtems_rfs_symlink_read+0xfc>
<== NOT EXECUTED
4001d590: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
handle->dirty = false;
4001d594: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4001d598: 96 10 20 00 clr %o3
<== NOT EXECUTED
handle->bnum = 0;
4001d59c: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001d5a0: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
handle->buffer = NULL;
4001d5a4: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
4001d5a8: 7f ff c8 c8 call 4000f8c8 <rtems_rfs_buffer_handle_request>
<== NOT EXECUTED
4001d5ac: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (rc > 0)
4001d5b0: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001d5b4: 14 bf ff f4 bg 4001d584 <rtems_rfs_symlink_read+0x188>
<== NOT EXECUTED
4001d5b8: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
memcpy (path, data, *length);
4001d5bc: c2 07 bf 84 ld [ %fp + -124 ], %g1
<== NOT EXECUTED
4001d5c0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
<== NOT EXECUTED
4001d5c4: d4 07 00 00 ld [ %i4 ], %o2
<== NOT EXECUTED
4001d5c8: 40 00 04 0f call 4001e604 <memcpy>
<== NOT EXECUTED
4001d5cc: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4001d5d0: 92 07 bf 7c add %fp, -132, %o1
<== NOT EXECUTED
4001d5d4: 7f ff c9 84 call 4000fbe4 <rtems_rfs_buffer_handle_release>
<== NOT EXECUTED
4001d5d8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
4001d5dc: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
handle->dirty = false;
4001d5e0: c0 2f bf 7c clrb [ %fp + -132 ]
<== NOT EXECUTED
4001d5e4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
handle->bnum = 0;
4001d5e8: c0 27 bf 80 clr [ %fp + -128 ]
<== NOT EXECUTED
4001d5ec: 7f ff ef 24 call 4001927c <rtems_rfs_block_map_close>
<== NOT EXECUTED
4001d5f0: c0 27 bf 84 clr [ %fp + -124 ]
<== NOT EXECUTED
if (rc > 0)
4001d5f4: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001d5f8: 04 bf ff b0 ble 4001d4b8 <rtems_rfs_symlink_read+0xbc>
<== NOT EXECUTED
4001d5fc: 92 07 bf 88 add %fp, -120, %o1
<== NOT EXECUTED
4001d600: 10 bf ff bf b 4001d4fc <rtems_rfs_symlink_read+0x100>
<== NOT EXECUTED
4001d604: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40013150 <rtems_rfs_trace>:
bool
rtems_rfs_trace (rtems_rfs_trace_mask mask)
{
bool result = false;
if (mask & rtems_rfs_trace_flags)
40013150: 03 10 00 9e sethi %hi(0x40027800), %g1
40013154: 84 10 60 a8 or %g1, 0xa8, %g2 ! 400278a8 <rtems_rfs_trace_flags>
40013158: c2 00 60 a8 ld [ %g1 + 0xa8 ], %g1
4001315c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40013160: 90 08 40 08 and %g1, %o0, %o0
40013164: 92 08 80 09 and %g2, %o1, %o1
40013168: 90 12 00 09 or %o0, %o1, %o0
result = true;
return result;
}
4001316c: 80 a0 00 08 cmp %g0, %o0
40013170: 81 c3 e0 08 retl
40013174: 90 40 20 00 addx %g0, 0, %o0
...
4001cd44 <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)
{
4001cd44: 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))
4001cd48: 90 10 20 00 clr %o0
4001cd4c: 7f ff d9 01 call 40013150 <rtems_rfs_trace>
4001cd50: 13 00 80 00 sethi %hi(0x2000000), %o1
4001cd54: 80 a2 20 00 cmp %o0, 0
4001cd58: 12 80 00 30 bne 4001ce18 <rtems_rfs_unlink+0xd4>
<== NEVER TAKEN
4001cd5c: 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);
4001cd60: 96 10 20 01 mov 1, %o3
4001cd64: 94 07 bf d8 add %fp, -40, %o2
4001cd68: 92 10 00 1a mov %i2, %o1
4001cd6c: 7f ff d2 c4 call 4001187c <rtems_rfs_inode_open>
4001cd70: 90 10 00 18 mov %i0, %o0
if (rc)
4001cd74: ba 92 20 00 orcc %o0, 0, %i5
4001cd78: 12 80 00 26 bne 4001ce10 <rtems_rfs_unlink+0xcc>
<== NEVER TAKEN
4001cd7c: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001cd80: 05 00 00 3c sethi %hi(0xf000), %g2
return rtems_rfs_read_u16 (&handle->node->mode);
4001cd84: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001cd88: 83 28 60 08 sll %g1, 8, %g1
4001cd8c: 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)
4001cd90: 05 00 00 10 sethi %hi(0x4000), %g2
4001cd94: 80 a0 40 02 cmp %g1, %g2
4001cd98: 12 80 00 0d bne 4001cdcc <rtems_rfs_unlink+0x88>
4001cd9c: a1 28 60 10 sll %g1, 0x10, %l0
{
switch (dir_mode)
4001cda0: 80 a7 20 00 cmp %i4, 0
4001cda4: 02 80 00 72 be 4001cf6c <rtems_rfs_unlink+0x228>
<== NEVER TAKEN
4001cda8: 80 a7 20 01 cmp %i4, 1
4001cdac: 12 80 00 09 bne 4001cdd0 <rtems_rfs_unlink+0x8c>
<== NEVER TAKEN
4001cdb0: 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);
4001cdb4: 92 07 bf d8 add %fp, -40, %o1
4001cdb8: 7f ff f8 7d call 4001afac <rtems_rfs_dir_empty>
4001cdbc: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001cdc0: ba 92 20 00 orcc %o0, 0, %i5
4001cdc4: 14 80 00 81 bg 4001cfc8 <rtems_rfs_unlink+0x284>
4001cdc8: 90 10 20 00 clr %o0
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001cdcc: 96 10 20 01 mov 1, %o3
4001cdd0: 94 07 bf b0 add %fp, -80, %o2
4001cdd4: 92 10 00 19 mov %i1, %o1
4001cdd8: 7f ff d2 a9 call 4001187c <rtems_rfs_inode_open>
4001cddc: 90 10 00 18 mov %i0, %o0
if (rc)
4001cde0: ba 92 20 00 orcc %o0, 0, %i5
4001cde4: 02 80 00 13 be 4001ce30 <rtems_rfs_unlink+0xec>
<== ALWAYS TAKEN
4001cde8: 96 10 00 1b mov %i3, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001cdec: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001cdf0: 7f ff d8 d8 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001cdf4: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001cdf8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cdfc: 12 80 00 6a bne 4001cfa4 <rtems_rfs_unlink+0x260>
<== NOT EXECUTED
4001ce00: 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);
4001ce04: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001ce08: 7f ff d3 14 call 40011a58 <rtems_rfs_inode_close>
4001ce0c: 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;
}
4001ce10: 81 c7 e0 08 ret
4001ce14: 91 e8 00 1d restore %g0, %i5, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
4001ce18: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001ce1c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001ce20: 7f ff d9 5a call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001ce24: 90 12 21 00 or %o0, 0x100, %o0 ! 40024500 <status_code_to_errno+0xfe4>
<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001ce28: 10 bf ff cf b 4001cd64 <rtems_rfs_unlink+0x20>
<== NOT EXECUTED
4001ce2c: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
4001ce30: 94 10 00 1a mov %i2, %o2
4001ce34: 92 07 bf b0 add %fp, -80, %o1
4001ce38: 7f ff f6 5e call 4001a7b0 <rtems_rfs_dir_del_entry>
4001ce3c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001ce40: ba 92 20 00 orcc %o0, 0, %i5
4001ce44: 14 80 00 34 bg 4001cf14 <rtems_rfs_unlink+0x1d0>
<== NEVER TAKEN
4001ce48: c2 07 bf e4 ld [ %fp + -28 ], %g1
links = rtems_rfs_read_u16 (&handle->node->links);
4001ce4c: fa 08 40 00 ldub [ %g1 ], %i5
4001ce50: c2 08 60 01 ldub [ %g1 + 1 ], %g1
4001ce54: bb 2f 60 08 sll %i5, 8, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001ce58: 90 10 20 00 clr %o0
4001ce5c: ba 17 40 01 or %i5, %g1, %i5
if (links == 0xffff)
4001ce60: b9 2f 60 10 sll %i5, 0x10, %i4
4001ce64: 03 00 00 3f sethi %hi(0xfc00), %g1
4001ce68: b7 37 20 10 srl %i4, 0x10, %i3
4001ce6c: 82 10 63 ff or %g1, 0x3ff, %g1
4001ce70: 80 a6 c0 01 cmp %i3, %g1
4001ce74: 02 80 00 69 be 4001d018 <rtems_rfs_unlink+0x2d4>
<== NEVER TAKEN
4001ce78: 13 00 80 00 sethi %hi(0x2000000), %o1
4001ce7c: 7f ff d8 b5 call 40013150 <rtems_rfs_trace>
4001ce80: 01 00 00 00 nop
4001ce84: 80 a2 20 00 cmp %o0, 0
4001ce88: 12 80 00 5e bne 4001d000 <rtems_rfs_unlink+0x2bc>
<== NEVER TAKEN
4001ce8c: 94 10 00 1b mov %i3, %o2
if (links > 1)
4001ce90: b9 37 20 10 srl %i4, 0x10, %i4
4001ce94: 80 a7 20 01 cmp %i4, 1
4001ce98: 08 80 00 6a bleu 4001d040 <rtems_rfs_unlink+0x2fc>
4001ce9c: c4 07 bf e4 ld [ %fp + -28 ], %g2
links--;
4001cea0: ba 07 7f ff add %i5, -1, %i5
rtems_rfs_write_u16 (&handle->node->links, links);
4001cea4: 83 2f 60 10 sll %i5, 0x10, %g1
4001cea8: 83 30 60 18 srl %g1, 0x18, %g1
4001ceac: c2 28 80 00 stb %g1, [ %g2 ]
4001ceb0: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001ceb4: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ceb8: 82 10 20 01 mov 1, %g1
4001cebc: c2 2f bf e8 stb %g1, [ %fp + -24 ]
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
4001cec0: 94 10 20 01 mov 1, %o2
4001cec4: 92 10 20 01 mov 1, %o1
4001cec8: 7f ff d3 54 call 40011c18 <rtems_rfs_inode_time_stamp_now>
4001cecc: 90 07 bf b0 add %fp, -80, %o0
if (rc > 0)
4001ced0: ba 92 20 00 orcc %o0, 0, %i5
4001ced4: 04 80 00 79 ble 4001d0b8 <rtems_rfs_unlink+0x374>
<== ALWAYS TAKEN
4001ced8: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001cedc: 7f ff d8 9d call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001cee0: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001cee4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cee8: 22 80 00 19 be,a 4001cf4c <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001ceec: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
4001cef0: 40 00 09 6c call 4001f4a0 <strerror>
<== NOT EXECUTED
4001cef4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001cef8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cefc: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001cf00: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cf04: 7f ff d9 21 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001cf08: 90 12 22 28 or %o0, 0x228, %o0 ! 40024628 <status_code_to_errno+0x110c>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001cf0c: 10 80 00 10 b 4001cf4c <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001cf10: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001cf14: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001cf18: 7f ff d8 8e call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001cf1c: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001cf20: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cf24: 02 80 00 0a be 4001cf4c <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001cf28: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
4001cf2c: 40 00 09 5d call 4001f4a0 <strerror>
<== NOT EXECUTED
4001cf30: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001cf34: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cf38: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001cf3c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cf40: 7f ff d9 12 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001cf44: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400245a0 <status_code_to_errno+0x1084>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001cf48: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
4001cf4c: 7f ff d2 c3 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cf50: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cf54: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001cf58: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001cf5c: 7f ff d2 bf call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cf60: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4001cf64: 81 c7 e0 08 ret
<== NOT EXECUTED
4001cf68: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001cf6c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001cf70: 7f ff d8 78 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001cf74: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001cf78: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001cf7c: 02 80 00 06 be 4001cf94 <rtems_rfs_unlink+0x250>
<== NOT EXECUTED
4001cf80: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
4001cf84: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cf88: 7f ff d9 0f call 400133c4 <__wrap_puts>
<== NOT EXECUTED
4001cf8c: 90 12 21 30 or %o0, 0x130, %o0 ! 40024530 <status_code_to_errno+0x1014>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cf90: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
4001cf94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001cf98: 7f ff d2 b0 call 40011a58 <rtems_rfs_inode_close>
<== NOT EXECUTED
4001cf9c: ba 10 20 15 mov 0x15, %i5
<== NOT EXECUTED
return EISDIR;
4001cfa0: 30 bf ff 9c b,a 4001ce10 <rtems_rfs_unlink+0xcc>
<== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
4001cfa4: 40 00 09 3f call 4001f4a0 <strerror>
<== NOT EXECUTED
4001cfa8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001cfac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cfb0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001cfb4: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cfb8: 7f ff d8 f4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001cfbc: 90 12 21 70 or %o0, 0x170, %o0 ! 40024570 <status_code_to_errno+0x1054>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cfc0: 10 bf ff 92 b 4001ce08 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001cfc4: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001cfc8: 7f ff d8 62 call 40013150 <rtems_rfs_trace>
4001cfcc: 13 00 80 00 sethi %hi(0x2000000), %o1
4001cfd0: 80 a2 20 00 cmp %o0, 0
4001cfd4: 22 bf ff 8d be,a 4001ce08 <rtems_rfs_unlink+0xc4>
<== ALWAYS TAKEN
4001cfd8: 92 07 bf d8 add %fp, -40, %o1
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4001cfdc: 40 00 09 31 call 4001f4a0 <strerror>
<== NOT EXECUTED
4001cfe0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001cfe4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001cfe8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001cfec: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001cff0: 7f ff d8 e6 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001cff4: 90 12 21 50 or %o0, 0x150, %o0 ! 40024550 <status_code_to_errno+0x1034>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001cff8: 10 bf ff 84 b 4001ce08 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001cffc: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001d000: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001d004: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d008: 7f ff d8 e0 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d00c: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400245d0 <status_code_to_errno+0x10b4>
<== NOT EXECUTED
if (links > 1)
4001d010: 10 bf ff a1 b 4001ce94 <rtems_rfs_unlink+0x150>
<== NOT EXECUTED
4001d014: b9 37 20 10 srl %i4, 0x10, %i4
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001d018: 7f ff d8 4e call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001d01c: 01 00 00 00 nop
<== NOT EXECUTED
4001d020: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d024: 02 80 00 08 be 4001d044 <rtems_rfs_unlink+0x300>
<== NOT EXECUTED
4001d028: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
4001d02c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d030: 94 10 20 00 clr %o2
<== NOT EXECUTED
4001d034: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4001d038: 7f ff d8 d4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d03c: 90 12 21 d0 or %o0, 0x1d0, %o0
<== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
4001d040: 92 07 bf d8 add %fp, -40, %o1
4001d044: 7f ff d2 ab call 40011af0 <rtems_rfs_inode_delete>
4001d048: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d04c: ba 92 20 00 orcc %o0, 0, %i5
4001d050: 14 80 00 41 bg 4001d154 <rtems_rfs_unlink+0x410>
<== NEVER TAKEN
4001d054: 03 10 00 00 sethi %hi(0x40000000), %g1
if (dir)
4001d058: 80 a4 00 01 cmp %l0, %g1
4001d05c: 12 bf ff 9a bne 4001cec4 <rtems_rfs_unlink+0x180>
4001d060: 94 10 20 01 mov 1, %o2
4001d064: c4 07 bf bc ld [ %fp + -68 ], %g2
links = rtems_rfs_read_u16 (&handle->node->links);
4001d068: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001d06c: c2 08 80 00 ldub [ %g2 ], %g1
4001d070: 83 28 60 08 sll %g1, 8, %g1
4001d074: 82 10 40 03 or %g1, %g3, %g1
if (links == 0xffff)
4001d078: 07 00 00 3f sethi %hi(0xfc00), %g3
4001d07c: 86 10 e3 ff or %g3, 0x3ff, %g3 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
4001d080: 80 a0 40 03 cmp %g1, %g3
4001d084: 02 80 00 43 be 4001d190 <rtems_rfs_unlink+0x44c>
<== NEVER TAKEN
4001d088: 80 a0 60 01 cmp %g1, 1
if (links > 1)
4001d08c: 08 80 00 05 bleu 4001d0a0 <rtems_rfs_unlink+0x35c>
4001d090: 86 10 20 00 clr %g3
links--;
4001d094: 82 00 7f ff add %g1, -1, %g1
4001d098: 87 28 60 10 sll %g1, 0x10, %g3
4001d09c: 87 30 e0 18 srl %g3, 0x18, %g3
rtems_rfs_write_u16 (&handle->node->links, links);
4001d0a0: c6 28 80 00 stb %g3, [ %g2 ]
4001d0a4: c4 07 bf bc ld [ %fp + -68 ], %g2
4001d0a8: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001d0ac: 82 10 20 01 mov 1, %g1
4001d0b0: 10 bf ff 84 b 4001cec0 <rtems_rfs_unlink+0x17c>
4001d0b4: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rc = rtems_rfs_inode_close (fs, &parent_inode);
4001d0b8: 92 07 bf b0 add %fp, -80, %o1
4001d0bc: 7f ff d2 67 call 40011a58 <rtems_rfs_inode_close>
4001d0c0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001d0c4: ba 92 20 00 orcc %o0, 0, %i5
4001d0c8: 04 80 00 10 ble 4001d108 <rtems_rfs_unlink+0x3c4>
<== ALWAYS TAKEN
4001d0cc: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001d0d0: 7f ff d8 20 call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001d0d4: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001d0d8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d0dc: 22 bf ff 4b be,a 4001ce08 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001d0e0: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
4001d0e4: 40 00 08 ef call 4001f4a0 <strerror>
<== NOT EXECUTED
4001d0e8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001d0ec: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001d0f0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001d0f4: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d0f8: 7f ff d8 a4 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d0fc: 90 12 22 60 or %o0, 0x260, %o0 ! 40024660 <status_code_to_errno+0x1144>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001d100: 10 bf ff 42 b 4001ce08 <rtems_rfs_unlink+0xc4>
<== NOT EXECUTED
4001d104: 92 07 bf d8 add %fp, -40, %o1
<== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &target_inode);
4001d108: 92 07 bf d8 add %fp, -40, %o1
4001d10c: 7f ff d2 53 call 40011a58 <rtems_rfs_inode_close>
4001d110: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001d114: ba 92 20 00 orcc %o0, 0, %i5
4001d118: 04 bf ff 3e ble 4001ce10 <rtems_rfs_unlink+0xcc>
<== ALWAYS TAKEN
4001d11c: 90 10 20 00 clr %o0
4001d120: 7f ff d8 0c call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001d124: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001d128: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d12c: 02 bf ff 39 be 4001ce10 <rtems_rfs_unlink+0xcc>
<== NOT EXECUTED
4001d130: 01 00 00 00 nop
<== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
4001d134: 40 00 08 db call 4001f4a0 <strerror>
<== NOT EXECUTED
4001d138: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001d13c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001d140: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001d144: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d148: 7f ff d8 90 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d14c: 90 12 22 98 or %o0, 0x298, %o0 ! 40024698 <status_code_to_errno+0x117c>
<== NOT EXECUTED
4001d150: 30 bf ff 30 b,a 4001ce10 <rtems_rfs_unlink+0xcc>
<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001d154: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001d158: 7f ff d7 fe call 40013150 <rtems_rfs_trace>
<== NOT EXECUTED
4001d15c: 13 00 80 00 sethi %hi(0x2000000), %o1
<== NOT EXECUTED
4001d160: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001d164: 22 bf ff 7a be,a 4001cf4c <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001d168: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
4001d16c: 40 00 08 cd call 4001f4a0 <strerror>
<== NOT EXECUTED
4001d170: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001d174: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001d178: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001d17c: 11 10 00 91 sethi %hi(0x40024400), %o0
<== NOT EXECUTED
4001d180: 7f ff d8 82 call 40013388 <__wrap_printf>
<== NOT EXECUTED
4001d184: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400245f8 <status_code_to_errno+0x10dc>
<== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4001d188: 10 bf ff 71 b 4001cf4c <rtems_rfs_unlink+0x208>
<== NOT EXECUTED
4001d18c: 92 07 bf b0 add %fp, -80, %o1
<== NOT EXECUTED
if (links == 0xffff)
4001d190: 82 10 20 00 clr %g1
<== NOT EXECUTED
4001d194: 10 bf ff c3 b 4001d0a0 <rtems_rfs_unlink+0x35c>
<== NOT EXECUTED
4001d198: 86 10 20 00 clr %g3
<== NOT EXECUTED